diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 6d356bedb..ec8ed890b 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -130,7 +130,7 @@ jobs: zlib1g-dev \ libjack-jackd2-dev \ appstream - wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" + wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" || wget "https://tildearrow.org/storage/furnace/ci/appimagetool-x86_64.AppImage" chmod +x appimagetool-x86_64.AppImage - name: Install Dependencies [Linux armhf] @@ -151,8 +151,8 @@ jobs: libsndfile1-dev:armhf \ zlib1g-dev:armhf \ libjack-jackd2-dev:armhf - wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" - wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/runtime-armhf" + wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" || wget "https://tildearrow.org/storage/furnace/ci/appimagetool-x86_64.AppImage" + wget "https://github.com/AppImage/AppImageKit/releases/download/continuous/runtime-armhf" || wget "https://tildearrow.org/storage/furnace/ci/runtime-armhf" chmod +x appimagetool-x86_64.AppImage ls /usr/arm-linux-gnueabihf/lib diff --git a/CMakeLists.txt b/CMakeLists.txt index c24a09525..4ea45d8e8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,6 +23,7 @@ set(USE_SNDFILE_DEFAULT ON) set(SYSTEM_SDL2_DEFAULT OFF) include(CheckIncludeFile) +include(TestBigEndian) if (ANDROID) set(USE_RTMIDI_DEFAULT OFF) @@ -72,9 +73,15 @@ option(WITH_INSTRUMENTS "Install instruments" ON) set(DEPENDENCIES_INCLUDE_DIRS "") if (ANDROID AND NOT TERMUX) -set(DEPENDENCIES_DEFINES "IS_MOBILE") + set(DEPENDENCIES_DEFINES "IS_MOBILE") else() -set(DEPENDENCIES_DEFINES "") + set(DEPENDENCIES_DEFINES "") +endif() + +TEST_BIG_ENDIAN(IS_BIG_ENDIAN) + +if (IS_BIG_ENDIAN) + list(APPEND DEPENDENCIES_DEFINES "TA_BIG_ENDIAN") endif() set(DEPENDENCIES_COMPILE_OPTIONS "") @@ -547,6 +554,8 @@ src/gui/stats.cpp src/gui/subSongs.cpp src/gui/sysConf.cpp src/gui/sysEx.cpp +src/gui/sysManager.cpp +src/gui/sysPicker.cpp src/gui/util.cpp src/gui/waveEdit.cpp src/gui/volMeter.cpp diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 51903d8b7..c6931ce8f 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -33,6 +33,7 @@ the coding style is described here: - indent switch cases - preprocessor directives not intended - if macro comprises more than one line, indent + - no new line after `template<>` - prefer built-in types: - `bool` - `signed char` or `unsigned char` are 8-bit @@ -81,6 +82,7 @@ just put your demo song in `demos/`! be noted there are some guidelines: - avoid Nintendo song covers. - avoid big label song covers. +- avoid poor quality songs. # Finishing diff --git a/TODO.md b/TODO.md index 13f31300e..cba0b7c65 100644 --- a/TODO.md +++ b/TODO.md @@ -1,5 +1,5 @@ # to-do for 0.6pre1.5-0.6pre2 - volume commands should work on Game Boy -- ability to customize `OFF`, `===` and `REL` - stereo separation control for AY +- "paste with instrument" \ No newline at end of file diff --git a/demos/BONUS. Sonic 2 Boss.fur b/demos/BONUS. Sonic 2 Boss.fur new file mode 100644 index 000000000..8f5263f79 Binary files /dev/null and b/demos/BONUS. Sonic 2 Boss.fur differ diff --git a/demos/Silver Surfer - Stage Music 1.fur b/demos/Silver Surfer - Stage Music 1.fur new file mode 100644 index 000000000..bbe6a3c77 Binary files /dev/null and b/demos/Silver Surfer - Stage Music 1.fur differ diff --git a/demos/The_only_thing_the_Metallix_fear_is_you_Forte....fur b/demos/The_only_thing_the_Metallix_fear_is_you_Forte....fur deleted file mode 100644 index 123381d8d..000000000 Binary files a/demos/The_only_thing_the_Metallix_fear_is_you_Forte....fur and /dev/null differ diff --git a/demos/Waterworld_-_Map.fur b/demos/Waterworld_-_Map.fur new file mode 100644 index 000000000..2bf8a7af7 Binary files /dev/null and b/demos/Waterworld_-_Map.fur differ diff --git a/demos/government funding breakcore-ish remix.fur b/demos/government funding breakcore-ish remix.fur new file mode 100644 index 000000000..7acbabc49 Binary files /dev/null and b/demos/government funding breakcore-ish remix.fur differ diff --git a/demos/rule2.fur b/demos/rule2.fur new file mode 100644 index 000000000..aa6375916 Binary files /dev/null and b/demos/rule2.fur differ diff --git a/papers/format.md b/papers/format.md index 1a8cd7219..def8cba16 100644 --- a/papers/format.md +++ b/papers/format.md @@ -32,6 +32,12 @@ these fields are 0 in format versions prior to 100 (0.6pre1). the format versions are: +- 112: Furnace dev112 +- 111: Furnace dev111 +- 110: Furnace dev110 +- 109: Furnace dev109 +- 108: Furnace dev108 +- 107: Furnace dev107 - 106: Furnace dev106 - 105: Furnace dev105 - 104: Furnace dev104 @@ -330,7 +336,9 @@ size | description 1 | broken outVol (>=99) or reserved 1 | E1xy and E2xy stop on same note (>=100) or reserved 1 | broken initial position of porta after arp (>=101) or reserved - 7 | reserved + 1 | SN periods under 8 are treated as 1 (>=108) or reserved + 1 | cut/delay effect policy (>=110) or reserved + 5 | reserved --- | **virtual tempo data** 2 | virtual tempo numerator of first song (>=96) or reserved 2 | virtual tempo denominator of first song (>=96) or reserved @@ -447,6 +455,7 @@ size | description | - 29: SNES | - 30: Sound Unit | - 31: Namco WSG + | - 32: OPL (drums) 1 | reserved STR | instrument name --- | **FM instrument data** @@ -538,7 +547,18 @@ size | description 4 | extra 1 macro loop (>=17) 4 | extra 2 macro loop (>=17) 4 | extra 3 macro loop (>=17) - 1 | arp macro mode + 1 | arp macro mode (<112) or reserved + | - treat this value in a special way. + | - before version 112, this byte indicates whether the arp macro mode is fixed or not. + | - from that version onwards, the fixed mode is part of the macro values. + | - to convert a <112 macro mode to a modern one, do the following: + | - is the macro mode set to fixed? + | - if yes, then: + | - set bit 30 of all arp macro values (this is the fixed mode bit) + | - does the macro loop? + | - if yes, then do nothing else + | - if no, then add one to the macro length, and set the last macro value to 0 + | - if no, then do nothing 1 | reserved (>=17) or volume macro height (>=15) or reserved 1 | reserved (>=17) or duty macro height (>=15) or reserved 1 | reserved (>=17) or wave macro height (>=15) or reserved @@ -546,6 +566,7 @@ size | description | - before version 87, if this is the C64 relative cutoff macro, its values were stored offset by 18. 4?? | arp macro | - before version 31, this macro's values were stored offset by 12. + | - from version 112 onward, bit 30 of a value indicates fixed mode. 4?? | duty macro | - before version 87, if this is the C64 relative duty macro, its values were stored offset by 12. 4?? | wave macro @@ -850,6 +871,111 @@ size | description --- | **Game Boy extra flags** (>=106) 1 | use software envelope 1 | always init hard env on new note + --- | **ES5506 data** (>=107) + 1 | filter mode + | - 0: HPK2_HPK2 + | - 1: HPK2_LPK1 + | - 2: LPK2_LPK2 + | - 3: LPK2_LPK1 + 2 | K1 + 2 | K2 + 2 | envelope count + 1 | left volume ramp + 1 | right volume ramp + 1 | K1 ramp + 1 | K2 ramp + 1 | K1 slow + 1 | K2 slow + --- | **SNES data** (>=109) + 1 | use envelope + 1 | gain mode + 1 | gain + 1 | attack + 1 | decay + 1 | sustain + 1 | release + --- | **macro speeds/delays** (>=111) + 1 | volume macro speed + 1 | arp macro speed + 1 | duty macro speed + 1 | wave macro speed + 1 | pitch macro speed + 1 | extra 1 macro speed + 1 | extra 2 macro speed + 1 | extra 3 macro speed + 1 | alg macro speed + 1 | fb macro speed + 1 | fms macro speed + 1 | ams macro speed + 1 | left panning macro speed + 1 | right panning macro speed + 1 | phase reset macro speed + 1 | extra 4 macro speed + 1 | extra 5 macro speed + 1 | extra 6 macro speed + 1 | extra 7 macro speed + 1 | extra 8 macro speed + 1 | volume macro delay + 1 | arp macro delay + 1 | duty macro delay + 1 | wave macro delay + 1 | pitch macro delay + 1 | extra 1 macro delay + 1 | extra 2 macro delay + 1 | extra 3 macro delay + 1 | alg macro delay + 1 | fb macro delay + 1 | fms macro delay + 1 | ams macro delay + 1 | left panning macro delay + 1 | right panning macro delay + 1 | phase reset macro delay + 1 | extra 4 macro delay + 1 | extra 5 macro delay + 1 | extra 6 macro delay + 1 | extra 7 macro delay + 1 | extra 8 macro delay + --- | **operator macro speeds/delay** × 4 (>=111) + 1 | AM macro speed + 1 | AR macro speed + 1 | DR macro speed + 1 | MULT macro speed + 1 | RR macro speed + 1 | SL macro speed + 1 | TL macro speed + 1 | DT2 macro speed + 1 | RS macro speed + 1 | DT macro speed + 1 | D2R macro speed + 1 | SSG-EG macro speed + 1 | DAM macro speed + 1 | DVB macro speed + 1 | EGT macro speed + 1 | KSL macro speed + 1 | SUS macro speed + 1 | VIB macro speed + 1 | WS macro speed + 1 | KSR macro speed + 1 | AM macro delay + 1 | AR macro delay + 1 | DR macro delay + 1 | MULT macro delay + 1 | RR macro delay + 1 | SL macro delay + 1 | TL macro delay + 1 | DT2 macro delay + 1 | RS macro delay + 1 | DT macro delay + 1 | D2R macro delay + 1 | SSG-EG macro delay + 1 | DAM macro delay + 1 | DVB macro delay + 1 | EGT macro delay + 1 | KSL macro delay + 1 | SUS macro delay + 1 | VIB macro delay + 1 | WS macro delay + 1 | KSR macro delay ``` # wavetable @@ -860,9 +986,9 @@ size | description 4 | "WAVE" block ID 4 | size of this block STR | wavetable name - 4 | wavetable size - 4 | wavetable min - 4 | wavetable max + 4 | wavetable width + 4 | reserved + 4 | wavetable height 4?? | wavetable data ``` diff --git a/src/audio/sdlAudio.cpp b/src/audio/sdlAudio.cpp index 5c11a0342..f1d0e1e9d 100644 --- a/src/audio/sdlAudio.cpp +++ b/src/audio/sdlAudio.cpp @@ -110,7 +110,11 @@ bool TAAudioSDL::init(TAAudioDesc& request, TAAudioDesc& response) { desc.outFormat=TA_AUDIO_FORMAT_F32; ac.freq=desc.rate; +#ifdef TA_BIG_ENDIAN + ac.format=AUDIO_F32MSB; +#else ac.format=AUDIO_F32; +#endif ac.channels=desc.outChans; ac.samples=desc.bufsize; ac.callback=taSDLProcess; diff --git a/src/engine/dispatch.h b/src/engine/dispatch.h index fb9be5800..2fde9addd 100644 --- a/src/engine/dispatch.h +++ b/src/engine/dispatch.h @@ -417,13 +417,6 @@ class DivDispatch { */ virtual bool getWantPreNote(); - /** - * get a description of a dispatch-specific effect. - * @param effect the effect. - * @return the description, or NULL if effect is invalid. - */ - virtual const char* getEffectName(unsigned char effect); - /** * set the chip flags. * @param flags the flags. see song.h for possible values. diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp index 68c492219..1230cb599 100644 --- a/src/engine/engine.cpp +++ b/src/engine/engine.cpp @@ -18,6 +18,7 @@ */ #include "dispatch.h" +#include "song.h" #define _USE_MATH_DEFINES #include "engine.h" #include "instrument.h" @@ -124,8 +125,15 @@ const char* DivEngine::getEffectDesc(unsigned char effect, int chan, bool notNul if ((effect&0xf0)==0x90) { return "9xxx: Set sample offset*256"; } else if (chan>=0 && changetEffectName(effect); - if (ret!=NULL) return ret; + DivSysDef* sysDef=sysDefs[sysOfChan[chan]]; + auto iter=sysDef->effectHandlers.find(effect); + if (iter!=sysDef->effectHandlers.end()) { + return iter->second.description; + } + iter=sysDef->postEffectHandlers.find(effect); + if (iter!=sysDef->postEffectHandlers.end()) { + return iter->second.description; + } } break; } @@ -1379,6 +1387,115 @@ bool DivEngine::removeSystem(int index, bool preserveOrder) { return true; } +bool DivEngine::swapSystem(int src, int dest, bool preserveOrder) { + if (src==dest) { + lastError="source and destination are equal"; + return false; + } + if (src<0 || src>=song.systemLen) { + lastError="invalid source index"; + return false; + } + if (dest<0 || dest>=song.systemLen) { + lastError="invalid destination index"; + return false; + } + //int chanCount=chans; + quitDispatch(); + BUSY_BEGIN; + saveLock.lock(); + + if (!preserveOrder) { + // move channels + unsigned char unswappedChannels[DIV_MAX_CHANS]; + unsigned char swappedChannels[DIV_MAX_CHANS]; + std::vector> swapList; + std::vector chanList; + + int tchans=0; + + for (int i=0; i& i: swapList) { + for (int& j: i) { + swappedChannels[index++]=j; + } + } + + logV("swap list:"); + for (int i=0; i %d",unswappedChannels[i],swappedChannels[i]); + } + + // swap channels + bool allComplete=false; + while (!allComplete) { + logD("doing swap..."); + allComplete=true; + for (int i=0; i %d -> %d",unswappedChannels[i],unswappedChannels[swappedChannels[i]]); + unswappedChannels[i]^=unswappedChannels[swappedChannels[i]]; + unswappedChannels[swappedChannels[i]]^=unswappedChannels[i]; + unswappedChannels[i]^=unswappedChannels[swappedChannels[i]]; + } + } + } + } + + DivSystem srcSystem=song.system[src]; + + song.system[src]=song.system[dest]; + song.system[dest]=srcSystem; + + song.systemVol[src]^=song.systemVol[dest]; + song.systemVol[dest]^=song.systemVol[src]; + song.systemVol[src]^=song.systemVol[dest]; + + song.systemPan[src]^=song.systemPan[dest]; + song.systemPan[dest]^=song.systemPan[src]; + song.systemPan[src]^=song.systemPan[dest]; + + song.systemFlags[src]^=song.systemFlags[dest]; + song.systemFlags[dest]^=song.systemFlags[src]; + song.systemFlags[src]^=song.systemFlags[dest]; + + recalcChans(); + saveLock.unlock(); + BUSY_END; + initDispatch(); + BUSY_BEGIN; + renderSamples(); + reset(); + BUSY_END; + return true; +} + void DivEngine::poke(int sys, unsigned int addr, unsigned short val) { if (sys<0 || sys>=song.systemLen) return; BUSY_BEGIN; @@ -1654,6 +1771,15 @@ int DivEngine::calcFreq(int base, int pitch, bool period, int octave, int pitch2 base+((pitch*octave)>>1)+pitch2; } +int DivEngine::calcArp(int note, int arp, int offset) { + if (arp<0) { + if (!(arp&0x40000000)) return (arp|0x40000000)+offset; + } else { + if (arp&0x40000000) return (arp&(~0x40000000))+offset; + } + return note+arp; +} + int DivEngine::convertPanSplitToLinear(unsigned int val, unsigned char bits, int range) { int panL=val>>bits; int panR=val&((1<=chans) return; BUSY_BEGIN; - pendingNotes.push(DivNoteEvent(chan,ins,note,vol,true)); + pendingNotes.push_back(DivNoteEvent(chan,ins,note,vol,true)); if (!playing) { reset(); freelance=true; @@ -3096,7 +3222,7 @@ void DivEngine::noteOn(int chan, int ins, int note, int vol) { void DivEngine::noteOff(int chan) { if (chan<0 || chan>=chans) return; BUSY_BEGIN; - pendingNotes.push(DivNoteEvent(chan,-1,-1,-1,false)); + pendingNotes.push_back(DivNoteEvent(chan,-1,-1,-1,false)); if (!playing) { reset(); freelance=true; @@ -3148,7 +3274,7 @@ void DivEngine::autoNoteOn(int ch, int ins, int note, int vol) { if ((!midiPoly) || (isViable[finalChan] && chan[finalChan].midiNote==-1 && (insInst->type==DIV_INS_OPL || getChannelType(finalChan)==finalChanType || notInViableChannel))) { chan[finalChan].midiNote=note; chan[finalChan].midiAge=midiAgeCounter++; - pendingNotes.push(DivNoteEvent(finalChan,ins,note,vol,true)); + pendingNotes.push_back(DivNoteEvent(finalChan,ins,note,vol,true)); return; } if (++finalChan>=chans) { @@ -3169,7 +3295,7 @@ void DivEngine::autoNoteOn(int ch, int ins, int note, int vol) { chan[candidate].midiNote=note; chan[candidate].midiAge=midiAgeCounter++; - pendingNotes.push(DivNoteEvent(candidate,ins,note,vol,true)); + pendingNotes.push_back(DivNoteEvent(candidate,ins,note,vol,true)); } void DivEngine::autoNoteOff(int ch, int note, int vol) { @@ -3181,7 +3307,7 @@ void DivEngine::autoNoteOff(int ch, int note, int vol) { //if (ch<0 || ch>=chans) return; for (int i=0; i #include #include -#include +#include +#include #define addWarning(x) \ if (warnings.empty()) { \ @@ -45,8 +46,8 @@ #define BUSY_BEGIN_SOFT softLocked=true; isBusy.lock(); #define BUSY_END isBusy.unlock(); softLocked=false; -#define DIV_VERSION "dev106" -#define DIV_ENGINE_VERSION 106 +#define DIV_VERSION "dev112" +#define DIV_ENGINE_VERSION 112 // for imports #define DIV_VERSION_MOD 0xff01 @@ -194,7 +195,29 @@ struct DivDispatchContainer { dcOffCompensation(false) {} }; -typedef std::function EffectProcess; +typedef int EffectValConversion(unsigned char,unsigned char); + +struct EffectHandler { + DivDispatchCmds dispatchCmd; + const char* description; + EffectValConversion* val; + EffectValConversion* val2; + EffectHandler( + DivDispatchCmds dispatchCmd_, + const char* description_, + EffectValConversion val_=NULL, + EffectValConversion val2_=NULL + ): + dispatchCmd(dispatchCmd_), + description(description_), + val(val_), + val2(val2_) {} +}; + +struct DivDoNotHandleEffect { +}; + +typedef std::unordered_map EffectHandlerMap; struct DivSysDef { const char* name; @@ -211,8 +234,8 @@ struct DivSysDef { // 0: primary // 1: alternate (usually PCM) DivInstrumentType chanInsType[DIV_MAX_CHANS][2]; - EffectProcess effectFunc; - EffectProcess postEffectFunc; + const EffectHandlerMap effectHandlers; + const EffectHandlerMap postEffectHandlers; DivSysDef( const char* sysName, const char* sysNameJ, unsigned char fileID, unsigned char fileID_DMF, int chans, bool isFMChip, bool isSTDChip, unsigned int vgmVer, bool compound, const char* desc, @@ -221,8 +244,8 @@ struct DivSysDef { std::initializer_list chTypes, std::initializer_list chInsType1, std::initializer_list chInsType2={}, - EffectProcess fxHandler=[](int,unsigned char,unsigned char) -> bool {return false;}, - EffectProcess postFxHandler=[](int,unsigned char,unsigned char) -> bool {return false;}): + const EffectHandlerMap fxHandlers_={}, + const EffectHandlerMap postFxHandlers_={}): name(sysName), nameJ(sysNameJ), description(desc), @@ -233,8 +256,8 @@ struct DivSysDef { isSTD(isSTDChip), isCompound(compound), vgmVersion(vgmVer), - effectFunc(fxHandler), - postEffectFunc(postFxHandler) { + effectHandlers(fxHandlers_), + postEffectHandlers(postFxHandlers_) { memset(chanNames,0,DIV_MAX_CHANS*sizeof(void*)); memset(chanShortNames,0,DIV_MAX_CHANS*sizeof(void*)); memset(chanTypes,0,DIV_MAX_CHANS*sizeof(int)); @@ -334,7 +357,7 @@ class DivEngine { DivAudioExportModes exportMode; double exportFadeOut; std::map conf; - std::queue pendingNotes; + std::deque pendingNotes; bool isMuted[DIV_MAX_CHANS]; std::mutex isBusy, saveLock; String configPath; @@ -533,6 +556,9 @@ class DivEngine { // calculate frequency/period int calcFreq(int base, int pitch, bool period=false, int octave=0, int pitch2=0, double clock=1.0, double divider=1.0, int blockBits=0); + // calculate arpeggio + int calcArp(int note, int arp, int offset=0); + // convert panning formats int convertPanSplitToLinear(unsigned int val, unsigned char bits, int range); int convertPanSplitToLinearLR(unsigned char left, unsigned char right, int range); @@ -603,6 +629,9 @@ class DivEngine { // get japanese system name const char* getSystemNameJ(DivSystem sys); + // get sys definition + const DivSysDef* getSystemDef(DivSystem sys); + // convert sample rate format int fileToDivRate(int frate); int divToFileRate(int drate); @@ -885,6 +914,9 @@ class DivEngine { // remove system bool removeSystem(int index, bool preserveOrder=true); + // move system + bool swapSystem(int src, int dest, bool preserveOrder=true); + // write to register on system void poke(int sys, unsigned int addr, unsigned short val); diff --git a/src/engine/fileOps.cpp b/src/engine/fileOps.cpp index 589ca6a58..0e0ceb8bd 100644 --- a/src/engine/fileOps.cpp +++ b/src/engine/fileOps.cpp @@ -145,7 +145,9 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) { ds.loopModality=0; ds.properNoiseLayout=false; ds.waveDutyIsVol=false; - ds.resetMacroOnPorta=true; + // TODO: WHAT?! geodude.dmf fails when this is true + // but isn't that how Defle behaves??? + ds.resetMacroOnPorta=false; ds.legacyVolumeSlides=true; ds.compatibleArpeggio=true; ds.noteOffResetsSlides=true; @@ -175,6 +177,8 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) { ds.brokenOutVol=true; // ??? ds.e1e2StopOnSameNote=true; ds.brokenPortaArp=false; + ds.snNoLowPeriods=true; + ds.delayBehavior=0; // 1.1 compat flags if (ds.version>24) { @@ -505,6 +509,14 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) { for (int j=0; jstd.arpMacro.len; j++) { ins->std.arpMacro.val[j]-=12; } + } else { + ins->std.arpMacro.mode=0; + for (int j=0; jstd.arpMacro.len; j++) { + ins->std.arpMacro.val[j]^=0x40000000; + } + if (ins->std.arpMacro.loop==255 && ins->std.arpMacro.len<255) { + ins->std.arpMacro.val[ins->std.arpMacro.len++]=0; + } } ins->std.dutyMacro.len=reader.readC(); @@ -825,6 +837,13 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) { data=new short[length]; reader.read(data,length*2); } + +#ifdef TA_BIG_ENDIAN + // convert to big-endian + for (int pos=0; pos>8)); + } +#endif if (pitch!=5) { logD("%d: scaling from %d...",i,pitch); @@ -1056,6 +1075,12 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) { if (ds.version<101) { ds.brokenPortaArp=true; } + if (ds.version<108) { + ds.snNoLowPeriods=true; + } + if (ds.version<110) { + ds.delayBehavior=1; + } ds.isDMF=false; reader.readS(); // reserved @@ -1323,9 +1348,15 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) { } // pointers - reader.read(insPtr,ds.insLen*4); - reader.read(wavePtr,ds.waveLen*4); - reader.read(samplePtr,ds.sampleLen*4); + for (int i=0; iordersLen); @@ -1462,7 +1493,17 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) { } else { reader.readC(); } - for (int i=0; i<7; i++) { + if (ds.version>=108) { + ds.snNoLowPeriods=reader.readC(); + } else { + reader.readC(); + } + if (ds.version>=110) { + ds.delayBehavior=reader.readC(); + } else { + reader.readC(); + } + for (int i=0; i<5; i++) { reader.readC(); } } @@ -1703,11 +1744,36 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) { if (ds.version>=58) { // modern sample sample->init(sample->samples); reader.read(sample->getCurBuf(),sample->getCurBufLen()); +#ifdef TA_BIG_ENDIAN + // convert 16-bit samples to big-endian + if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) { + unsigned char* sampleBuf=(unsigned char*)sample->getCurBuf(); + size_t sampleBufLen=sample->getCurBufLen(); + for (size_t pos=0; possamples; short* data=new short[length]; reader.read(data,2*length); +#ifdef TA_BIG_ENDIAN + // convert 16-bit samples to big-endian + if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) { + unsigned char* sampleBuf=(unsigned char*)sample->getCurBuf(); + size_t sampleBufLen=sample->getCurBufLen(); + for (size_t pos=0; posstd.volMacro.val[ins->std.volMacro.len]=lastVal; - if (++ins->std.volMacro.len>=128) break; + if (++ins->std.volMacro.len>=255) break; } - if (ins->std.volMacro.len>=128) break; + if (ins->std.volMacro.len>=255) break; } else if (m.val[j]==0xe9 || m.val[j]==0xea) { // volume slide if (++j>=64) break; signed char slideStep=m.val[j]; @@ -2807,16 +2874,16 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { } } ins->std.volMacro.val[ins->std.volMacro.len]=lastVal; - if (++ins->std.volMacro.len>=128) break; + if (++ins->std.volMacro.len>=255) break; } } else { // TODO: replace with upcoming macro speed for (int k=0; kstd.volMacro.val[ins->std.volMacro.len]=m.val[j]; lastVal=m.val[j]; - if (++ins->std.volMacro.len>=128) break; + if (++ins->std.volMacro.len>=255) break; } - if (ins->std.volMacro.len>=128) break; + if (ins->std.volMacro.len>=255) break; } } @@ -2829,9 +2896,6 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { loopMapFreq[j]=ins->std.arpMacro.len; loopMapWave[j]=ins->std.waveMacro.len; if (fm.val[j]==0xe1) { - if (ins->std.arpMacro.mode) { - ins->std.arpMacro.loop=(signed int)ins->std.arpMacro.len-1; - } break; } else if (fm.val[j]==0xe2 || fm.val[j]==0xe4) { if (++j>=64) break; @@ -2845,7 +2909,7 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { ins->std.waveMacro.val[ins->std.waveMacro.len]=wave-10; ins->std.waveMacro.open=true; lastVal=wave; - //if (++ins->std.arpMacro.len>=128) break; + //if (++ins->std.arpMacro.len>=255) break; } } else if (fm.val[j]==0xe0) { if (++j>=64) break; @@ -2866,8 +2930,7 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { logV("unhandled pitch!"); } else { if (fm.val[j]>0x80) { - ins->std.arpMacro.val[ins->std.arpMacro.len]=fm.val[j]-0x80+24; - ins->std.arpMacro.mode=1; // TODO: variable fixed/relative mode + ins->std.arpMacro.val[ins->std.arpMacro.len]=(fm.val[j]-0x80+24)^0x40000000; } else { ins->std.arpMacro.val[ins->std.arpMacro.len]=fm.val[j]; } @@ -2875,8 +2938,8 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { ins->std.waveMacro.val[ins->std.waveMacro.len]=lastVal-10; } ins->std.arpMacro.open=true; - if (++ins->std.arpMacro.len>=128) break; - if (++ins->std.waveMacro.len>=128) break; + if (++ins->std.arpMacro.len>=255) break; + if (++ins->std.waveMacro.len>=255) break; } } } @@ -2889,7 +2952,7 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { // vibrato for (int j=0; j<=vibDelay; j++) { ins->std.pitchMacro.val[ins->std.pitchMacro.len]=0; - if (++ins->std.pitchMacro.len>=128) break; + if (++ins->std.pitchMacro.len>=255) break; } int vibPos=0; ins->std.pitchMacro.loop=ins->std.pitchMacro.len; @@ -2897,19 +2960,19 @@ bool DivEngine::loadFC(unsigned char* file, size_t len) { vibPos+=vibSpeed; if (vibPos>vibDepth) vibPos=vibDepth; ins->std.pitchMacro.val[ins->std.pitchMacro.len]=vibPos*32; - if (++ins->std.pitchMacro.len>=128) break; + if (++ins->std.pitchMacro.len>=255) break; } while (vibPosstd.pitchMacro.val[ins->std.pitchMacro.len]=vibPos*32; - if (++ins->std.pitchMacro.len>=128) break; + if (++ins->std.pitchMacro.len>=255) break; } while (vibPos>-vibDepth); do { vibPos+=vibSpeed; if (vibPos>0) vibPos=0; ins->std.pitchMacro.val[ins->std.pitchMacro.len]=vibPos*32; - if (++ins->std.pitchMacro.len>=128) break; + if (++ins->std.pitchMacro.len>=255) break; } while (vibPos<0); ds.ins.push_back(ins); @@ -3236,6 +3299,7 @@ bool DivEngine::loadFTM(unsigned char* file, size_t len) { ins->std.arpMacro.len=reader.readC(); ins->std.arpMacro.loop=reader.readI(); ins->std.arpMacro.rel=reader.readI(); + // TODO: get rid ins->std.arpMacro.mode=reader.readI(); for (int j=0; jstd.arpMacro.len; j++) { ins->std.arpMacro.val[j]=reader.readC(); @@ -3681,7 +3745,9 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) { w->writeC(song.brokenOutVol); w->writeC(song.e1e2StopOnSameNote); w->writeC(song.brokenPortaArp); - for (int i=0; i<7; i++) { + w->writeC(song.snNoLowPeriods); + w->writeC(song.delayBehavior); + for (int i=0; i<5; i++) { w->writeC(0); } @@ -3807,7 +3873,21 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) { w->writeI(0xffffffff); } +#ifdef TA_BIG_ENDIAN + // store 16-bit samples as little-endian + if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) { + unsigned char* sampleBuf=(unsigned char*)sample->getCurBuf(); + size_t bufLen=sample->getCurBufLen(); + for (size_t i=0; iwriteC(sampleBuf[i+1]); + w->writeC(sampleBuf[i]); + } + } else { + w->write(sample->getCurBuf(),sample->getCurBufLen()); + } +#else w->write(sample->getCurBuf(),sample->getCurBufLen()); +#endif blockEndSeek=w->tell(); w->seek(blockStartSeek,SEEK_SET); @@ -3834,7 +3914,13 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) { w->writeS(pat->data[j][1]); // octave w->writeS(pat->data[j][2]); // instrument w->writeS(pat->data[j][3]); // volume +#ifdef TA_BIG_ENDIAN + for (int k=0; kpat[i.chan].effectCols*2; k++) { + w->writeS(pat->data[j][4+k]); + } +#else w->write(&pat->data[j][4],2*song.subsong[i.subsong]->pat[i.chan].effectCols*2); // effects +#endif } w->writeString(pat->name,false); @@ -4069,7 +4155,25 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) { // safety check if (!isFMSystem(sys) && i->type!=DIV_INS_STD && i->type!=DIV_INS_FDS) { - i->type=DIV_INS_STD; + switch (song.system[0]) { + case DIV_SYSTEM_GB: + i->type=DIV_INS_GB; + break; + case DIV_SYSTEM_C64_6581: + case DIV_SYSTEM_C64_8580: + i->type=DIV_INS_C64; + break; + case DIV_SYSTEM_PCE: + i->type=DIV_INS_PCE; + break; + case DIV_SYSTEM_YM2610: + case DIV_SYSTEM_YM2610_EXT: + i->type=DIV_INS_AY; + break; + default: + i->type=DIV_INS_STD; + break; + } } if (!isSTDSystem(sys) && i->type!=DIV_INS_FM) { i->type=DIV_INS_FM; @@ -4110,47 +4214,79 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) { } } else { // STD if (sys!=DIV_SYSTEM_GB) { - w->writeC(i->std.volMacro.len); + int realVolMacroLen=i->std.volMacro.len; + if (realVolMacroLen>127) realVolMacroLen=127; + w->writeC(realVolMacroLen); if ((sys==DIV_SYSTEM_C64_6581 || sys==DIV_SYSTEM_C64_8580) && i->c64.volIsCutoff) { - for (int j=0; jstd.volMacro.len; j++) { + for (int j=0; jwriteI(i->std.volMacro.val[j]+18); } } else { - w->write(i->std.volMacro.val,4*i->std.volMacro.len); + for (int j=0; jwriteI(i->std.volMacro.val[j]); + } } - if (i->std.volMacro.len>0) { + if (realVolMacroLen>0) { w->writeC(i->std.volMacro.loop); } } + // TODO: take care of new arp macro format w->writeC(i->std.arpMacro.len); - if (i->std.arpMacro.mode) { - w->write(i->std.arpMacro.val,4*i->std.arpMacro.len); + bool arpMacroMode=false; + int arpMacroHowManyFixed=0; + int realArpMacroLen=i->std.arpMacro.len; + for (int j=0; jstd.arpMacro.len; j++) { + if ((i->std.arpMacro.val[j]&0xc0000000)==0x40000000 || (i->std.arpMacro.val[j]&0xc0000000)==0x80000000) { + arpMacroHowManyFixed++; + } + } + if (arpMacroHowManyFixed>=i->std.arpMacro.len-1) { + arpMacroMode=true; + } + if (i->std.arpMacro.len>0) { + if (arpMacroMode && i->std.arpMacro.val[i->std.arpMacro.len-1]==0 && i->std.arpMacro.loop>=i->std.arpMacro.len) { + realArpMacroLen--; + } + } + + if (arpMacroMode) { + for (int j=0; jwriteI(i->std.arpMacro.val[j]); + } } else { - for (int j=0; jstd.arpMacro.len; j++) { + for (int j=0; jwriteI(i->std.arpMacro.val[j]+12); } } - if (i->std.arpMacro.len>0) { + if (realArpMacroLen>0) { w->writeC(i->std.arpMacro.loop); } - w->writeC(i->std.arpMacro.mode); + w->writeC(arpMacroMode); - w->writeC(i->std.dutyMacro.len); + int realDutyMacroLen=i->std.dutyMacro.len; + if (realDutyMacroLen>127) realDutyMacroLen=127; + w->writeC(realDutyMacroLen); if (sys==DIV_SYSTEM_C64_6581 || sys==DIV_SYSTEM_C64_8580) { - for (int j=0; jstd.dutyMacro.len; j++) { + for (int j=0; jwriteI(i->std.dutyMacro.val[j]+12); } } else { - w->write(i->std.dutyMacro.val,4*i->std.dutyMacro.len); + for (int j=0; jwriteI(i->std.dutyMacro.val[j]); + } } - if (i->std.dutyMacro.len>0) { + if (realDutyMacroLen>0) { w->writeC(i->std.dutyMacro.loop); } - w->writeC(i->std.waveMacro.len); - w->write(i->std.waveMacro.val,4*i->std.waveMacro.len); - if (i->std.waveMacro.len>0) { + int realWaveMacroLen=i->std.waveMacro.len; + if (realWaveMacroLen>127) realWaveMacroLen=127; + w->writeC(realWaveMacroLen); + for (int j=0; jwriteI(i->std.waveMacro.val[j]); + } + if (realWaveMacroLen>0) { w->writeC(i->std.waveMacro.loop); } @@ -4200,7 +4336,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) { w->writeI(i->data[j]>>2); } } else { - w->write(i->data,4*i->len); + for (int j=0; jlen; j++) { + w->writeI(i->data[j]); + } } } @@ -4213,7 +4351,13 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) { w->writeS(pat->data[k][0]); // note w->writeS(pat->data[k][1]); // octave w->writeS(pat->data[k][3]); // volume +#ifdef TA_BIG_ENDIAN + for (int l=0; lwriteS(pat->data[k][4+l]); + } +#else w->write(&pat->data[k][4],2*curPat[i].effectCols*2); // effects +#endif w->writeS(pat->data[k][2]); // instrument } } @@ -4232,7 +4376,15 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) { w->writeC(50); // i'm too lazy to deal with .dmf's weird way of storing 8-bit samples w->writeC(16); + // well I can't be lazy if it's on a big-endian system +#ifdef TA_BIG_ENDIAN + for (unsigned int j=0; jlength16; j++) { + w->writeC(((unsigned short)i->data16[j])&0xff); + w->writeC(((unsigned short)i->data16[j])>>8); + } +#else w->write(i->data16,i->length16); +#endif } saveLock.unlock(); diff --git a/src/engine/instrument.cpp b/src/engine/instrument.cpp index 2836e6f95..19cb1ba55 100644 --- a/src/engine/instrument.cpp +++ b/src/engine/instrument.cpp @@ -132,7 +132,7 @@ void DivInstrument::putInsData(SafeWriter* w) { w->writeI(std.ex1Macro.loop); w->writeI(std.ex2Macro.loop); w->writeI(std.ex3Macro.loop); - w->writeC(std.arpMacro.mode); + w->writeC(0); // this was arp macro mode w->writeC(0); // reserved w->writeC(0); w->writeC(0); @@ -543,12 +543,126 @@ void DivInstrument::putInsData(SafeWriter* w) { w->writeC(gb.softEnv); w->writeC(gb.alwaysInit); + // ES5506 + w->writeC(es5506.filter.mode); + w->writeS(es5506.filter.k1); + w->writeS(es5506.filter.k2); + w->writeS(es5506.envelope.ecount); + w->writeC(es5506.envelope.lVRamp); + w->writeC(es5506.envelope.rVRamp); + w->writeC(es5506.envelope.k1Ramp); + w->writeC(es5506.envelope.k2Ramp); + w->writeC(es5506.envelope.k1Slow); + w->writeC(es5506.envelope.k2Slow); + + // SNES + w->writeC(snes.useEnv); + w->writeC(snes.gainMode); + w->writeC(snes.gain); + w->writeC(snes.a); + w->writeC(snes.d); + w->writeC(snes.s); + w->writeC(snes.r); + + // macro speed/delay + w->writeC(std.volMacro.speed); + w->writeC(std.arpMacro.speed); + w->writeC(std.dutyMacro.speed); + w->writeC(std.waveMacro.speed); + w->writeC(std.pitchMacro.speed); + w->writeC(std.ex1Macro.speed); + w->writeC(std.ex2Macro.speed); + w->writeC(std.ex3Macro.speed); + w->writeC(std.algMacro.speed); + w->writeC(std.fbMacro.speed); + w->writeC(std.fmsMacro.speed); + w->writeC(std.amsMacro.speed); + w->writeC(std.panLMacro.speed); + w->writeC(std.panRMacro.speed); + w->writeC(std.phaseResetMacro.speed); + w->writeC(std.ex4Macro.speed); + w->writeC(std.ex5Macro.speed); + w->writeC(std.ex6Macro.speed); + w->writeC(std.ex7Macro.speed); + w->writeC(std.ex8Macro.speed); + + w->writeC(std.volMacro.delay); + w->writeC(std.arpMacro.delay); + w->writeC(std.dutyMacro.delay); + w->writeC(std.waveMacro.delay); + w->writeC(std.pitchMacro.delay); + w->writeC(std.ex1Macro.delay); + w->writeC(std.ex2Macro.delay); + w->writeC(std.ex3Macro.delay); + w->writeC(std.algMacro.delay); + w->writeC(std.fbMacro.delay); + w->writeC(std.fmsMacro.delay); + w->writeC(std.amsMacro.delay); + w->writeC(std.panLMacro.delay); + w->writeC(std.panRMacro.delay); + w->writeC(std.phaseResetMacro.delay); + w->writeC(std.ex4Macro.delay); + w->writeC(std.ex5Macro.delay); + w->writeC(std.ex6Macro.delay); + w->writeC(std.ex7Macro.delay); + w->writeC(std.ex8Macro.delay); + + // op macro speed/delay + for (int i=0; i<4; i++) { + DivInstrumentSTD::OpMacro& op=std.opMacros[i]; + + w->writeC(op.amMacro.speed); + w->writeC(op.arMacro.speed); + w->writeC(op.drMacro.speed); + w->writeC(op.multMacro.speed); + w->writeC(op.rrMacro.speed); + w->writeC(op.slMacro.speed); + w->writeC(op.tlMacro.speed); + w->writeC(op.dt2Macro.speed); + w->writeC(op.rsMacro.speed); + w->writeC(op.dtMacro.speed); + w->writeC(op.d2rMacro.speed); + w->writeC(op.ssgMacro.speed); + w->writeC(op.damMacro.speed); + w->writeC(op.dvbMacro.speed); + w->writeC(op.egtMacro.speed); + w->writeC(op.kslMacro.speed); + w->writeC(op.susMacro.speed); + w->writeC(op.vibMacro.speed); + w->writeC(op.wsMacro.speed); + w->writeC(op.ksrMacro.speed); + + w->writeC(op.amMacro.delay); + w->writeC(op.arMacro.delay); + w->writeC(op.drMacro.delay); + w->writeC(op.multMacro.delay); + w->writeC(op.rrMacro.delay); + w->writeC(op.slMacro.delay); + w->writeC(op.tlMacro.delay); + w->writeC(op.dt2Macro.delay); + w->writeC(op.rsMacro.delay); + w->writeC(op.dtMacro.delay); + w->writeC(op.d2rMacro.delay); + w->writeC(op.ssgMacro.delay); + w->writeC(op.damMacro.delay); + w->writeC(op.dvbMacro.delay); + w->writeC(op.egtMacro.delay); + w->writeC(op.kslMacro.delay); + w->writeC(op.susMacro.delay); + w->writeC(op.vibMacro.delay); + w->writeC(op.wsMacro.delay); + w->writeC(op.ksrMacro.delay); + } + blockEndSeek=w->tell(); w->seek(blockStartSeek,SEEK_SET); w->writeI(blockEndSeek-blockStartSeek-4); w->seek(0,SEEK_END); } +#define READ_MACRO_VALS(x,y) \ + for (int macroValPos=0; macroValPos=17) { - reader.read(std.pitchMacro.val,4*std.pitchMacro.len); - reader.read(std.ex1Macro.val,4*std.ex1Macro.len); - reader.read(std.ex2Macro.val,4*std.ex2Macro.len); - reader.read(std.ex3Macro.val,4*std.ex3Macro.len); + READ_MACRO_VALS(std.pitchMacro.val,std.pitchMacro.len); + READ_MACRO_VALS(std.ex1Macro.val,std.ex1Macro.len); + READ_MACRO_VALS(std.ex2Macro.val,std.ex2Macro.len); + READ_MACRO_VALS(std.ex3Macro.val,std.ex3Macro.len); } else { if (type==DIV_INS_STD) { if (oldVolHeight==31) { @@ -730,10 +844,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) { std.fmsMacro.open=reader.readC(); std.amsMacro.open=reader.readC(); - reader.read(std.algMacro.val,4*std.algMacro.len); - reader.read(std.fbMacro.val,4*std.fbMacro.len); - reader.read(std.fmsMacro.val,4*std.fmsMacro.len); - reader.read(std.amsMacro.val,4*std.amsMacro.len); + READ_MACRO_VALS(std.algMacro.val,std.algMacro.len); + READ_MACRO_VALS(std.fbMacro.val,std.fbMacro.len); + READ_MACRO_VALS(std.fmsMacro.val,std.fmsMacro.len); + READ_MACRO_VALS(std.amsMacro.val,std.amsMacro.len); for (int i=0; i<4; i++) { DivInstrumentSTD::OpMacro& op=std.opMacros[i]; @@ -936,15 +1050,15 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) { // clear noise macro if PCE instrument and version<63 if (version<63 && type==DIV_INS_PCE) { std.dutyMacro.len=0; - std.dutyMacro.loop=-1; - std.dutyMacro.rel=-1; + std.dutyMacro.loop=255; + std.dutyMacro.rel=255; } // clear wave macro if OPLL instrument and version<70 if (version<70 && type==DIV_INS_OPLL) { std.waveMacro.len=0; - std.waveMacro.loop=-1; - std.waveMacro.rel=-1; + std.waveMacro.loop=255; + std.waveMacro.rel=255; } // sample map @@ -1007,14 +1121,14 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) { std.ex7Macro.open=reader.readC(); std.ex8Macro.open=reader.readC(); - reader.read(std.panLMacro.val,4*std.panLMacro.len); - reader.read(std.panRMacro.val,4*std.panRMacro.len); - reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len); - reader.read(std.ex4Macro.val,4*std.ex4Macro.len); - reader.read(std.ex5Macro.val,4*std.ex5Macro.len); - reader.read(std.ex6Macro.val,4*std.ex6Macro.len); - reader.read(std.ex7Macro.val,4*std.ex7Macro.len); - reader.read(std.ex8Macro.val,4*std.ex8Macro.len); + READ_MACRO_VALS(std.panLMacro.val,std.panLMacro.len); + READ_MACRO_VALS(std.panRMacro.val,std.panRMacro.len); + READ_MACRO_VALS(std.phaseResetMacro.val,std.phaseResetMacro.len); + READ_MACRO_VALS(std.ex4Macro.val,std.ex4Macro.len); + READ_MACRO_VALS(std.ex5Macro.val,std.ex5Macro.len); + READ_MACRO_VALS(std.ex6Macro.val,std.ex6Macro.len); + READ_MACRO_VALS(std.ex7Macro.val,std.ex7Macro.len); + READ_MACRO_VALS(std.ex8Macro.val,std.ex8Macro.len); // FDS fds.modSpeed=reader.readI(); @@ -1111,6 +1225,136 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) { gb.alwaysInit=reader.readC(); } + // ES5506 + if (version>=107) { + es5506.filter.mode=(DivInstrumentES5506::Filter::FilterMode)reader.readC(); + es5506.filter.k1=reader.readS(); + es5506.filter.k2=reader.readS(); + es5506.envelope.ecount=reader.readS(); + es5506.envelope.lVRamp=reader.readC(); + es5506.envelope.rVRamp=reader.readC(); + es5506.envelope.k1Ramp=reader.readC(); + es5506.envelope.k2Ramp=reader.readC(); + es5506.envelope.k1Slow=reader.readC(); + es5506.envelope.k2Slow=reader.readC(); + } + + // SNES + if (version>=109) { + snes.useEnv=reader.readC(); + snes.gainMode=(DivInstrumentSNES::GainMode)reader.readC(); + snes.gain=reader.readC(); + snes.a=reader.readC(); + snes.d=reader.readC(); + snes.s=reader.readC(); + snes.r=reader.readC(); + } + + // macro speed/delay + if (version>=111) { + std.volMacro.speed=reader.readC(); + std.arpMacro.speed=reader.readC(); + std.dutyMacro.speed=reader.readC(); + std.waveMacro.speed=reader.readC(); + std.pitchMacro.speed=reader.readC(); + std.ex1Macro.speed=reader.readC(); + std.ex2Macro.speed=reader.readC(); + std.ex3Macro.speed=reader.readC(); + std.algMacro.speed=reader.readC(); + std.fbMacro.speed=reader.readC(); + std.fmsMacro.speed=reader.readC(); + std.amsMacro.speed=reader.readC(); + std.panLMacro.speed=reader.readC(); + std.panRMacro.speed=reader.readC(); + std.phaseResetMacro.speed=reader.readC(); + std.ex4Macro.speed=reader.readC(); + std.ex5Macro.speed=reader.readC(); + std.ex6Macro.speed=reader.readC(); + std.ex7Macro.speed=reader.readC(); + std.ex8Macro.speed=reader.readC(); + + std.volMacro.delay=reader.readC(); + std.arpMacro.delay=reader.readC(); + std.dutyMacro.delay=reader.readC(); + std.waveMacro.delay=reader.readC(); + std.pitchMacro.delay=reader.readC(); + std.ex1Macro.delay=reader.readC(); + std.ex2Macro.delay=reader.readC(); + std.ex3Macro.delay=reader.readC(); + std.algMacro.delay=reader.readC(); + std.fbMacro.delay=reader.readC(); + std.fmsMacro.delay=reader.readC(); + std.amsMacro.delay=reader.readC(); + std.panLMacro.delay=reader.readC(); + std.panRMacro.delay=reader.readC(); + std.phaseResetMacro.delay=reader.readC(); + std.ex4Macro.delay=reader.readC(); + std.ex5Macro.delay=reader.readC(); + std.ex6Macro.delay=reader.readC(); + std.ex7Macro.delay=reader.readC(); + std.ex8Macro.delay=reader.readC(); + + // op macro speed/delay + for (int i=0; i<4; i++) { + DivInstrumentSTD::OpMacro& op=std.opMacros[i]; + + op.amMacro.speed=reader.readC(); + op.arMacro.speed=reader.readC(); + op.drMacro.speed=reader.readC(); + op.multMacro.speed=reader.readC(); + op.rrMacro.speed=reader.readC(); + op.slMacro.speed=reader.readC(); + op.tlMacro.speed=reader.readC(); + op.dt2Macro.speed=reader.readC(); + op.rsMacro.speed=reader.readC(); + op.dtMacro.speed=reader.readC(); + op.d2rMacro.speed=reader.readC(); + op.ssgMacro.speed=reader.readC(); + op.damMacro.speed=reader.readC(); + op.dvbMacro.speed=reader.readC(); + op.egtMacro.speed=reader.readC(); + op.kslMacro.speed=reader.readC(); + op.susMacro.speed=reader.readC(); + op.vibMacro.speed=reader.readC(); + op.wsMacro.speed=reader.readC(); + op.ksrMacro.speed=reader.readC(); + + op.amMacro.delay=reader.readC(); + op.arMacro.delay=reader.readC(); + op.drMacro.delay=reader.readC(); + op.multMacro.delay=reader.readC(); + op.rrMacro.delay=reader.readC(); + op.slMacro.delay=reader.readC(); + op.tlMacro.delay=reader.readC(); + op.dt2Macro.delay=reader.readC(); + op.rsMacro.delay=reader.readC(); + op.dtMacro.delay=reader.readC(); + op.d2rMacro.delay=reader.readC(); + op.ssgMacro.delay=reader.readC(); + op.damMacro.delay=reader.readC(); + op.dvbMacro.delay=reader.readC(); + op.egtMacro.delay=reader.readC(); + op.kslMacro.delay=reader.readC(); + op.susMacro.delay=reader.readC(); + op.vibMacro.delay=reader.readC(); + op.wsMacro.delay=reader.readC(); + op.ksrMacro.delay=reader.readC(); + } + } + + // old arp macro format + if (version<112) { + if (std.arpMacro.mode) { + std.arpMacro.mode=0; + for (int i=0; i=std.arpMacro.len || (std.arpMacro.rel>std.arpMacro.loop && std.arpMacro.rel0) { + delay--; + return; + } + if (began && source.delay>0) { + delay=source.delay; + } else { + delay=source.speed-1; + } + if (began) { + began=false; + } if (finished) { finished=false; } @@ -41,16 +53,17 @@ void DivMacroStruct::doMacro(DivInstrumentMacro& source, bool released, bool tic actualHad=has; had=actualHad; if (has) { + lastPos=pos; val=source.val[pos++]; - if (source.rel>=0 && pos>source.rel && !released) { - if (source.loop=0 && source.loopsource.rel && !released) { + if (source.loop=source.len) { - if (source.loop=0 && (source.loop>=source.rel || source.rel>=source.len)) { + if (source.loop=source.rel || source.rel>=source.len)) { pos=source.loop; } else if (linger) { pos--; @@ -239,7 +252,7 @@ void DivMacroInt::init(DivInstrument* which) { for (size_t i=0; iprepare(*macroSource[i],e); - hasRelease=(macroSource[i]->rel>=0 && macroSource[i]->rellen); + hasRelease=(macroSource[i]->rellen); } else { hasRelease=false; } @@ -251,3 +264,110 @@ void DivMacroInt::notifyInsDeletion(DivInstrument* which) { init(NULL); } } + +// randomly-generated +constexpr unsigned int hashTable[256]={ + 0x0718657, 0xe904eb33, 0x14b2da2b, 0x0ef67ca9, + 0x0f0559a, 0x4142065a, 0x4d9ab4ba, 0x3cdd601a, + 0x6635aca, 0x2c41ab72, 0xf98e8d31, 0x1003ee63, + 0x3fd9fb5, 0x30734d16, 0xe8964431, 0x29bb9b79, + 0x817f580, 0xfe083b9e, 0x974b5e85, 0x3b5729c2, + 0x2afea96, 0xf1573b4b, 0x308a1024, 0xaa94b92d, + 0x693fa93, 0x547ba3da, 0xac4f206c, 0x93f72ea9, + 0xcc44001, 0x37e27670, 0xf35a63d0, 0xd1cdbb92, + 0x7c7ee24, 0xfa267ee9, 0xf9cd9956, 0x6a6768d4, + 0x9e6a108, 0xf6ca4bd0, 0xa53cba9f, 0x526a523a, + 0xf46f0c8, 0xf131bd4c, 0x82800d48, 0xabff9214, + 0x40eabd4, 0xea0ef8f7, 0xdc3968d6, 0x54c3cb63, + 0x8855023, 0xaab73861, 0xff0bea2c, 0x139b9765, + 0x4a21279, 0x6b2aa29a, 0xf147cc3f, 0xc42edc1a, + 0xfe2f86f, 0x6d352047, 0xd3cac3e4, 0x35e5c389, + 0xe923727, 0x12fe3b32, 0x204295c5, 0x254a8b7a, + 0xc1d995d, 0x26a512d2, 0xa3e34033, 0x9a968df0, + 0x53447ed, 0x36cf4077, 0x189b03a7, 0x558790e8, + 0x01f921a, 0x840f260c, 0x93dd2b86, 0x12f69cb0, + 0x117d93a, 0xcb2cbc2b, 0xd41e3aed, 0x5ff6ec75, + 0x607290d, 0xd41adb92, 0x64f94ba7, 0xaff720f7, + 0x6bf1d5d, 0xc8e36c6d, 0x7095bab5, 0xdfbf7b0d, + 0x01ddeea, 0xe8f262da, 0xf589512f, 0xc2ecac5d, + 0xbe29d98, 0xff8b5a2e, 0x18e7279e, 0x6ad24dcb, + 0x2b3b9b1, 0x6f5227d8, 0x076d7553, 0x6c5856e2, + 0x995f655, 0xe9fcf5a6, 0x83671b70, 0xaf3aed1e, + 0xac340f0, 0x5c7008b4, 0x14651282, 0x8bf855b9, + 0x4a933af, 0x829b87f1, 0x9a673070, 0xb19da64f, + 0x77d8f36, 0x584c9fdc, 0xa9e52c0d, 0x6da5e13d, + 0xae1051f, 0xe85e976f, 0xfeac2d9a, 0x19c46754, + 0x1cba6f3, 0xaf21bc31, 0x16b6a8d4, 0xe08b0fdb, + 0x97e6e54, 0x5da499ae, 0xab472e19, 0xc2491f2e, + 0xc08c563, 0xe91b131b, 0xc8e22451, 0x6995c8fe, + 0x7042718, 0x01043738, 0xc7d88b28, 0x2d9f330f, + 0x4b3aae5, 0xf1e705ba, 0xc5b8ee59, 0xa8ba4e8f, + 0x55f65a2, 0xa1899e41, 0x296243c8, 0x1e502bf2, + 0x20080de, 0x841d2239, 0x37b082af, 0xbdd7f7da, + 0x4075090, 0x1dc7dc49, 0x5cd3c69a, 0x7fb13b62, + 0xb382bf1, 0xa0cfbc2f, 0x9eca4dc1, 0xb9355453, + 0x5d0dd24, 0x834f4d8e, 0xe9b136b2, 0xe7b8738d, + 0x1c91d41, 0x8cb3ddb5, 0xdc600590, 0x607cff55, + 0x2ca7675, 0x4622a8e4, 0x9340e414, 0xcb44928a, + 0xa9e791c, 0x68849920, 0xc5b5fcd8, 0xbc352269, + 0x3ab13cf, 0xaa3cbbd0, 0x1abacc64, 0x623b5b49, + 0xcc8c4c3, 0x3c8f2f70, 0x3e584a28, 0x9316d24d, + 0xfe315a2, 0x10f0ba7a, 0xed15a523, 0x4f987369, + 0x7aa4a4a, 0x90eaf98f, 0xcf0af610, 0x1b38f4e7, + 0x19df72d, 0xd8306808, 0xd54e25ac, 0x76b79c6d, + 0x58110cf, 0x06a3e5f2, 0x873a6039, 0xf52684e3, + 0xecf39c3, 0x7cbb2759, 0xe280d361, 0x91e8471a, + 0xa67cdd3, 0x17cac3be, 0xfc9eff1f, 0x71abdf49, + 0x6168624, 0xb68f86f7, 0x67a8e72a, 0xe746911d, + 0xca48fd7, 0x8f3cc436, 0x3a3851a8, 0x30a7e26e, + 0xca49308, 0xb598ef74, 0x49ef167a, 0xa9e17632, + 0x0f7308a, 0xf156efed, 0xcf799645, 0xbae4b85a, + 0xecba3fe, 0xd97f861d, 0xc164af62, 0xb1aca42f, + 0xf249576, 0x83d1bf4e, 0x2f486a9c, 0xd3b53cc2, + 0x17d7c26, 0xd95ddae1, 0x76c1a2f5, 0xf8af6782, + 0xdbaece4, 0x010b2b53, 0x049be200, 0xd9fd0d1a, + 0x37d7e6c, 0x5b848651, 0x203c98c7, 0x669681b0, + 0x683086f, 0xdd0ee8ab, 0x5dbe008b, 0xe5d0690d, + 0x23dd758, 0x6b34acbc, 0x4b2b3e65, 0xcc7b56c1, + 0x196b0a0, 0x7b065105, 0xb731b01a, 0xd37daa16, + 0xf77816b, 0x3c9fa546, 0x81dfadb8, 0x39b1fb8b +}; + +constexpr unsigned int NAME_HASH(const char* name) { + unsigned int nameHash=0xffffffff; + for (const char* i=name; *i; i++) { + nameHash=(nameHash>>8)^hashTable[(unsigned char)*i]; + } + return nameHash; +} + +#define CONSIDER(x) case NAME_HASH(#x): return &x; break; + +DivMacroStruct* DivMacroInt::structByName(const String& name) { + unsigned int hash=NAME_HASH(name.c_str()); + + switch (hash) { + CONSIDER(vol) + CONSIDER(arp) + CONSIDER(duty) + CONSIDER(wave) + CONSIDER(pitch) + CONSIDER(ex1) + CONSIDER(ex2) + CONSIDER(ex3) + CONSIDER(alg) + CONSIDER(fb) + CONSIDER(fms) + CONSIDER(ams) + CONSIDER(panL) + CONSIDER(panR) + CONSIDER(phaseReset) + CONSIDER(ex4) + CONSIDER(ex5) + CONSIDER(ex6) + CONSIDER(ex7) + CONSIDER(ex8) + } + + return NULL; +} diff --git a/src/engine/macroInt.h b/src/engine/macroInt.h index 839625558..ad761ba53 100644 --- a/src/engine/macroInt.h +++ b/src/engine/macroInt.h @@ -25,21 +25,24 @@ class DivEngine; struct DivMacroStruct { - int pos; + int pos, lastPos, delay; int val; - bool has, had, actualHad, finished, will, linger; + bool has, had, actualHad, finished, will, linger, began; unsigned int mode; void doMacro(DivInstrumentMacro& source, bool released, bool tick); void init() { - pos=mode=0; + pos=lastPos=mode=delay=0; has=had=actualHad=will=false; linger=false; + began=true; // TODO: test whether this breaks anything? val=0; } void prepare(DivInstrumentMacro& source, DivEngine* e); DivMacroStruct(): pos(0), + lastPos(0), + delay(0), val(0), has(false), had(false), @@ -47,6 +50,7 @@ struct DivMacroStruct { finished(false), will(false), linger(false), + began(false), mode(0) {} }; @@ -127,6 +131,13 @@ class DivMacroInt { */ void notifyInsDeletion(DivInstrument* which); + /** + * get DivMacroStruct by macro name. + * @param which the macro name. + * @return a DivMacroStruct, or NULL if none found. + */ + DivMacroStruct* structByName(const String& name); + DivMacroInt(): e(NULL), ins(NULL), diff --git a/src/engine/platform/abstract.cpp b/src/engine/platform/abstract.cpp index 5b732e7e9..358e54aa0 100644 --- a/src/engine/platform/abstract.cpp +++ b/src/engine/platform/abstract.cpp @@ -94,10 +94,6 @@ bool DivDispatch::getWantPreNote() { return false; } -const char* DivDispatch::getEffectName(unsigned char effect) { - return NULL; -} - void DivDispatch::setFlags(unsigned int flags) { } diff --git a/src/engine/platform/amiga.cpp b/src/engine/platform/amiga.cpp index 1b0075307..ed71d76a4 100644 --- a/src/engine/platform/amiga.cpp +++ b/src/engine/platform/amiga.cpp @@ -64,21 +64,6 @@ const char** DivPlatformAmiga::getRegisterSheet() { return regCheatSheetAmiga; } -const char* DivPlatformAmiga::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Toggle filter (0 disables; 1 enables)"; - break; - case 0x11: - return "11xx: Toggle AM with next channel"; - break; - case 0x12: - return "12xx: Toggle period modulation with next channel"; - break; - } - return NULL; -} - #define writeAudDat(x) \ chan[i].audDat=x; \ if (i<3 && chan[i].useV) { \ @@ -178,19 +163,9 @@ void DivPlatformAmiga::tick(bool sysTick) { } } if (chan[i].std.arp.had) { - if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=round(off*NOTE_PERIODIC_NOROUND(chan[i].std.arp.val)); - } else { - chan[i].baseFreq=round(off*NOTE_PERIODIC_NOROUND(chan[i].note+chan[i].std.arp.val)); - } - } + // TODO: why the off mult? this may be a bug! + chan[i].baseFreq=round(off*NOTE_PERIODIC_NOROUND(parent->calcArp(chan[i].note,chan[i].std.arp.val))); chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=round(off*NOTE_PERIODIC_NOROUND(chan[i].note)); - chan[i].freqChanged=true; - } } if (chan[i].useWave && chan[i].std.wave.had) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/amiga.h b/src/engine/platform/amiga.h index e7372e63b..59617ec36 100644 --- a/src/engine/platform/amiga.h +++ b/src/engine/platform/amiga.h @@ -105,7 +105,6 @@ class DivPlatformAmiga: public DivDispatch { void notifyWaveChange(int wave); void notifyInsDeletion(void* ins); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); }; diff --git a/src/engine/platform/arcade.cpp b/src/engine/platform/arcade.cpp index 41042cd5c..cca54d28b 100644 --- a/src/engine/platform/arcade.cpp +++ b/src/engine/platform/arcade.cpp @@ -50,111 +50,6 @@ const char** DivPlatformArcade::getRegisterSheet() { return regCheatSheetOPM; } -const char* DivPlatformArcade::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set noise frequency (xx: value; 0 disables noise)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x17: - return "17xx: Set LFO speed"; - break; - case 0x18: - return "18xx: Set LFO waveform (0 saw, 1 square, 2 triangle, 3 noise)"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x1e: - return "1Exx: Set AM depth (0 to 7F)"; - break; - case 0x1f: - return "1Fxx: Set PM depth (0 to 7F)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set detune 2 (x: operator from 1 to 4 (0 for all ops); y: detune from 0 to 3)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - void DivPlatformArcade::acquire_nuked(short* bufL, short* bufR, size_t start, size_t len) { static int o[2]; @@ -266,18 +161,9 @@ void DivPlatformArcade::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_LINEAR(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_LINEAR(chan[i].note+(signed char)chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_LINEAR(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_LINEAR(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { diff --git a/src/engine/platform/arcade.h b/src/engine/platform/arcade.h index daa883620..93aa490d0 100644 --- a/src/engine/platform/arcade.h +++ b/src/engine/platform/arcade.h @@ -115,7 +115,6 @@ class DivPlatformArcade: public DivPlatformOPM { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformArcade(); diff --git a/src/engine/platform/ay.cpp b/src/engine/platform/ay.cpp index 8df5bd4ce..f45c51ea7 100644 --- a/src/engine/platform/ay.cpp +++ b/src/engine/platform/ay.cpp @@ -73,42 +73,6 @@ const char** DivPlatformAY8910::getRegisterSheet() { return intellivision?regCheatSheetAY8914:regCheatSheetAY; } -const char* DivPlatformAY8910::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xx: Set channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set envelope period low byte"; - break; - case 0x24: - return "24xx: Set envelope period high byte"; - break; - case 0x25: - return "25xx: Envelope slide up"; - break; - case 0x26: - return "26xx: Envelope slide down"; - break; - case 0x29: - return "29xy: Set auto-envelope (x: numerator; y: denominator)"; - break; - case 0x2e: - return "2Exx: Write to I/O port A"; - break; - case 0x2f: - return "2Fxx: Write to I/O port B"; - break; - } - return NULL; -} - void DivPlatformAY8910::acquire(short* bufL, short* bufR, size_t start, size_t len) { if (ayBufLencalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { rWrite(0x06,31-chan[i].std.duty.val); diff --git a/src/engine/platform/ay.h b/src/engine/platform/ay.h index f67a2ad97..4b7ce1068 100644 --- a/src/engine/platform/ay.h +++ b/src/engine/platform/ay.h @@ -112,7 +112,6 @@ class DivPlatformAY8910: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); DivPlatformAY8910(bool useExtMode=false, unsigned int eclk=COLOR_NTSC, unsigned char ediv=8): diff --git a/src/engine/platform/ay8930.cpp b/src/engine/platform/ay8930.cpp index 581ebb9e8..d77457d66 100644 --- a/src/engine/platform/ay8930.cpp +++ b/src/engine/platform/ay8930.cpp @@ -77,54 +77,6 @@ const char** DivPlatformAY8930::getRegisterSheet() { return regCheatSheetAY8930; } -const char* DivPlatformAY8930::getEffectName(unsigned char effect) { - switch (effect) { - case 0x12: - return "12xx: Set duty cycle (0 to 8)"; - break; - case 0x20: - return "20xx: Set channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set envelope period low byte"; - break; - case 0x24: - return "24xx: Set envelope period high byte"; - break; - case 0x25: - return "25xx: Envelope slide up"; - break; - case 0x26: - return "26xx: Envelope slide down"; - break; - case 0x27: - return "27xx: Set noise AND mask"; - break; - case 0x28: - return "28xx: Set noise OR mask"; - break; - case 0x29: - return "29xy: Set auto-envelope (x: numerator; y: denominator)"; - break; - case 0x2d: - return "2Dxx: NOT TO BE EMPLOYED BY THE COMPOSER"; - break; - case 0x2e: - return "2Exx: Write to I/O port A"; - break; - case 0x2f: - return "2Fxx: Write to I/O port B"; - break; - } - return NULL; -} - void DivPlatformAY8930::acquire(short* bufL, short* bufR, size_t start, size_t len) { if (ayBufLencalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { rWrite(0x06,chan[i].std.duty.val); diff --git a/src/engine/platform/ay8930.h b/src/engine/platform/ay8930.h index 10ac7736b..81995f2de 100644 --- a/src/engine/platform/ay8930.h +++ b/src/engine/platform/ay8930.h @@ -103,7 +103,6 @@ class DivPlatformAY8930: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); }; diff --git a/src/engine/platform/bubsyswsg.cpp b/src/engine/platform/bubsyswsg.cpp index 5fe4462f4..89503cceb 100644 --- a/src/engine/platform/bubsyswsg.cpp +++ b/src/engine/platform/bubsyswsg.cpp @@ -39,15 +39,6 @@ const char** DivPlatformBubSysWSG::getRegisterSheet() { return regCheatSheetBubSysWSG; } -const char* DivPlatformBubSysWSG::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - } - return NULL; -} - void DivPlatformBubSysWSG::acquire(short* bufL, short* bufR, size_t start, size_t len) { int chanOut=0; for (size_t h=start; hcalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/bubsyswsg.h b/src/engine/platform/bubsyswsg.h index e288493c1..cfc41dc12 100644 --- a/src/engine/platform/bubsyswsg.h +++ b/src/engine/platform/bubsyswsg.h @@ -85,7 +85,6 @@ class DivPlatformBubSysWSG: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformBubSysWSG(); diff --git a/src/engine/platform/c64.cpp b/src/engine/platform/c64.cpp index 9049ffec4..9825f189e 100644 --- a/src/engine/platform/c64.cpp +++ b/src/engine/platform/c64.cpp @@ -62,52 +62,6 @@ const char** DivPlatformC64::getRegisterSheet() { return regCheatSheetSID; } -const char* DivPlatformC64::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set waveform (bit 0: triangle; bit 1: saw; bit 2: pulse; bit 3: noise)"; - break; - case 0x11: - return "11xx: Set coarse cutoff (not recommended; use 4xxx instead)"; - break; - case 0x12: - return "12xx: Set coarse pulse width (not recommended; use 3xxx instead)"; - break; - case 0x13: - return "13xx: Set resonance (0 to F)"; - break; - case 0x14: - return "14xx: Set filter mode (bit 0: low pass; bit 1: band pass; bit 2: high pass)"; - break; - case 0x15: - return "15xx: Set envelope reset time"; - break; - case 0x1a: - return "1Axx: Disable envelope reset for this channel (1 disables; 0 enables)"; - break; - case 0x1b: - return "1Bxy: Reset cutoff (x: on new note; y: now)"; - break; - case 0x1c: - return "1Cxy: Reset pulse width (x: on new note; y: now)"; - break; - case 0x1e: - return "1Exy: Change additional parameters"; - break; - case 0x30: case 0x31: case 0x32: case 0x33: - case 0x34: case 0x35: case 0x36: case 0x37: - case 0x38: case 0x39: case 0x3a: case 0x3b: - case 0x3c: case 0x3d: case 0x3e: case 0x3f: - return "3xxx: Set pulse width (0 to FFF)"; - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: - return "4xxx: Set cutoff (0 to 7FF)"; - break; - } - return NULL; -} - void DivPlatformC64::acquire(short* bufL, short* bufR, size_t start, size_t len) { int dcOff=sid.get_dc(0); for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { DivInstrument* ins=parent->getIns(chan[i].ins,DIV_INS_C64); diff --git a/src/engine/platform/c64.h b/src/engine/platform/c64.h index ae1034a82..799635977 100644 --- a/src/engine/platform/c64.h +++ b/src/engine/platform/c64.h @@ -103,7 +103,6 @@ class DivPlatformC64: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void setChipModel(bool is6581); void quit(); diff --git a/src/engine/platform/fds.cpp b/src/engine/platform/fds.cpp index f9fc5b50b..7622a0990 100644 --- a/src/engine/platform/fds.cpp +++ b/src/engine/platform/fds.cpp @@ -55,30 +55,6 @@ const char** DivPlatformFDS::getRegisterSheet() { return regCheatSheetFDS; } -const char* DivPlatformFDS::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Set modulation depth"; - break; - case 0x12: - return "12xy: Set modulation speed high byte (x: enable; y: value)"; - break; - case 0x13: - return "13xx: Set modulation speed low byte"; - break; - case 0x14: - return "14xx: Set modulator position"; - break; - case 0x15: - return "15xx: Set modulator table to waveform"; - break; - } - return NULL; -} - void DivPlatformFDS::acquire_puNES(short* bufL, short* bufR, size_t start, size_t len) { for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } /* if (chan[i].std.duty.had) { diff --git a/src/engine/platform/fds.h b/src/engine/platform/fds.h index f655a7777..2bd983292 100644 --- a/src/engine/platform/fds.h +++ b/src/engine/platform/fds.h @@ -104,7 +104,6 @@ class DivPlatformFDS: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformFDS(); diff --git a/src/engine/platform/gb.cpp b/src/engine/platform/gb.cpp index c29329b95..fea89c71d 100644 --- a/src/engine/platform/gb.cpp +++ b/src/engine/platform/gb.cpp @@ -61,27 +61,6 @@ const char** DivPlatformGB::getRegisterSheet() { return regCheatSheetGB; } -const char* DivPlatformGB::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Set noise length (0: long; 1: short)"; - break; - case 0x12: - return "12xx: Set duty cycle (0 to 3)"; - break; - case 0x13: - return "13xy: Setup sweep (x: time; y: shift)"; - break; - case 0x14: - return "14xx: Set sweep direction (0: up; 1: down)"; - break; - } - return NULL; -} - void DivPlatformGB::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val,24); if (chan[i].baseFreq>255) chan[i].baseFreq=255; if (chan[i].baseFreq<0) chan[i].baseFreq=0; } else { - if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].std.arp.val+24); - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - } - } + chan[i].baseFreq=NOTE_PERIODIC(parent->calcArp(chan[i].note,chan[i].std.arp.val,24)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { chan[i].duty=chan[i].std.duty.val; diff --git a/src/engine/platform/gb.h b/src/engine/platform/gb.h index 00dcca036..516e7d9f1 100644 --- a/src/engine/platform/gb.h +++ b/src/engine/platform/gb.h @@ -115,7 +115,6 @@ class DivPlatformGB: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setFlags(unsigned int flags); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); diff --git a/src/engine/platform/genesis.cpp b/src/engine/platform/genesis.cpp index b6dbb8d12..f499865ef 100644 --- a/src/engine/platform/genesis.cpp +++ b/src/engine/platform/genesis.cpp @@ -27,108 +27,6 @@ #define IS_REALLY_MUTED(x) (isMuted[x] && (x<5 || !softPCM || (isMuted[5] && isMuted[6]))) -const char* DivPlatformGenesis::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xy: Setup LFO (x: enable; y: speed)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x17: - return "17xx: Enable channel 6 DAC"; - break; - case 0x18: - return "18xx: Toggle extended channel 3 mode"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - case 0xdf: - return "DFxx: Set sample playback direction (0: normal; 1: reverse)"; - break; - } - return NULL; -} - void DivPlatformGenesis::processDAC() { if (softPCM) { softPCMTimer+=chipClock/576; @@ -365,26 +263,40 @@ void DivPlatformGenesis::tick(bool sysTick) { } } - if (chan[i].std.arp.had) { - if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].std.arp.val,11); - } else { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note+(signed char)chan[i].std.arp.val,11); + if (i>=5 && chan[i].furnaceDac) { + if (chan[i].std.arp.had) { + if (!chan[i].inPorta) { + chan[i].baseFreq=parent->calcBaseFreq(1,1,parent->calcArp(chan[i].note,chan[i].std.arp.val),false); } + chan[i].freqChanged=true; } - chan[i].freqChanged=true; } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note,11); + if (chan[i].std.arp.had) { + if (!chan[i].inPorta) { + chan[i].baseFreq=NOTE_FNUM_BLOCK(parent->calcArp(chan[i].note,chan[i].std.arp.val),11); + } chan[i].freqChanged=true; } } - if (chan[i].std.panL.had) { - chan[i].pan=chan[i].std.panL.val&3; - if (i<6) { - rWrite(chanOffs[i]+ADDR_LRAF,(IS_REALLY_MUTED(i)?0:(chan[i].pan<<6))|(chan[i].state.fms&7)|((chan[i].state.ams&3)<<4)); + if (i>=5 && chan[i].furnaceDac) { + if (chan[i].std.panL.had) { + chan[5].pan&=1; + chan[5].pan|=chan[i].std.panL.val?2:0; + } + if (chan[i].std.panR.had) { + chan[5].pan&=2; + chan[5].pan|=chan[i].std.panR.val?1:0; + } + if (chan[i].std.panL.had || chan[i].std.panR.had) { + rWrite(chanOffs[5]+ADDR_LRAF,(IS_REALLY_MUTED(i)?0:(chan[5].pan<<6))|(chan[5].state.fms&7)|((chan[5].state.ams&3)<<4)); + } + } else { + if (chan[i].std.panL.had) { + chan[i].pan=chan[i].std.panL.val&3; + if (i<6) { + rWrite(chanOffs[i]+ADDR_LRAF,(IS_REALLY_MUTED(i)?0:(chan[i].pan<<6))|(chan[i].state.fms&7)|((chan[i].state.ams&3)<<4)); + } } } diff --git a/src/engine/platform/genesis.h b/src/engine/platform/genesis.h index c46a992d3..5e61fe678 100644 --- a/src/engine/platform/genesis.h +++ b/src/engine/platform/genesis.h @@ -144,7 +144,6 @@ class DivPlatformGenesis: public DivPlatformOPN { int getPortaFloor(int ch); void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); DivPlatformGenesis(): diff --git a/src/engine/platform/genesisext.cpp b/src/engine/platform/genesisext.cpp index 1f320dd34..dfd7d514c 100644 --- a/src/engine/platform/genesisext.cpp +++ b/src/engine/platform/genesisext.cpp @@ -561,6 +561,11 @@ void DivPlatformGenesisExt::forceIns() { opChan[i].freqChanged=true; } } + if (extMode && softPCM && chan[7].active) { // CSM + chan[7].insChanged=true; + chan[7].freqChanged=true; + chan[7].keyOn=true; + } } void* DivPlatformGenesisExt::getChanState(int ch) { diff --git a/src/engine/platform/lynx.cpp b/src/engine/platform/lynx.cpp index 7c349e5a5..f771be334 100644 --- a/src/engine/platform/lynx.cpp +++ b/src/engine/platform/lynx.cpp @@ -129,19 +129,6 @@ const char** DivPlatformLynx::getRegisterSheet() { return regCheatSheetLynx; } -const char* DivPlatformLynx::getEffectName(unsigned char effect) { - switch (effect) - { - case 0x30: case 0x31: case 0x32: case 0x33: - case 0x34: case 0x35: case 0x36: case 0x37: - case 0x38: case 0x39: case 0x3a: case 0x3b: - case 0x3c: case 0x3d: case 0x3e: case 0x3f: - return "3xxx: Load LFSR (0 to FFF)"; - break; - } - return NULL; -} - void DivPlatformLynx::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; hcalcBaseFreq(1.0,1.0,chan[i].std.arp.val,false); - chan[i].actualNote=chan[i].std.arp.val; - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - if (chan[i].pcm) chan[i].sampleBaseFreq=parent->calcBaseFreq(1.0,1.0,chan[i].note+chan[i].std.arp.val,false); - chan[i].actualNote=chan[i].note+chan[i].std.arp.val; - } - chan[i].freqChanged=true; - } - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - if (chan[i].pcm) chan[i].sampleBaseFreq=parent->calcBaseFreq(1.0,1.0,chan[i].note,false); - chan[i].actualNote=chan[i].note; + chan[i].actualNote=parent->calcArp(chan[i].note,chan[i].std.arp.val); + chan[i].baseFreq=NOTE_PERIODIC(chan[i].actualNote); + if (chan[i].pcm) chan[i].sampleBaseFreq=parent->calcBaseFreq(1.0,1.0,chan[i].actualNote,false); chan[i].freqChanged=true; } } diff --git a/src/engine/platform/lynx.h b/src/engine/platform/lynx.h index 849c3182b..1d7895211 100644 --- a/src/engine/platform/lynx.h +++ b/src/engine/platform/lynx.h @@ -104,7 +104,6 @@ class DivPlatformLynx: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName( unsigned char effect ); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformLynx(); diff --git a/src/engine/platform/mmc5.cpp b/src/engine/platform/mmc5.cpp index 2154e855f..0a3bfb9e7 100644 --- a/src/engine/platform/mmc5.cpp +++ b/src/engine/platform/mmc5.cpp @@ -43,15 +43,6 @@ const char** DivPlatformMMC5::getRegisterSheet() { return regCheatSheetMMC5; } -const char* DivPlatformMMC5::getEffectName(unsigned char effect) { - switch (effect) { - case 0x12: - return "12xx: Set duty cycle/noise mode (pulse: 0 to 3; noise: 0 or 1)"; - break; - } - return NULL; -} - void DivPlatformMMC5::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { chan[i].duty=chan[i].std.duty.val; diff --git a/src/engine/platform/mmc5.h b/src/engine/platform/mmc5.h index f09092d55..90da3eaa2 100644 --- a/src/engine/platform/mmc5.h +++ b/src/engine/platform/mmc5.h @@ -89,7 +89,6 @@ class DivPlatformMMC5: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformMMC5(); diff --git a/src/engine/platform/msm6258.cpp b/src/engine/platform/msm6258.cpp index dc81950ef..0ba3ae0b8 100644 --- a/src/engine/platform/msm6258.cpp +++ b/src/engine/platform/msm6258.cpp @@ -30,18 +30,6 @@ const char** DivPlatformMSM6258::getRegisterSheet() { return NULL; } -const char* DivPlatformMSM6258::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xx: Set frequency divider (0-2)"; - break; - case 0x21: - return "21xx: Select clock rate (0: full; 1: half)"; - break; - } - return NULL; -} - void DivPlatformMSM6258::acquire(short* bufL, short* bufR, size_t start, size_t len) { short* outs[2]={ &msmOut, diff --git a/src/engine/platform/msm6258.h b/src/engine/platform/msm6258.h index cd975c8f8..f6a351b5e 100644 --- a/src/engine/platform/msm6258.h +++ b/src/engine/platform/msm6258.h @@ -109,7 +109,6 @@ class DivPlatformMSM6258: public DivDispatch { void poke(std::vector& wlist); void setFlags(unsigned int flags); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index); size_t getSampleMemCapacity(int index); size_t getSampleMemUsage(int index); diff --git a/src/engine/platform/msm6295.cpp b/src/engine/platform/msm6295.cpp index fc5f9ea30..0a76a2c9b 100644 --- a/src/engine/platform/msm6295.cpp +++ b/src/engine/platform/msm6295.cpp @@ -30,15 +30,6 @@ const char** DivPlatformMSM6295::getRegisterSheet() { return NULL; } -const char* DivPlatformMSM6295::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xx: Set chip output rate (0: clock/132; 1: clock/165)"; - break; - } - return NULL; -} - u8 DivPlatformMSM6295::read_byte(u32 address) { if (adpcmMem==NULL || address>=getSampleMemCapacity(0)) { return 0; diff --git a/src/engine/platform/msm6295.h b/src/engine/platform/msm6295.h index f01c1b233..0953bd33e 100644 --- a/src/engine/platform/msm6295.h +++ b/src/engine/platform/msm6295.h @@ -97,7 +97,6 @@ class DivPlatformMSM6295: public DivDispatch, public vgsound_emu_mem_intf { virtual void poke(std::vector& wlist) override; virtual void setFlags(unsigned int flags) override; virtual const char** getRegisterSheet() override; - virtual const char* getEffectName(unsigned char effect) override; virtual const void* getSampleMem(int index) override; virtual size_t getSampleMemCapacity(int index) override; virtual size_t getSampleMemUsage(int index) override; diff --git a/src/engine/platform/n163.cpp b/src/engine/platform/n163.cpp index b20b460e0..7da2e0a16 100644 --- a/src/engine/platform/n163.cpp +++ b/src/engine/platform/n163.cpp @@ -108,51 +108,6 @@ const char** DivPlatformN163::getRegisterSheet() { return regCheatSheetN163; } -const char* DivPlatformN163::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Select waveform"; - break; - case 0x11: - return "11xx: Set waveform position in RAM (single nibble unit)"; - break; - case 0x12: - return "12xx: Set waveform length in RAM (04 to FC, 4 nibble unit)"; - break; - case 0x13: - return "130x: Change waveform update mode (0: off, bit 0: update now, bit 1: update when every waveform changes)"; - break; - case 0x14: - return "14xx: Select waveform for load to RAM"; - break; - case 0x15: - return "15xx: Set waveform position for load to RAM (single nibble unit)"; - break; - case 0x16: - return "16xx: Set waveform length for load to RAM (04 to FC, 4 nibble unit)"; - break; - case 0x17: - return "170x: Change waveform load mode (0: off, bit 0: load now, bit 1: load when every waveform changes)"; - break; - case 0x18: - return "180x: Change channel limits (0 to 7, x + 1)"; - break; - case 0x20: - return "20xx: (Global) Select waveform for load to RAM"; - break; - case 0x21: - return "21xx: (Global) Set waveform position for load to RAM (single nibble unit)"; - break; - case 0x22: - return "22xx: (Global) Set waveform length for load to RAM (04 to FC, 4 nibble unit)"; - break; - case 0x23: - return "230x: (Global) Change waveform load mode (0: off, bit 0: load now, bit 1: load when every waveform changes)"; - break; - } - return NULL; -} - void DivPlatformN163::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { if (chan[i].wavePos!=chan[i].std.duty.val) { diff --git a/src/engine/platform/n163.h b/src/engine/platform/n163.h index 5e44d3dd8..c77510f56 100644 --- a/src/engine/platform/n163.h +++ b/src/engine/platform/n163.h @@ -110,7 +110,6 @@ class DivPlatformN163: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformN163(); diff --git a/src/engine/platform/namcowsg.cpp b/src/engine/platform/namcowsg.cpp index 00b127930..236790e37 100644 --- a/src/engine/platform/namcowsg.cpp +++ b/src/engine/platform/namcowsg.cpp @@ -151,18 +151,6 @@ const char** DivPlatformNamcoWSG::getRegisterSheet() { return regCheatSheetNamcoWSG; } -const char* DivPlatformNamcoWSG::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Toggle noise mode"; - break; - } - return NULL; -} - void DivPlatformNamcoWSG::acquire(short* bufL, short* bufR, size_t start, size_t len) { while (!writes.empty()) { QueuedWrite w=writes.front(); @@ -218,18 +206,9 @@ void DivPlatformNamcoWSG::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/namcowsg.h b/src/engine/platform/namcowsg.h index 4ab81bdce..ede25e8e6 100644 --- a/src/engine/platform/namcowsg.h +++ b/src/engine/platform/namcowsg.h @@ -96,7 +96,6 @@ class DivPlatformNamcoWSG: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformNamcoWSG(); diff --git a/src/engine/platform/nes.cpp b/src/engine/platform/nes.cpp index bd1be94a8..ab466f1b5 100644 --- a/src/engine/platform/nes.cpp +++ b/src/engine/platform/nes.cpp @@ -62,27 +62,6 @@ const char** DivPlatformNES::getRegisterSheet() { return regCheatSheetNES; } -const char* DivPlatformNES::getEffectName(unsigned char effect) { - switch (effect) { - case 0x11: - return "11xx: Write to delta modulation counter (0 to 7F)"; - break; - case 0x12: - return "12xx: Set duty cycle/noise mode (pulse: 0 to 3; noise: 0 or 1)"; - break; - case 0x13: - return "13xy: Sweep up (x: time; y: shift)"; - break; - case 0x14: - return "14xy: Sweep down (x: time; y: shift)"; - break; - case 0x18: - return "18xx: Select PCM/DPCM mode (0: PCM; 1: DPCM)"; - break; - } - return NULL; -} - void DivPlatformNES::doWrite(unsigned short addr, unsigned char data) { if (useNP) { nes1_NP->Write(addr,data); @@ -240,28 +219,15 @@ void DivPlatformNES::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (i==3) { // noise - if (chan[i].std.arp.mode) { - chan[i].baseFreq=chan[i].std.arp.val; - } else { - chan[i].baseFreq=chan[i].note+chan[i].std.arp.val; - } + chan[i].baseFreq=parent->calcArp(chan[i].note,chan[i].std.arp.val); if (chan[i].baseFreq>255) chan[i].baseFreq=255; if (chan[i].baseFreq<0) chan[i].baseFreq=0; } else { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_PERIODIC(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { chan[i].duty=chan[i].std.duty.val; diff --git a/src/engine/platform/nes.h b/src/engine/platform/nes.h index 35c51df74..c00003305 100644 --- a/src/engine/platform/nes.h +++ b/src/engine/platform/nes.h @@ -106,7 +106,6 @@ class DivPlatformNES: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index); size_t getSampleMemCapacity(int index); size_t getSampleMemUsage(int index); diff --git a/src/engine/platform/opl.cpp b/src/engine/platform/opl.cpp index 8b76db213..eb49637e3 100644 --- a/src/engine/platform/opl.cpp +++ b/src/engine/platform/opl.cpp @@ -152,98 +152,6 @@ const int orderedOpsL[4]={ #define ADDR_FREQH 0xb0 #define ADDR_LR_FB_ALG 0xc0 -const char* DivPlatformOPL::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set global AM depth (0: 1dB, 1: 4.8dB)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 3F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 3F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 3F lowest; 4-op only)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 3F lowest; 4-op only)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x17: - return "17xx: Set global vibrato depth (0: normal, 1: double)"; - break; - case 0x18: - if (properDrumsSys) { - return "18xx: Toggle drums mode (1: enabled; 0: disabled)"; - } - break; - case 0x19: - return "19xx: Set attack of all operators (0 to F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to F; 4-op only)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to F; 4-op only)"; - break; - case 0x2a: - return "2Axy: Set waveform (x: operator from 1 to 4 (0 for all ops); y: waveform from 0 to 3 in OPL2 and 0 to 7 in OPL3)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set vibrato (x: operator from 1 to 4 (0 for all ops); y: enabled)"; - break; - case 0x54: - return "54xy: Set key scale level (x: operator from 1 to 4 (0 for all ops); y: level from 0 to 3)"; - break; - case 0x55: - return "55xy: Set envelope sustain (x: operator from 1 to 4 (0 for all ops); y: enabled)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to F; 4-op only)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to F; 4-op only)"; - break; - case 0x5b: - return "5Bxy: Set whether key will scale envelope (x: operator from 1 to 4 (0 for all ops); y: enabled)"; - break; - } - return NULL; -} - void DivPlatformOPL::acquire_nuked(short* bufL, short* bufR, size_t start, size_t len) { static short o[2]; static int os[2]; @@ -389,18 +297,9 @@ void DivPlatformOPL::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note+(signed char)chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (oplType==3 && chan[i].std.panL.had) { @@ -583,18 +482,9 @@ void DivPlatformOPL::tick(bool sysTick) { if (chan[adpcmChan].std.arp.had) { if (!chan[adpcmChan].inPorta) { - if (chan[adpcmChan].std.arp.mode) { - chan[adpcmChan].baseFreq=NOTE_ADPCMB(chan[adpcmChan].std.arp.val); - } else { - chan[adpcmChan].baseFreq=NOTE_ADPCMB(chan[adpcmChan].note+(signed char)chan[adpcmChan].std.arp.val); - } + chan[adpcmChan].baseFreq=NOTE_ADPCMB(parent->calcArp(chan[adpcmChan].note,chan[adpcmChan].std.arp.val)); } chan[adpcmChan].freqChanged=true; - } else { - if (chan[adpcmChan].std.arp.mode && chan[adpcmChan].std.arp.finished) { - chan[adpcmChan].baseFreq=NOTE_ADPCMB(chan[adpcmChan].note); - chan[adpcmChan].freqChanged=true; - } } } if (chan[adpcmChan].freqChanged) { @@ -1687,7 +1577,7 @@ void DivPlatformOPL::setOPLType(int type, bool drums) { adpcmChan=drums?11:9; } break; - case 3: case 759: + case 3: case 4: case 759: slotsNonDrums=slotsOPL3; slotsDrums=slotsOPL3Drums; slots=drums?slotsDrums:slotsNonDrums; @@ -1701,6 +1591,7 @@ void DivPlatformOPL::setOPLType(int type, bool drums) { pretendYMU=true; adpcmChan=16; } else if (type==4) { + chipFreqBase=32768*684; downsample=true; } break; diff --git a/src/engine/platform/opl.h b/src/engine/platform/opl.h index 3d6497367..e3b16679f 100644 --- a/src/engine/platform/opl.h +++ b/src/engine/platform/opl.h @@ -145,7 +145,6 @@ class DivPlatformOPL: public DivDispatch { int getPortaFloor(int ch); void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index); size_t getSampleMemCapacity(int index); size_t getSampleMemUsage(int index); diff --git a/src/engine/platform/opll.cpp b/src/engine/platform/opll.cpp index 5c9611b43..9485551aa 100644 --- a/src/engine/platform/opll.cpp +++ b/src/engine/platform/opll.cpp @@ -27,68 +27,6 @@ #define CHIP_FREQBASE 1180068 -const char* DivPlatformOPLL::getEffectName(unsigned char effect) { - switch (effect) { - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 3F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 2; y: multiplier)"; - break; - case 0x18: - if (properDrumsSys) { - return "18xx: Toggle drums mode (1: enabled; 0: disabled)"; - } - break; - case 0x19: - return "19xx: Set attack of all operators (0 to F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to F)"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 2 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 2 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 2 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set vibrato (x: operator from 1 to 2 (0 for all ops); y: enabled)"; - break; - case 0x54: - return "54xy: Set key scale level (x: operator from 1 to 2 (0 for all ops); y: level from 0 to 3)"; - break; - case 0x55: - return "55xy: Set envelope sustain (x: operator from 1 to 2 (0 for all ops); y: enabled)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to F)"; - break; - case 0x5b: - return "5Bxy: Set whether key will scale envelope (x: operator from 1 to 2 (0 for all ops); y: enabled)"; - break; - } - return NULL; -} - const unsigned char cycleMapOPLL[18]={ 8, 7, 6, 7, 8, 7, 8, 6, 0, 1, 2, 7, 8, 9, 3, 4, 5, 9 }; @@ -169,18 +107,9 @@ void DivPlatformOPLL::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note+(signed char)chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had && chan[i].state.opllPreset!=16) { diff --git a/src/engine/platform/opll.h b/src/engine/platform/opll.h index dad660dea..21a77b4e6 100644 --- a/src/engine/platform/opll.h +++ b/src/engine/platform/opll.h @@ -122,7 +122,6 @@ class DivPlatformOPLL: public DivDispatch { int getPortaFloor(int ch); void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformOPLL(); diff --git a/src/engine/platform/pce.cpp b/src/engine/platform/pce.cpp index 3fc7a05bd..476b1ecca 100644 --- a/src/engine/platform/pce.cpp +++ b/src/engine/platform/pce.cpp @@ -53,27 +53,6 @@ const char** DivPlatformPCE::getRegisterSheet() { return regCheatSheetPCE; } -const char* DivPlatformPCE::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Toggle noise mode"; - break; - case 0x12: - return "12xx: Setup LFO (0: disabled; 1: 1x depth; 2: 16x depth; 3: 256x depth)"; - break; - case 0x13: - return "13xx: Set LFO speed"; - break; - case 0x17: - return "17xx: Toggle PCM mode"; - break; - } - return NULL; -} - void DivPlatformPCE::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; hsong.properNoiseLayout?(noiseSeek&31):noiseFreq[noiseSeek%12])):0); - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - int noiseSeek=chan[i].note+chan[i].std.arp.val; - if (noiseSeek<0) noiseSeek=0; - chWrite(i,0x07,chan[i].noise?(0x80|(parent->song.properNoiseLayout?(noiseSeek&31):noiseFreq[noiseSeek%12])):0); - } - } - chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - int noiseSeek=chan[i].note; + int noiseSeek=parent->calcArp(chan[i].note,chan[i].std.arp.val); + chan[i].baseFreq=NOTE_PERIODIC(noiseSeek); if (noiseSeek<0) noiseSeek=0; chWrite(i,0x07,chan[i].noise?(0x80|(parent->song.properNoiseLayout?(noiseSeek&31):noiseFreq[noiseSeek%12])):0); - chan[i].freqChanged=true; } + chan[i].freqChanged=true; } if (chan[i].std.wave.had && !chan[i].pcm) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/pce.h b/src/engine/platform/pce.h index 17e191d44..164b70a96 100644 --- a/src/engine/platform/pce.h +++ b/src/engine/platform/pce.h @@ -109,7 +109,6 @@ class DivPlatformPCE: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformPCE(); diff --git a/src/engine/platform/pcmdac.cpp b/src/engine/platform/pcmdac.cpp index 213cb85a3..026e989cc 100644 --- a/src/engine/platform/pcmdac.cpp +++ b/src/engine/platform/pcmdac.cpp @@ -83,18 +83,9 @@ void DivPlatformPCMDAC::tick(bool sysTick) { } if (chan.std.arp.had) { if (!chan.inPorta) { - if (chan.std.arp.mode) { - chan.baseFreq=NOTE_FREQUENCY(chan.std.arp.val); - } else { - chan.baseFreq=NOTE_FREQUENCY(chan.note+chan.std.arp.val); - } + chan.baseFreq=NOTE_FREQUENCY(parent->calcArp(chan.note,chan.std.arp.val)); } chan.freqChanged=true; - } else { - if (chan.std.arp.mode && chan.std.arp.finished) { - chan.baseFreq=NOTE_FREQUENCY(chan.note); - chan.freqChanged=true; - } } if (chan.useWave && chan.std.wave.had) { if (chan.wave!=chan.std.wave.val || chan.ws.activeChanged()) { diff --git a/src/engine/platform/pcspkr.cpp b/src/engine/platform/pcspkr.cpp index d40a297ae..ab3b8a7ca 100644 --- a/src/engine/platform/pcspkr.cpp +++ b/src/engine/platform/pcspkr.cpp @@ -190,10 +190,6 @@ const char** DivPlatformPCSpeaker::getRegisterSheet() { return regCheatSheetPCSpeaker; } -const char* DivPlatformPCSpeaker::getEffectName(unsigned char effect) { - return NULL; -} - const float cut=0.05; const float reso=0.06; @@ -351,18 +347,9 @@ void DivPlatformPCSpeaker::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_PERIODIC(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { if (chan[i].std.pitch.mode) { diff --git a/src/engine/platform/pcspkr.h b/src/engine/platform/pcspkr.h index cb6f070fe..ba6275c32 100644 --- a/src/engine/platform/pcspkr.h +++ b/src/engine/platform/pcspkr.h @@ -113,7 +113,6 @@ class DivPlatformPCSpeaker: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformPCSpeaker(); diff --git a/src/engine/platform/pet.cpp b/src/engine/platform/pet.cpp index dc524e45f..c314edf6f 100644 --- a/src/engine/platform/pet.cpp +++ b/src/engine/platform/pet.cpp @@ -37,15 +37,6 @@ const char** DivPlatformPET::getRegisterSheet() { return regCheatSheet6522; } -const char* DivPlatformPET::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - } - return NULL; -} - // high-level emulation of 6522 shift register and driver software for now void DivPlatformPET::rWrite(unsigned int addr, unsigned char val) { bool hwSROutput=((regPool[11]>>2)&7)==4; @@ -113,18 +104,9 @@ void DivPlatformPET::tick(bool sysTick) { } if (chan.std.arp.had) { if (!chan.inPorta) { - if (chan.std.arp.mode) { - chan.baseFreq=NOTE_PERIODIC(chan.std.arp.val); - } else { - chan.baseFreq=NOTE_PERIODIC(chan.note+chan.std.arp.val); - } + chan.baseFreq=NOTE_PERIODIC(parent->calcArp(chan.note,chan.std.arp.val)); } chan.freqChanged=true; - } else { - if (chan.std.arp.mode && chan.std.arp.finished) { - chan.baseFreq=NOTE_PERIODIC(chan.note); - chan.freqChanged=true; - } } if (chan.std.wave.had) { if (chan.wave!=chan.std.wave.val) { diff --git a/src/engine/platform/pet.h b/src/engine/platform/pet.h index 06c7e736a..8de217790 100644 --- a/src/engine/platform/pet.h +++ b/src/engine/platform/pet.h @@ -80,7 +80,6 @@ class DivPlatformPET: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformPET(); diff --git a/src/engine/platform/qsound.cpp b/src/engine/platform/qsound.cpp index ca6a794cd..9120464e6 100644 --- a/src/engine/platform/qsound.cpp +++ b/src/engine/platform/qsound.cpp @@ -249,24 +249,6 @@ const char** DivPlatformQSound::getRegisterSheet() { return regCheatSheetQSound; } -const char* DivPlatformQSound::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set echo feedback level (00 to FF)"; - break; - case 0x11: - return "11xx: Set channel echo level (00 to FF)"; - break; - case 0x12: - return "12xx: Toggle QSound algorithm (0: disabled; 1: enabled)"; - break; - default: - if ((effect & 0xf0) == 0x30) { - return "3xxx: Set echo delay buffer length (000 to AA5)"; - } - } - return NULL; -} void DivPlatformQSound::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; hcalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=QS_NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { if (chan[i].std.pitch.mode) { @@ -365,7 +338,7 @@ void DivPlatformQSound::tick(bool sysTick) { rWrite(q1_reg_map[Q1V_LOOP][i], qsound_loop); rWrite(q1_reg_map[Q1V_START][i], qsound_addr); rWrite(q1_reg_map[Q1V_PHASE][i], 0x8000); - logV("ch %d bank=%04x, addr=%04x, end=%04x, loop=%04x!",i,qsound_bank,qsound_addr,qsound_end,qsound_loop); + //logV("ch %d bank=%04x, addr=%04x, end=%04x, loop=%04x!",i,qsound_bank,qsound_addr,qsound_end,qsound_loop); // Write sample address. Enable volume if (!chan[i].std.vol.had) { rWrite(q1_reg_map[Q1V_VOL][i], chan[i].vol << 4); diff --git a/src/engine/platform/qsound.h b/src/engine/platform/qsound.h index 285760138..37217072d 100644 --- a/src/engine/platform/qsound.h +++ b/src/engine/platform/qsound.h @@ -96,7 +96,6 @@ class DivPlatformQSound: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index = 0); size_t getSampleMemCapacity(int index = 0); size_t getSampleMemUsage(int index = 0); diff --git a/src/engine/platform/rf5c68.cpp b/src/engine/platform/rf5c68.cpp index e4a39d44e..c032284f1 100644 --- a/src/engine/platform/rf5c68.cpp +++ b/src/engine/platform/rf5c68.cpp @@ -43,10 +43,6 @@ const char** DivPlatformRF5C68::getRegisterSheet() { return regCheatSheetRF5C68; } -const char* DivPlatformRF5C68::getEffectName(unsigned char effect) { - return NULL; -} - void DivPlatformRF5C68::chWrite(unsigned char ch, unsigned int addr, unsigned char val) { if (!skipRegisterWrites) { if (curChan!=ch) { @@ -88,18 +84,9 @@ void DivPlatformRF5C68::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { if (chan[i].std.pitch.mode) { @@ -120,7 +107,7 @@ void DivPlatformRF5C68::tick(bool sysTick) { chan[i].panning|=(chan[i].std.panR.val&15)<<4; } if (chan[i].std.panL.had || chan[i].std.panR.had) { - chWrite(i,0x05,isMuted[i]?0:chan[i].panning); + chWrite(i,1,isMuted[i]?0:chan[i].panning); } if (chan[i].setPos) { // force keyon diff --git a/src/engine/platform/rf5c68.h b/src/engine/platform/rf5c68.h index 6946b4900..d82c926e6 100644 --- a/src/engine/platform/rf5c68.h +++ b/src/engine/platform/rf5c68.h @@ -92,7 +92,6 @@ class DivPlatformRF5C68: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index = 0); size_t getSampleMemCapacity(int index = 0); size_t getSampleMemUsage(int index = 0); diff --git a/src/engine/platform/saa.cpp b/src/engine/platform/saa.cpp index 103c3348f..b7a77d968 100644 --- a/src/engine/platform/saa.cpp +++ b/src/engine/platform/saa.cpp @@ -56,21 +56,6 @@ const char** DivPlatformSAA1099::getRegisterSheet() { return regCheatSheetSAA; } -const char* DivPlatformSAA1099::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xy: Set channel mode (x: noise; y: tone)"; - break; - case 0x11: - return "11xx: Set noise frequency"; - break; - case 0x12: - return "12xx: Setup envelope (refer to docs for more information)"; - break; - } - return NULL; -} - void DivPlatformSAA1099::acquire_saaSound(short* bufL, short* bufR, size_t start, size_t len) { if (saaBufLencalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { saaNoise[i/3]=chan[i].std.duty.val&3; diff --git a/src/engine/platform/saa.h b/src/engine/platform/saa.h index 0efd498d6..92855be7e 100644 --- a/src/engine/platform/saa.h +++ b/src/engine/platform/saa.h @@ -96,7 +96,6 @@ class DivPlatformSAA1099: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); }; diff --git a/src/engine/platform/scc.cpp b/src/engine/platform/scc.cpp index 485839bf1..d8859cffd 100644 --- a/src/engine/platform/scc.cpp +++ b/src/engine/platform/scc.cpp @@ -80,15 +80,6 @@ const char** DivPlatformSCC::getRegisterSheet() { return isPlus ? regCheatSheetSCCPlus : regCheatSheetSCC; } -const char* DivPlatformSCC::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - } - return NULL; -} - void DivPlatformSCC::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; hcalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/scc.h b/src/engine/platform/scc.h index 43a8be5ae..f9fa31725 100644 --- a/src/engine/platform/scc.h +++ b/src/engine/platform/scc.h @@ -84,7 +84,6 @@ class DivPlatformSCC: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setFlags(unsigned int flags); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void setChipModel(bool isPlus); diff --git a/src/engine/platform/segapcm.cpp b/src/engine/platform/segapcm.cpp index d66fcce0b..329e3b82a 100644 --- a/src/engine/platform/segapcm.cpp +++ b/src/engine/platform/segapcm.cpp @@ -26,15 +26,6 @@ //#define rWrite(a,v) if (!skipRegisterWrites) {pendingWrites[a]=v;} //#define immWrite(a,v) if (!skipRegisterWrites) {writes.emplace(a,v); if (dumpWrites) {addWrite(a,v);} } -const char* DivPlatformSegaPCM::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xx: Set PCM frequency"; - break; - } - return NULL; -} - void DivPlatformSegaPCM::acquire(short* bufL, short* bufR, size_t start, size_t len) { static int os[2]; @@ -97,18 +88,9 @@ void DivPlatformSegaPCM::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=(chan[i].std.arp.val<<6); - } else { - chan[i].baseFreq=((chan[i].note+(signed char)chan[i].std.arp.val)<<6); - } + chan[i].baseFreq=(parent->calcArp(chan[i].note,chan[i].std.arp.val)<<6); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=(chan[i].note<<6); - chan[i].freqChanged=true; - } } if (chan[i].std.panL.had) { diff --git a/src/engine/platform/segapcm.h b/src/engine/platform/segapcm.h index 6edc85302..0dd4b837a 100644 --- a/src/engine/platform/segapcm.h +++ b/src/engine/platform/segapcm.h @@ -114,7 +114,6 @@ class DivPlatformSegaPCM: public DivDispatch { bool isStereo(); void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformSegaPCM(); diff --git a/src/engine/platform/sms.cpp b/src/engine/platform/sms.cpp index 3d11a5ac9..d4d77f171 100644 --- a/src/engine/platform/sms.cpp +++ b/src/engine/platform/sms.cpp @@ -38,15 +38,6 @@ const char** DivPlatformSMS::getRegisterSheet() { return stereo?regCheatSheetGG:regCheatSheetSN; } -const char* DivPlatformSMS::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xy: Set noise mode (x: preset freq/ch3 freq; y: thin pulse/noise)"; - break; - } - return NULL; -} - void DivPlatformSMS::acquire_nuked(short* bufL, short* bufR, size_t start, size_t len) { int oL=0; int oR=0; @@ -141,22 +132,12 @@ void DivPlatformSMS::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].std.arp.val); - chan[i].actualNote=chan[i].std.arp.val; - } else { - // TODO: check whether this weird octave boundary thing applies to other systems as well - int areYouSerious=chan[i].note+chan[i].std.arp.val; - while (areYouSerious>0x60) areYouSerious-=12; - chan[i].baseFreq=NOTE_PERIODIC(areYouSerious); - chan[i].actualNote=areYouSerious; - } - chan[i].freqChanged=true; - } - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].actualNote=chan[i].note; + // TODO: check whether this weird octave boundary thing applies to other systems as well + // TODO: add compatibility flag. this is horrible. + int areYouSerious=parent->calcArp(chan[i].note,chan[i].std.arp.val); + while (areYouSerious>0x60) areYouSerious-=12; + chan[i].baseFreq=NOTE_PERIODIC(areYouSerious); + chan[i].actualNote=areYouSerious; chan[i].freqChanged=true; } } @@ -197,7 +178,11 @@ void DivPlatformSMS::tick(bool sysTick) { if (chan[i].freqChanged) { chan[i].freq=parent->calcFreq(chan[i].baseFreq,chan[i].pitch,true,0,chan[i].pitch2,chipClock,toneDivider); if (chan[i].freq>1023) chan[i].freq=1023; - if (chan[i].freq<8) chan[i].freq=1; + if (parent->song.snNoLowPeriods) { + if (chan[i].freq<8) chan[i].freq=1; + } else { + if (chan[i].freq<0) chan[i].freq=0; + } //if (chan[i].actualNote>0x5d) chan[i].freq=0x01; rWrite(0,0x80|i<<5|(chan[i].freq&15)); rWrite(0,chan[i].freq>>4); @@ -212,7 +197,9 @@ void DivPlatformSMS::tick(bool sysTick) { if (chan[3].freqChanged || updateSNMode) { chan[3].freq=parent->calcFreq(chan[3].baseFreq,chan[3].pitch,true,0,chan[3].pitch2,chipClock,noiseDivider); if (chan[3].freq>1023) chan[3].freq=1023; - if (chan[3].actualNote>0x5d) chan[3].freq=0x01; + if (parent->song.snNoLowPeriods) { + if (chan[3].actualNote>0x5d) chan[3].freq=0x01; + } if (snNoiseMode&2) { // take period from channel 3 if (updateSNMode || resetPhase) { if (snNoiseMode&1) { @@ -232,12 +219,8 @@ void DivPlatformSMS::tick(bool sysTick) { } else { // 3 fixed values unsigned char value; if (chan[3].std.arp.had) { - if (chan[3].std.arp.mode) { - value=chan[3].std.arp.val%12; - } else { - value=(chan[3].note+chan[3].std.arp.val)%12; - } - } else { + value=parent->calcArp(chan[3].note,chan[3].std.arp.val)%12; + } else { // pardon? value=chan[3].note%12; } if (value<3) { diff --git a/src/engine/platform/sms.h b/src/engine/platform/sms.h index 35bb44bab..eef54da1e 100644 --- a/src/engine/platform/sms.h +++ b/src/engine/platform/sms.h @@ -101,7 +101,6 @@ class DivPlatformSMS: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setNuked(bool value); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); diff --git a/src/engine/platform/su.cpp b/src/engine/platform/su.cpp index afcdba242..136503457 100644 --- a/src/engine/platform/su.cpp +++ b/src/engine/platform/su.cpp @@ -33,72 +33,6 @@ const char** DivPlatformSoundUnit::getRegisterSheet() { return NULL; } -const char* DivPlatformSoundUnit::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set waveform (0 to 7)"; - break; - case 0x12: - return "12xx: Set pulse width (0 to 7F)"; - break; - case 0x13: - return "13xx: Set resonance (0 to F)"; - break; - case 0x14: - return "14xx: Set filter mode (bit 0: ring mod; bit 1: low pass; bit 2: high pass; bit 3: band pass)"; - break; - case 0x15: - return "15xx: Set frequency sweep period low byte"; - break; - case 0x16: - return "16xx: Set frequency sweep period high byte"; - break; - case 0x17: - return "17xx: Set volume sweep period low byte"; - break; - case 0x18: - return "18xx: Set volume sweep period high byte"; - break; - case 0x19: - return "19xx: Set cutoff sweep period low byte"; - break; - case 0x1a: - return "1Axx: Set cutoff sweep period high byte"; - break; - case 0x1b: - return "1Bxx: Set frequency sweep boundary"; - break; - case 0x1c: - return "1Cxx: Set volume sweep boundary"; - break; - case 0x1d: - return "1Dxx: Set cutoff sweep boundary"; - break; - case 0x1e: - return "1Exx: Set phase reset period low byte"; - break; - case 0x1f: - return "1Fxx: Set phase reset period high byte"; - break; - case 0x20: - return "20xx: Toggle frequency sweep (bit 0-6: speed; bit 7: direction is up)"; - break; - case 0x21: - return "21xx: Toggle volume sweep (bit 0-4: speed; bit 5: direciton is up; bit 6: loop; bit 7: alternate)"; - break; - case 0x22: - return "22xx: Toggle cutoff sweep (bit 0-6: speed; bit 7: direction is up)"; - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: - case 0x48: case 0x49: case 0x4a: case 0x4b: - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - return "4xxx: Set cutoff (0 to FFF)"; - break; - } - return NULL; -} - double DivPlatformSoundUnit::NOTE_SU(int ch, int note) { if (chan[ch].switchRoles) { return NOTE_PERIODIC(note); @@ -144,18 +78,9 @@ void DivPlatformSoundUnit::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_SU(i,chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_SU(i,chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_SU(i,parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_SU(i,chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { chan[i].duty=chan[i].std.duty.val; @@ -432,7 +357,7 @@ int DivPlatformSoundUnit::dispatch(DivCommand c) { writeControlUpper(c.chan); break; case DIV_CMD_C64_FINE_CUTOFF: - chan[c.chan].baseCutoff=c.value; + chan[c.chan].baseCutoff=c.value*4; if (!chan[c.chan].std.ex1.has) { chan[c.chan].cutoff=chan[c.chan].baseCutoff; chWrite(c.chan,0x06,chan[c.chan].cutoff&0xff); diff --git a/src/engine/platform/su.h b/src/engine/platform/su.h index 2392624f6..d76d07227 100644 --- a/src/engine/platform/su.h +++ b/src/engine/platform/su.h @@ -133,7 +133,6 @@ class DivPlatformSoundUnit: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index); size_t getSampleMemCapacity(int index); size_t getSampleMemUsage(int index); diff --git a/src/engine/platform/swan.cpp b/src/engine/platform/swan.cpp index b6da23271..7f1e10a02 100644 --- a/src/engine/platform/swan.cpp +++ b/src/engine/platform/swan.cpp @@ -50,27 +50,6 @@ const char** DivPlatformSwan::getRegisterSheet() { return regCheatSheetWS; } -const char* DivPlatformSwan::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Setup noise mode (0: disabled; 1-8: enabled/tap)"; - break; - case 0x12: - return "12xx: Setup sweep period (0: disabled; 1-20: enabled/period)"; - break; - case 0x13: - return "13xx: Set sweep amount"; - break; - case 0x17: - return "17xx: Toggle PCM mode"; - break; - } - return NULL; -} - void DivPlatformSwan::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; hcalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had && !(i==1 && pcm)) { if (chan[i].wave!=chan[i].std.wave.val || chan[i].ws.activeChanged()) { diff --git a/src/engine/platform/swan.h b/src/engine/platform/swan.h index aafb17ace..cf7926385 100644 --- a/src/engine/platform/swan.h +++ b/src/engine/platform/swan.h @@ -93,7 +93,6 @@ class DivPlatformSwan: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformSwan(); diff --git a/src/engine/platform/tia.cpp b/src/engine/platform/tia.cpp index ddb380844..82d032703 100644 --- a/src/engine/platform/tia.cpp +++ b/src/engine/platform/tia.cpp @@ -34,15 +34,6 @@ const char* regCheatSheetTIA[]={ NULL }; -const char* DivPlatformTIA::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Select shape (0 to F)"; - break; - } - return NULL; -} - const char** DivPlatformTIA::getRegisterSheet() { return regCheatSheetTIA; } @@ -96,20 +87,18 @@ void DivPlatformTIA::tick(bool sysTick) { rWrite(0x19+i,chan[i].outVol&15); } } + // TODO: the way arps work on TIA is really weird if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=0x80000000|chan[i].std.arp.val; + if (chan[i].std.arp.val<0 && (!(chan[i].std.arp.val&0x40000000))) { + chan[i].baseFreq=0x80000000|(chan[i].std.arp.val|0x40000000); + } else if (chan[i].std.arp.val>=0 && chan[i].std.arp.val&0x40000000) { + chan[i].baseFreq=0x80000000|(chan[i].std.arp.val&(~0x40000000)); } else { chan[i].baseFreq=(chan[i].note+chan[i].std.arp.val)<<8; } } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=chan[i].note<<8; - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had) { chan[i].shape=chan[i].std.wave.val&15; @@ -126,13 +115,6 @@ void DivPlatformTIA::tick(bool sysTick) { chan[i].freqChanged=true; } if (chan[i].freqChanged || chan[i].keyOn || chan[i].keyOff) { - if (chan[i].insChanged) { - if (!chan[i].std.wave.will) { - chan[i].shape=4; - rWrite(0x15+i,chan[i].shape); - } - chan[i].insChanged=false; - } chan[i].freq=dealWithFreq(chan[i].shape,chan[i].baseFreq,chan[i].pitch)+chan[i].pitch2; if ((chan[i].shape==4 || chan[i].shape==5) && !(chan[i].baseFreq&0x80000000 && ((chan[i].baseFreq&0x7fffffff)<32))) { if (chan[i].baseFreq<39*256) { @@ -173,6 +155,13 @@ int DivPlatformTIA::dispatch(DivCommand c) { if (!parent->song.brokenOutVol && !chan[c.chan].std.vol.will) { chan[c.chan].outVol=chan[c.chan].vol; } + if (chan[c.chan].insChanged) { + if (!chan[c.chan].std.wave.will) { + chan[c.chan].shape=4; + rWrite(0x15+c.chan,chan[c.chan].shape); + } + chan[c.chan].insChanged=false; + } if (isMuted[c.chan]) { rWrite(0x19+c.chan,0); } else { diff --git a/src/engine/platform/tia.h b/src/engine/platform/tia.h index cabe91533..168175367 100644 --- a/src/engine/platform/tia.h +++ b/src/engine/platform/tia.h @@ -67,7 +67,6 @@ class DivPlatformTIA: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); }; diff --git a/src/engine/platform/tx81z.cpp b/src/engine/platform/tx81z.cpp index 9d24e4db5..0fe0265e1 100644 --- a/src/engine/platform/tx81z.cpp +++ b/src/engine/platform/tx81z.cpp @@ -55,139 +55,6 @@ const char** DivPlatformTX81Z::getRegisterSheet() { return regCheatSheetOPZ; } -const char* DivPlatformTX81Z::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Set noise frequency (xx: value; 0 disables noise)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x17: - return "17xx: Set LFO speed"; - break; - case 0x18: - return "18xx: Set LFO waveform (0 saw, 1 square, 2 triangle, 3 noise)"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x1e: - return "1Exx: Set AM depth (0 to 7F)"; - break; - case 0x1f: - return "1Fxx: Set PM depth (0 to 7F)"; - break; - case 0x28: - return "28xy: Set reverb (x: operator from 1 to 4 (0 for all ops); y: reverb from 0 to 7)"; - break; - case 0x2a: - return "2Axy: Set waveform (x: operator from 1 to 4 (0 for all ops); y: waveform from 0 to 7)"; - break; - case 0x2b: - return "2Bxy: Set envelope generator shift (x: operator from 1 to 4 (0 for all ops); y: shift from 0 to 3)"; - break; - case 0x2c: - return "2Cxy: Set fine multiplier (x: operator from 1 to 4 (0 for all ops); y: fine)"; - break; - case 0x2f: - return "2Fxx: Toggle hard envelope reset on new notes"; - break; - case 0x30: case 0x31: case 0x32: case 0x33: - case 0x34: case 0x35: case 0x36: case 0x37: - return "3xyy: Set fixed frequency of operator 1 (x: octave from 0 to 7; y: frequency)"; - break; - case 0x38: case 0x39: case 0x3a: case 0x3b: - case 0x3c: case 0x3d: case 0x3e: case 0x3f: - return "3xyy: Set fixed frequency of operator 2 (x: octave from 8 to F; y: frequency)"; - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: - return "4xyy: Set fixed frequency of operator 3 (x: octave from 0 to 7; y: frequency)"; - break; - case 0x48: case 0x49: case 0x4a: case 0x4b: - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - return "4xyy: Set fixed frequency of operator 4 (x: octave from 8 to F; y: frequency)"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set detune 2 (x: operator from 1 to 4 (0 for all ops); y: detune from 0 to 3)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - void DivPlatformTX81Z::acquire(short* bufL, short* bufR, size_t start, size_t len) { static int os[2]; @@ -256,18 +123,9 @@ void DivPlatformTX81Z::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_LINEAR(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_LINEAR(chan[i].note+(signed char)chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_LINEAR(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_LINEAR(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { diff --git a/src/engine/platform/tx81z.h b/src/engine/platform/tx81z.h index e867416cf..d1e427282 100644 --- a/src/engine/platform/tx81z.h +++ b/src/engine/platform/tx81z.h @@ -108,7 +108,6 @@ class DivPlatformTX81Z: public DivPlatformOPM { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformTX81Z(); diff --git a/src/engine/platform/vera.cpp b/src/engine/platform/vera.cpp index 0b261a946..f05f1d88b 100644 --- a/src/engine/platform/vera.cpp +++ b/src/engine/platform/vera.cpp @@ -53,18 +53,6 @@ const char** DivPlatformVERA::getRegisterSheet() { return regCheatSheetVERA; } -const char* DivPlatformVERA::getEffectName(unsigned char effect) { - switch (effect) { - case 0x20: - return "20xx: Change waveform"; - break; - case 0x22: - return "22xx: Set duty cycle (0 to 3F)"; - break; - } - return NULL; -} - void DivPlatformVERA::acquire(short* bufL, short* bufR, size_t start, size_t len) { // both PSG part and PCM part output a full 16-bit range, putting bufL/R // argument right into both could cause an overflow @@ -173,18 +161,9 @@ void DivPlatformVERA::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=calcNoteFreq(0,chan[i].std.arp.val); - } else { - chan[i].baseFreq=calcNoteFreq(0,chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=calcNoteFreq(0,parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=calcNoteFreq(0,chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { rWriteLo(i,3,chan[i].std.duty.val); @@ -223,18 +202,9 @@ void DivPlatformVERA::tick(bool sysTick) { } if (chan[16].std.arp.had) { if (!chan[16].inPorta) { - if (chan[16].std.arp.mode) { - chan[16].baseFreq=calcNoteFreq(16,chan[16].std.arp.val); - } else { - chan[16].baseFreq=calcNoteFreq(16,chan[16].note+chan[16].std.arp.val); - } + chan[16].baseFreq=calcNoteFreq(16,parent->calcArp(chan[16].note,chan[16].std.arp.val)); } chan[16].freqChanged=true; - } else { - if (chan[16].std.arp.mode && chan[16].std.arp.finished) { - chan[16].baseFreq=calcNoteFreq(16,chan[16].note); - chan[16].freqChanged=true; - } } if (chan[16].freqChanged) { double off=65536.0; diff --git a/src/engine/platform/vera.h b/src/engine/platform/vera.h index 612b4354b..53e766dcd 100644 --- a/src/engine/platform/vera.h +++ b/src/engine/platform/vera.h @@ -79,7 +79,6 @@ class DivPlatformVERA: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformVERA(); diff --git a/src/engine/platform/vic20.cpp b/src/engine/platform/vic20.cpp index 771b87d1e..93c119484 100644 --- a/src/engine/platform/vic20.cpp +++ b/src/engine/platform/vic20.cpp @@ -39,15 +39,6 @@ const char** DivPlatformVIC20::getRegisterSheet() { return regCheatSheetVIC; } -const char* DivPlatformVIC20::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - } - return NULL; -} - void DivPlatformVIC20::acquire(short* bufL, short* bufR, size_t start, size_t len) { const unsigned char loadFreq[3] = {0x7e, 0x7d, 0x7b}; const unsigned char wavePatterns[16] = { @@ -103,18 +94,9 @@ void DivPlatformVIC20::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_PERIODIC(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.wave.had) { if (chan[i].wave!=chan[i].std.wave.val) { diff --git a/src/engine/platform/vic20.h b/src/engine/platform/vic20.h index d23f27be8..d4b56028c 100644 --- a/src/engine/platform/vic20.h +++ b/src/engine/platform/vic20.h @@ -82,7 +82,6 @@ class DivPlatformVIC20: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformVIC20(); diff --git a/src/engine/platform/vrc6.cpp b/src/engine/platform/vrc6.cpp index 8a34d9252..2500ce190 100644 --- a/src/engine/platform/vrc6.cpp +++ b/src/engine/platform/vrc6.cpp @@ -46,18 +46,6 @@ const char** DivPlatformVRC6::getRegisterSheet() { return regCheatSheetVRC6; } -const char* DivPlatformVRC6::getEffectName(unsigned char effect) { - switch (effect) { - case 0x12: - return "12xx: Set duty cycle (pulse: 0 to 7)"; - break; - case 0x17: - return "17xx: Toggle PCM mode (pulse channel)"; - break; - } - return NULL; -} - void DivPlatformVRC6::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t i=start; icalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_PERIODIC(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.duty.had) { chan[i].duty=chan[i].std.duty.val; diff --git a/src/engine/platform/vrc6.h b/src/engine/platform/vrc6.h index 450e09b98..608baa100 100644 --- a/src/engine/platform/vrc6.h +++ b/src/engine/platform/vrc6.h @@ -99,7 +99,6 @@ class DivPlatformVRC6: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); DivPlatformVRC6() : vrc6(intf) {}; diff --git a/src/engine/platform/x1_010.cpp b/src/engine/platform/x1_010.cpp index e2e360b1b..0f989ac9d 100644 --- a/src/engine/platform/x1_010.cpp +++ b/src/engine/platform/x1_010.cpp @@ -205,39 +205,6 @@ const char** DivPlatformX1_010::getRegisterSheet() { return regCheatSheetX1_010; } -const char* DivPlatformX1_010::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xx: Change waveform"; - break; - case 0x11: - return "11xx: Change envelope shape"; - break; - case 0x17: - return "17xx: Toggle PCM mode"; - break; - case 0x20: - return "20xx: Set PCM frequency (1 to FF)"; - break; - case 0x22: - return "22xx: Set envelope mode (bit 0: enable, bit 1: one-shot, bit 2: split shape to L/R, bit 3/5: H.invert right/left, bit 4/6: V.invert right/left)"; - break; - case 0x23: - return "23xx: Set envelope period"; - break; - case 0x25: - return "25xx: Envelope slide up"; - break; - case 0x26: - return "26xx: Envelope slide down"; - break; - case 0x29: - return "29xy: Set auto-envelope (x: numerator; y: denominator)"; - break; - } - return NULL; -} - void DivPlatformX1_010::acquire(short* bufL, short* bufR, size_t start, size_t len) { for (size_t h=start; htick(); @@ -354,18 +321,9 @@ void DivPlatformX1_010::tick(bool sysTick) { if ((!chan[i].pcm) || chan[i].furnacePCM) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NoteX1_010(i,chan[i].std.arp.val); - } else { - chan[i].baseFreq=NoteX1_010(i,chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NoteX1_010(i,parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NoteX1_010(i,chan[i].note); - chan[i].freqChanged=true; - } } } if (chan[i].std.wave.had && !chan[i].pcm) { diff --git a/src/engine/platform/x1_010.h b/src/engine/platform/x1_010.h index 7a85b6336..178a89383 100644 --- a/src/engine/platform/x1_010.h +++ b/src/engine/platform/x1_010.h @@ -149,7 +149,6 @@ class DivPlatformX1_010: public DivDispatch { size_t getSampleMemUsage(int index = 0); void renderSamples(); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformX1_010(); diff --git a/src/engine/platform/ym2203.cpp b/src/engine/platform/ym2203.cpp index 83c93c58e..178ef05b8 100644 --- a/src/engine/platform/ym2203.cpp +++ b/src/engine/platform/ym2203.cpp @@ -156,123 +156,6 @@ const char** DivPlatformYM2203::getRegisterSheet() { return regCheatSheetYM2203; } -const char* DivPlatformYM2203::getEffectName(unsigned char effect) { - switch (effect) { - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x18: - return "18xx: Toggle extended channel 3 mode"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x20: - return "20xx: Set SSG channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set SSG noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set SSG envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set SSG envelope period low byte"; - break; - case 0x24: - return "24xx: Set SSG envelope period high byte"; - break; - case 0x25: - return "25xx: SSG envelope slide up"; - break; - case 0x26: - return "26xx: SSG envelope slide down"; - break; - case 0x29: - return "29xy: Set SSG auto-envelope (x: numerator; y: denominator)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - void DivPlatformYM2203::acquire(short* bufL, short* bufR, size_t start, size_t len) { static int os; @@ -348,18 +231,9 @@ void DivPlatformYM2203::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].std.arp.val,11); - } else { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note+(signed char)chan[i].std.arp.val,11); - } + chan[i].baseFreq=NOTE_FNUM_BLOCK(parent->calcArp(chan[i].note,chan[i].std.arp.val),11); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note,11); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { diff --git a/src/engine/platform/ym2203.h b/src/engine/platform/ym2203.h index d406e2f28..0395c9d0f 100644 --- a/src/engine/platform/ym2203.h +++ b/src/engine/platform/ym2203.h @@ -114,7 +114,6 @@ class DivPlatformYM2203: public DivPlatformOPN { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setFlags(unsigned int flags); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); diff --git a/src/engine/platform/ym2608.cpp b/src/engine/platform/ym2608.cpp index c3cf52a06..244e4a16e 100644 --- a/src/engine/platform/ym2608.cpp +++ b/src/engine/platform/ym2608.cpp @@ -279,126 +279,6 @@ const char** DivPlatformYM2608::getRegisterSheet() { return regCheatSheetYM2608; } -const char* DivPlatformYM2608::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xy: Setup LFO (x: enable; y: speed)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x18: - return "18xx: Toggle extended channel 3 mode"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x20: - return "20xx: Set SSG channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set SSG noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set SSG envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set SSG envelope period low byte"; - break; - case 0x24: - return "24xx: Set SSG envelope period high byte"; - break; - case 0x25: - return "25xx: SSG envelope slide up"; - break; - case 0x26: - return "26xx: SSG envelope slide down"; - break; - case 0x29: - return "29xy: Set SSG auto-envelope (x: numerator; y: denominator)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - double DivPlatformYM2608::NOTE_OPNB(int ch, int note) { if (ch>8) { // ADPCM-B return NOTE_ADPCMB(note); @@ -506,18 +386,9 @@ void DivPlatformYM2608::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].std.arp.val,11); - } else { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note+(signed char)chan[i].std.arp.val,11); - } + chan[i].baseFreq=NOTE_FNUM_BLOCK(parent->calcArp(chan[i].note,chan[i].std.arp.val),11); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note,11); - chan[i].freqChanged=true; - } } if (chan[i].std.panL.had) { @@ -658,18 +529,9 @@ void DivPlatformYM2608::tick(bool sysTick) { if (chan[15].std.arp.had) { if (!chan[15].inPorta) { - if (chan[15].std.arp.mode) { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].std.arp.val); - } else { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].note+(signed char)chan[15].std.arp.val); - } + chan[15].baseFreq=NOTE_ADPCMB(parent->calcArp(chan[15].note,chan[15].std.arp.val)); } chan[15].freqChanged=true; - } else { - if (chan[15].std.arp.mode && chan[15].std.arp.finished) { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].note); - chan[15].freqChanged=true; - } } } if (chan[15].freqChanged) { diff --git a/src/engine/platform/ym2608.h b/src/engine/platform/ym2608.h index ac38a8c08..7a471b8bf 100644 --- a/src/engine/platform/ym2608.h +++ b/src/engine/platform/ym2608.h @@ -127,7 +127,6 @@ class DivPlatformYM2608: public DivPlatformOPN { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index); size_t getSampleMemCapacity(int index); size_t getSampleMemUsage(int index); diff --git a/src/engine/platform/ym2610.cpp b/src/engine/platform/ym2610.cpp index 4e01b005c..064b49f2d 100644 --- a/src/engine/platform/ym2610.cpp +++ b/src/engine/platform/ym2610.cpp @@ -318,126 +318,6 @@ const char** DivPlatformYM2610::getRegisterSheet() { return regCheatSheetYM2610; } -const char* DivPlatformYM2610::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xy: Setup LFO (x: enable; y: speed)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x18: - return "18xx: Toggle extended channel 3 mode"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x20: - return "20xx: Set SSG channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set SSG noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set SSG envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set SSG envelope period low byte"; - break; - case 0x24: - return "24xx: Set SSG envelope period high byte"; - break; - case 0x25: - return "25xx: SSG envelope slide up"; - break; - case 0x26: - return "26xx: SSG envelope slide down"; - break; - case 0x29: - return "29xy: Set SSG auto-envelope (x: numerator; y: denominator)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - double DivPlatformYM2610::NOTE_OPNB(int ch, int note) { if (ch>6) { // ADPCM return NOTE_ADPCMB(note); @@ -547,18 +427,9 @@ void DivPlatformYM2610::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].std.arp.val,11); - } else { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note+(signed char)chan[i].std.arp.val,11); - } + chan[i].baseFreq=NOTE_FNUM_BLOCK(parent->calcArp(chan[i].note,chan[i].std.arp.val),11); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note,11); - chan[i].freqChanged=true; - } } if (chan[i].std.panL.had) { @@ -700,18 +571,9 @@ void DivPlatformYM2610::tick(bool sysTick) { if (chan[13].std.arp.had) { if (!chan[13].inPorta) { - if (chan[13].std.arp.mode) { - chan[13].baseFreq=NOTE_ADPCMB(chan[13].std.arp.val); - } else { - chan[13].baseFreq=NOTE_ADPCMB(chan[13].note+(signed char)chan[13].std.arp.val); - } + chan[13].baseFreq=NOTE_ADPCMB(parent->calcArp(chan[13].note,chan[13].std.arp.val)); } chan[13].freqChanged=true; - } else { - if (chan[13].std.arp.mode && chan[13].std.arp.finished) { - chan[13].baseFreq=NOTE_ADPCMB(chan[13].note); - chan[13].freqChanged=true; - } } } if (chan[13].freqChanged) { diff --git a/src/engine/platform/ym2610.h b/src/engine/platform/ym2610.h index dde7ed105..5e22ed2a0 100644 --- a/src/engine/platform/ym2610.h +++ b/src/engine/platform/ym2610.h @@ -145,7 +145,6 @@ class DivPlatformYM2610: public DivPlatformYM2610Base { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setFlags(unsigned int flags); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); diff --git a/src/engine/platform/ym2610b.cpp b/src/engine/platform/ym2610b.cpp index 1a1f7f0ae..8d283374d 100644 --- a/src/engine/platform/ym2610b.cpp +++ b/src/engine/platform/ym2610b.cpp @@ -302,126 +302,6 @@ const char** DivPlatformYM2610B::getRegisterSheet() { return regCheatSheetYM2610B; } -const char* DivPlatformYM2610B::getEffectName(unsigned char effect) { - switch (effect) { - case 0x10: - return "10xy: Setup LFO (x: enable; y: speed)"; - break; - case 0x11: - return "11xx: Set feedback (0 to 7)"; - break; - case 0x12: - return "12xx: Set level of operator 1 (0 highest, 7F lowest)"; - break; - case 0x13: - return "13xx: Set level of operator 2 (0 highest, 7F lowest)"; - break; - case 0x14: - return "14xx: Set level of operator 3 (0 highest, 7F lowest)"; - break; - case 0x15: - return "15xx: Set level of operator 4 (0 highest, 7F lowest)"; - break; - case 0x16: - return "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)"; - break; - case 0x18: - return "18xx: Toggle extended channel 3 mode"; - break; - case 0x19: - return "19xx: Set attack of all operators (0 to 1F)"; - break; - case 0x1a: - return "1Axx: Set attack of operator 1 (0 to 1F)"; - break; - case 0x1b: - return "1Bxx: Set attack of operator 2 (0 to 1F)"; - break; - case 0x1c: - return "1Cxx: Set attack of operator 3 (0 to 1F)"; - break; - case 0x1d: - return "1Dxx: Set attack of operator 4 (0 to 1F)"; - break; - case 0x20: - return "20xx: Set SSG channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"; - break; - case 0x21: - return "21xx: Set SSG noise frequency (0 to 1F)"; - break; - case 0x22: - return "22xy: Set SSG envelope mode (x: shape, y: enable for this channel)"; - break; - case 0x23: - return "23xx: Set SSG envelope period low byte"; - break; - case 0x24: - return "24xx: Set SSG envelope period high byte"; - break; - case 0x25: - return "25xx: SSG envelope slide up"; - break; - case 0x26: - return "26xx: SSG envelope slide down"; - break; - case 0x29: - return "29xy: Set SSG auto-envelope (x: numerator; y: denominator)"; - break; - case 0x30: - return "30xx: Toggle hard envelope reset on new notes"; - break; - case 0x50: - return "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)"; - break; - case 0x51: - return "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)"; - break; - case 0x52: - return "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)"; - break; - case 0x53: - return "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)"; - break; - case 0x54: - return "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)"; - break; - case 0x55: - return "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)"; - break; - case 0x56: - return "56xx: Set decay of all operators (0 to 1F)"; - break; - case 0x57: - return "57xx: Set decay of operator 1 (0 to 1F)"; - break; - case 0x58: - return "58xx: Set decay of operator 2 (0 to 1F)"; - break; - case 0x59: - return "59xx: Set decay of operator 3 (0 to 1F)"; - break; - case 0x5a: - return "5Axx: Set decay of operator 4 (0 to 1F)"; - break; - case 0x5b: - return "5Bxx: Set decay 2 of all operators (0 to 1F)"; - break; - case 0x5c: - return "5Cxx: Set decay 2 of operator 1 (0 to 1F)"; - break; - case 0x5d: - return "5Dxx: Set decay 2 of operator 2 (0 to 1F)"; - break; - case 0x5e: - return "5Exx: Set decay 2 of operator 3 (0 to 1F)"; - break; - case 0x5f: - return "5Fxx: Set decay 2 of operator 4 (0 to 1F)"; - break; - } - return NULL; -} - double DivPlatformYM2610B::NOTE_OPNB(int ch, int note) { if (ch>8) { // ADPCM-B return NOTE_ADPCMB(note); @@ -530,18 +410,9 @@ void DivPlatformYM2610B::tick(bool sysTick) { if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].std.arp.val,11); - } else { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note+(signed char)chan[i].std.arp.val,11); - } + chan[i].baseFreq=NOTE_FNUM_BLOCK(parent->calcArp(chan[i].note,chan[i].std.arp.val),11); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FNUM_BLOCK(chan[i].note,11); - chan[i].freqChanged=true; - } } if (chan[i].std.panL.had) { @@ -682,18 +553,9 @@ void DivPlatformYM2610B::tick(bool sysTick) { if (chan[15].std.arp.had) { if (!chan[15].inPorta) { - if (chan[15].std.arp.mode) { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].std.arp.val); - } else { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].note+(signed char)chan[15].std.arp.val); - } + chan[15].baseFreq=NOTE_ADPCMB(parent->calcArp(chan[15].note,chan[15].std.arp.val)); } chan[15].freqChanged=true; - } else { - if (chan[15].std.arp.mode && chan[15].std.arp.finished) { - chan[15].baseFreq=NOTE_ADPCMB(chan[15].note); - chan[15].freqChanged=true; - } } } if (chan[15].freqChanged) { diff --git a/src/engine/platform/ym2610b.h b/src/engine/platform/ym2610b.h index fefb06929..703f8dd4a 100644 --- a/src/engine/platform/ym2610b.h +++ b/src/engine/platform/ym2610b.h @@ -113,7 +113,6 @@ class DivPlatformYM2610B: public DivPlatformYM2610Base { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); void setFlags(unsigned int flags); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); diff --git a/src/engine/platform/ymz280b.cpp b/src/engine/platform/ymz280b.cpp index 0543a815c..eb65a7bda 100644 --- a/src/engine/platform/ymz280b.cpp +++ b/src/engine/platform/ymz280b.cpp @@ -60,10 +60,6 @@ const char** DivPlatformYMZ280B::getRegisterSheet() { return regCheatSheetYMZ280B; } -const char* DivPlatformYMZ280B::getEffectName(unsigned char effect) { - return NULL; -} - void DivPlatformYMZ280B::acquire(short* bufL, short* bufR, size_t start, size_t len) { short buf[16][256]; short *bufPtrs[16]={ @@ -99,18 +95,9 @@ void DivPlatformYMZ280B::tick(bool sysTick) { } if (chan[i].std.arp.had) { if (!chan[i].inPorta) { - if (chan[i].std.arp.mode) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].std.arp.val); - } else { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note+chan[i].std.arp.val); - } + chan[i].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { if (chan[i].std.pitch.mode) { diff --git a/src/engine/platform/ymz280b.h b/src/engine/platform/ymz280b.h index 0d254c088..6dbe2623c 100644 --- a/src/engine/platform/ymz280b.h +++ b/src/engine/platform/ymz280b.h @@ -91,7 +91,6 @@ class DivPlatformYMZ280B: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); const void* getSampleMem(int index = 0); size_t getSampleMemCapacity(int index = 0); size_t getSampleMemUsage(int index = 0); diff --git a/src/engine/platform/zxbeeper.cpp b/src/engine/platform/zxbeeper.cpp index 01702dc5d..5fa3840bb 100644 --- a/src/engine/platform/zxbeeper.cpp +++ b/src/engine/platform/zxbeeper.cpp @@ -27,18 +27,6 @@ const char** DivPlatformZXBeeper::getRegisterSheet() { return NULL; } -const char* DivPlatformZXBeeper::getEffectName(unsigned char effect) { - switch (effect) { - case 0x12: - return "12xx: Set pulse width"; - break; - case 0x17: - return "17xx: Trigger overlay drum"; - break; - } - return NULL; -} - void DivPlatformZXBeeper::acquire(short* bufL, short* bufR, size_t start, size_t len) { bool o=false; for (size_t h=start; hcalcArp(chan[i].note,chan[i].std.arp.val)); } chan[i].freqChanged=true; - } else { - if (chan[i].std.arp.mode && chan[i].std.arp.finished) { - chan[i].baseFreq=NOTE_FREQUENCY(chan[i].note); - chan[i].freqChanged=true; - } } if (chan[i].std.pitch.had) { if (chan[i].std.pitch.mode) { diff --git a/src/engine/platform/zxbeeper.h b/src/engine/platform/zxbeeper.h index a9b400cb6..226f556de 100644 --- a/src/engine/platform/zxbeeper.h +++ b/src/engine/platform/zxbeeper.h @@ -92,7 +92,6 @@ class DivPlatformZXBeeper: public DivDispatch { void poke(unsigned int addr, unsigned short val); void poke(std::vector& wlist); const char** getRegisterSheet(); - const char* getEffectName(unsigned char effect); int init(DivEngine* parent, int channels, int sugRate, unsigned int flags); void quit(); ~DivPlatformZXBeeper(); diff --git a/src/engine/playback.cpp b/src/engine/playback.cpp index 3dbc6b5fb..7fb9583d7 100644 --- a/src/engine/playback.cpp +++ b/src/engine/playback.cpp @@ -292,13 +292,39 @@ int DivEngine::dispatchCmd(DivCommand c) { } bool DivEngine::perSystemEffect(int ch, unsigned char effect, unsigned char effectVal) { - if (sysDefs[sysOfChan[ch]]==NULL) return false; - return sysDefs[sysOfChan[ch]]->effectFunc(ch,effect,effectVal); + DivSysDef* sysDef=sysDefs[sysOfChan[ch]]; + if (sysDef==NULL) return false; + auto iter=sysDef->effectHandlers.find(effect); + if (iter==sysDef->effectHandlers.end()) return false; + EffectHandler handler=iter->second; + int val=0; + int val2=0; + try { + val=handler.val?handler.val(effect,effectVal):effectVal; + val2=handler.val2?handler.val2(effect,effectVal):0; + } catch (DivDoNotHandleEffect& e) { + return false; + } + // wouldn't this cause problems if it were to return 0? + return dispatchCmd(DivCommand(handler.dispatchCmd,ch,val,val2)); } bool DivEngine::perSystemPostEffect(int ch, unsigned char effect, unsigned char effectVal) { - if (sysDefs[sysOfChan[ch]]==NULL) return false; - return sysDefs[sysOfChan[ch]]->postEffectFunc(ch,effect,effectVal); + DivSysDef* sysDef=sysDefs[sysOfChan[ch]]; + if (sysDef==NULL) return false; + auto iter=sysDef->postEffectHandlers.find(effect); + if (iter==sysDef->postEffectHandlers.end()) return false; + EffectHandler handler=iter->second; + int val=0; + int val2=0; + try { + val=handler.val?handler.val(effect,effectVal):effectVal; + val2=handler.val2?handler.val2(effect,effectVal):0; + } catch (DivDoNotHandleEffect& e) { + return true; + } + // wouldn't this cause problems if it were to return 0? + return dispatchCmd(DivCommand(handler.dispatchCmd,ch,val,val2)); } void DivEngine::processRow(int i, bool afterDelay) { @@ -335,7 +361,9 @@ void DivEngine::processRow(int i, bool afterDelay) { break; case 0xed: // delay if (effectVal!=0) { - if (effectVal<=nextSpeed) { + bool comparison=(song.delayBehavior==1)?(effectVal<=nextSpeed):(effectVal%d",effectVal,nextSpeed); chan[i].delayLocked=false; } } @@ -353,6 +382,8 @@ void DivEngine::processRow(int i, bool afterDelay) { } } if (returnAfterPre) return; + } else { + logV("honoring delay at position %d",whatRow); } if (chan[i].delayLocked) return; @@ -609,9 +640,6 @@ void DivEngine::processRow(int i, bool afterDelay) { clockDrift=0; subticks=0; break; - case 0xdf: // set sample direction - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_DIR,i,effectVal)); - break; case 0xe0: // arp speed if (effectVal>0) { curSubSong->arpLen=effectVal; @@ -681,7 +709,7 @@ void DivEngine::processRow(int i, bool afterDelay) { dispatchCmd(DivCommand(DIV_CMD_SAMPLE_BANK,i,effectVal)); break; case 0xec: // delayed note cut - if (effectVal>0 && effectVal0 && (song.delayBehavior==2 || effectValmidiOut->send(TAMidiMessage(TA_MIDI_CLOCK,0,0)); } + if (!pendingNotes.empty()) { + bool isOn[DIV_MAX_CHANS]; + memset(isOn,0,DIV_MAX_CHANS*sizeof(bool)); + + for (int i=pendingNotes.size()-1; i>=0; i--) { + if (pendingNotes[i].channel<0 || pendingNotes[i].channel>=chans) continue; + if (pendingNotes[i].on) { + isOn[pendingNotes[i].channel]=true; + } else { + if (isOn[pendingNotes[i].channel]) { + logV("erasing off -> on sequence in %d",pendingNotes[i].channel); + pendingNotes.erase(pendingNotes.begin()+i); + } + } + } + } + while (!pendingNotes.empty()) { DivNoteEvent& note=pendingNotes.front(); if (note.channel<0 || note.channel>=chans) { - pendingNotes.pop(); + pendingNotes.pop_front(); continue; } if (note.on) { @@ -1003,7 +1050,7 @@ bool DivEngine::nextTick(bool noAccum, bool inhibitLowLat) { dispatchCmd(DivCommand(DIV_CMD_NOTE_OFF,note.channel)); } } - pendingNotes.pop(); + pendingNotes.pop_front(); } if (!freelance) { @@ -1215,7 +1262,7 @@ void DivEngine::nextBuf(float** in, float** out, int inChans, int outChans, unsi case TA_MIDI_NOTE_OFF: { if (chan<0 || chan>=chans) break; if (midiIsDirect) { - pendingNotes.push(DivNoteEvent(chan,-1,-1,-1,false)); + pendingNotes.push_back(DivNoteEvent(chan,-1,-1,-1,false)); } else { autoNoteOff(msg.type&15,msg.data[0]-12,msg.data[1]); } @@ -1230,13 +1277,13 @@ void DivEngine::nextBuf(float** in, float** out, int inChans, int outChans, unsi if (chan<0 || chan>=chans) break; if (msg.data[1]==0) { if (midiIsDirect) { - pendingNotes.push(DivNoteEvent(chan,-1,-1,-1,false)); + pendingNotes.push_back(DivNoteEvent(chan,-1,-1,-1,false)); } else { autoNoteOff(msg.type&15,msg.data[0]-12,msg.data[1]); } } else { if (midiIsDirect) { - pendingNotes.push(DivNoteEvent(chan,ins,msg.data[0]-12,msg.data[1],true)); + pendingNotes.push_back(DivNoteEvent(chan,ins,msg.data[0]-12,msg.data[1],true)); } else { autoNoteOn(msg.type&15,ins,msg.data[0]-12,msg.data[1]); } diff --git a/src/engine/safeReader.cpp b/src/engine/safeReader.cpp index 3cb1f4b1f..76e337a3d 100644 --- a/src/engine/safeReader.cpp +++ b/src/engine/safeReader.cpp @@ -77,6 +77,85 @@ signed char SafeReader::readC() { return (signed char)buf[curSeek++]; } +#ifdef TA_BIG_ENDIAN +short SafeReader::readS_BE() { +#ifdef READ_DEBUG + logD("SR: reading short %x:",curSeek); +#endif + if (curSeek+2>len) throw EndOfFileException(this,len); + short ret; + memcpy(&ret,&buf[curSeek],2); +#ifdef READ_DEBUG + logD("SR: %.4x",ret); +#endif + curSeek+=2; + return ret; +} + +short SafeReader::readS() { + if (curSeek+2>len) throw EndOfFileException(this,len); + short ret; + memcpy(&ret,&buf[curSeek],2); + curSeek+=2; + return ((ret>>8)&0xff)|(ret<<8); +} + +int SafeReader::readI_BE() { +#ifdef READ_DEBUG + logD("SR: reading int %x:",curSeek); +#endif + if (curSeek+4>len) throw EndOfFileException(this,len); + int ret; + memcpy(&ret,&buf[curSeek],4); + curSeek+=4; +#ifdef READ_DEBUG + logD("SR: %.8x",ret); +#endif + return ret; +} + +int SafeReader::readI() { + if (curSeek+4>len) throw EndOfFileException(this,len); + unsigned int ret; + memcpy(&ret,&buf[curSeek],4); + curSeek+=4; + return (int)((ret>>24)|((ret&0xff0000)>>8)|((ret&0xff00)<<8)|((ret&0xff)<<24)); +} + +int64_t SafeReader::readL() { + if (curSeek+8>len) throw EndOfFileException(this,len); + unsigned char ret[8]; + memcpy(ret,&buf[curSeek],8); + curSeek+=8; + return (int64_t)(ret[0]|(ret[1]<<8)|(ret[2]<<16)|(ret[3]<<24)|((uint64_t)ret[4]<<32)|((uint64_t)ret[5]<<40)|((uint64_t)ret[6]<<48)|((uint64_t)ret[7]<<56)); +} + +float SafeReader::readF() { + if (curSeek+4>len) throw EndOfFileException(this,len); + unsigned int ret; + memcpy(&ret,&buf[curSeek],4); + curSeek+=4; + ret=((ret>>24)|((ret&0xff0000)>>8)|((ret&0xff00)<<8)|((ret&0xff)<<24)); + return *((float*)(&ret)); +} + +double SafeReader::readD() { + if (curSeek+8>len) throw EndOfFileException(this,len); + unsigned char ret[8]; + unsigned char retB[8]; + memcpy(ret,&buf[curSeek],8); + curSeek+=8; + retB[0]=ret[7]; + retB[1]=ret[6]; + retB[2]=ret[5]; + retB[3]=ret[4]; + retB[4]=ret[3]; + retB[5]=ret[2]; + retB[6]=ret[1]; + retB[7]=ret[0]; + return *((double*)retB); +} +#else short SafeReader::readS() { #ifdef READ_DEBUG logD("SR: reading short %x:",curSeek); @@ -144,6 +223,7 @@ double SafeReader::readD() { curSeek+=8; return ret; } +#endif String SafeReader::readString(size_t stlen) { String ret; diff --git a/src/engine/safeWriter.cpp b/src/engine/safeWriter.cpp index 336793808..83fe48902 100644 --- a/src/engine/safeWriter.cpp +++ b/src/engine/safeWriter.cpp @@ -81,9 +81,64 @@ int SafeWriter::writeUC(unsigned char val) { return write(&val,1); } +#ifdef TA_BIG_ENDIAN +int SafeWriter::writeS_BE(short val) { + return write(&val,2); +} + +int SafeWriter::writeS(short val) { + unsigned char bytes[2]{(unsigned char)((val>>8)&0xff), (unsigned char)(val&0xff)}; + return write(bytes,2); +} + +int SafeWriter::writeI(int val) { + unsigned char bytes[4]; + bytes[0]=((unsigned int)val)&0xff; + bytes[1]=(((unsigned int)val)>>8)&0xff; + bytes[2]=(((unsigned int)val)>>16)&0xff; + bytes[3]=(((unsigned int)val)>>24)&0xff; + return write(bytes,4); +} + +int SafeWriter::writeL(int64_t val) { + unsigned char bytes[8]; + bytes[0]=((uint64_t)val)&0xff; + bytes[1]=(((uint64_t)val)>>8)&0xff; + bytes[2]=(((uint64_t)val)>>16)&0xff; + bytes[3]=(((uint64_t)val)>>24)&0xff; + bytes[4]=(((uint64_t)val)>>32)&0xff; + bytes[5]=(((uint64_t)val)>>40)&0xff; + bytes[6]=(((uint64_t)val)>>48)&0xff; + bytes[7]=(((uint64_t)val)>>56)&0xff; + return write(bytes,8); +} + +int SafeWriter::writeF(float val) { + unsigned char bytes[4]; + bytes[0]=((unsigned char*)(&val))[3]; + bytes[1]=((unsigned char*)(&val))[2]; + bytes[2]=((unsigned char*)(&val))[1]; + bytes[3]=((unsigned char*)(&val))[0]; + return write(bytes,4); +} + +int SafeWriter::writeD(double val) { + unsigned char bytes[8]; + bytes[0]=((unsigned char*)(&val))[7]; + bytes[1]=((unsigned char*)(&val))[6]; + bytes[2]=((unsigned char*)(&val))[5]; + bytes[3]=((unsigned char*)(&val))[4]; + bytes[4]=((unsigned char*)(&val))[3]; + bytes[5]=((unsigned char*)(&val))[2]; + bytes[6]=((unsigned char*)(&val))[1]; + bytes[7]=((unsigned char*)(&val))[0]; + return write(bytes,8); +} +#else int SafeWriter::writeS(short val) { return write(&val,2); } + int SafeWriter::writeS_BE(short val) { unsigned char bytes[2]{(unsigned char)((val>>8)&0xff), (unsigned char)(val&0xff)}; return write(bytes,2); @@ -92,23 +147,20 @@ int SafeWriter::writeS_BE(short val) { int SafeWriter::writeI(int val) { return write(&val,4); } + int SafeWriter::writeL(int64_t val) { return write(&val,8); } + int SafeWriter::writeF(float val) { return write(&val,4); } + int SafeWriter::writeD(double val) { return write(&val,8); } -int SafeWriter::writeString(String val, bool pascal) { - if (pascal) { - writeC((unsigned char)val.size()); - return write(val.c_str(),val.size())+1; - } else { - return write(val.c_str(),val.size()+1); - } -} +#endif + int SafeWriter::writeWString(WString val, bool pascal) { if (pascal) { writeS((unsigned short)val.size()); @@ -124,10 +176,20 @@ int SafeWriter::writeWString(WString val, bool pascal) { return 2+val.size()*2; } } + int SafeWriter::writeText(String val) { return write(val.c_str(),val.size()); } +int SafeWriter::writeString(String val, bool pascal) { + if (pascal) { + writeC((unsigned char)val.size()); + return write(val.c_str(),val.size())+1; + } else { + return write(val.c_str(),val.size()+1); + } +} + void SafeWriter::init() { if (operative) return; buf=new unsigned char[WRITER_BUF_SIZE]; diff --git a/src/engine/song.h b/src/engine/song.h index de422a24a..ac49832e7 100644 --- a/src/engine/song.h +++ b/src/engine/song.h @@ -463,6 +463,11 @@ struct DivSong { // 1: fake reset on loop // 2: don't do anything on loop unsigned char loopModality; + // cut/delay effect behavior + // 0: strict (don't allow value higher than or equal to speed) + // 1: broken (don't allow value higher than speed) + // 2: lax (allow value higher than speed) + unsigned char delayBehavior; bool properNoiseLayout; bool waveDutyIsVol; bool resetMacroOnPorta; @@ -500,6 +505,7 @@ struct DivSong { bool brokenOutVol; bool e1e2StopOnSameNote; bool brokenPortaArp; + bool snNoLowPeriods; std::vector ins; std::vector wave; @@ -563,7 +569,8 @@ struct DivSong { limitSlides(false), linearPitch(2), pitchSlideSpeed(4), - loopModality(0), + loopModality(2), + delayBehavior(2), properNoiseLayout(true), waveDutyIsVol(false), resetMacroOnPorta(false), @@ -600,7 +607,8 @@ struct DivSong { volMacroLinger(true), brokenOutVol(false), e1e2StopOnSameNote(false), - brokenPortaArp(false) { + brokenPortaArp(false), + snNoLowPeriods(false) { for (int i=0; i<32; i++) { system[i]=DIV_SYSTEM_NULL; systemVol[i]=64; diff --git a/src/engine/sysDef.cpp b/src/engine/sysDef.cpp index e3c356cf7..1c63431f9 100644 --- a/src/engine/sysDef.cpp +++ b/src/engine/sysDef.cpp @@ -284,6 +284,10 @@ const char* DivEngine::getSystemNameJ(DivSystem sys) { */ } +const DivSysDef* DivEngine::getSystemDef(DivSystem sys) { + return sysDefs[sys]; +} + bool DivEngine::isFMSystem(DivSystem sys) { if (sysDefs[sys]==NULL) return false; return sysDefs[sys]->isFM; @@ -360,390 +364,222 @@ int DivEngine::minVGMVersion(DivSystem which) { // {chanTypes, ...}, // {chanPreferInsType, ...}, // {chanPreferInsType2, ...}, (optional) -// [this](int ch, unsigned char effect, unsigned char effectVal) -> bool {}, (effect handler, optional) -// [this](int ch, unsigned char effect, unsigned char effectVal) -> bool {} (post effect handler, optional) +// {{effect, {DIV_CMD_xx, "Description"}}, ...}, (effect handler, optional) +// {{effect, {DIV_CMD_xx, "Description"}}, ...} (post effect handler, optional) // ); +template int constVal(unsigned char, unsigned char) { + return val; +}; + +int effectVal(unsigned char, unsigned char val) { + return val; +}; + +int negEffectVal(unsigned char, unsigned char val) { + return -(int)val; +}; + +template int effectValAnd(unsigned char, unsigned char val) { + return val&mask; +}; + +template int effectOpVal(unsigned char, unsigned char val) { + if ((val>>4)>maxOp) throw DivDoNotHandleEffect(); + return (val>>4)-1; +}; + +template int effectOpValNoZero(unsigned char, unsigned char val) { + if ((val>>4)<1 || (val>>4)>maxOp) throw DivDoNotHandleEffect(); + return (val>>4)-1; +}; + +template int effectValLong(unsigned char cmd, unsigned char val) { + return ((((unsigned int)cmd)&((1<<(bits-8))-1))<<8)|((unsigned int)val); +}; + void DivEngine::registerSystems() { logD("registering systems..."); - auto fmPostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // LFO or noise mode - if (IS_OPM_LIKE) { - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_FREQ,ch,effectVal)); - } else { - dispatchCmd(DivCommand(DIV_CMD_FM_LFO,ch,effectVal)); - } - break; - case 0x11: // FB - dispatchCmd(DivCommand(DIV_CMD_FM_FB,ch,effectVal&7)); - break; - case 0x12: // TL op1 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,0,effectVal&0x7f)); - break; - case 0x13: // TL op2 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,1,effectVal&0x7f)); - break; - case 0x14: // TL op3 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,2,effectVal&0x7f)); - break; - case 0x15: // TL op4 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,3,effectVal&0x7f)); - break; - case 0x16: // MULT - if ((effectVal>>4)>0 && (effectVal>>4)<5) { - dispatchCmd(DivCommand(DIV_CMD_FM_MULT,ch,(effectVal>>4)-1,effectVal&15)); - } - break; - case 0x17: // arcade LFO - if (IS_OPM_LIKE) { - dispatchCmd(DivCommand(DIV_CMD_FM_LFO,ch,effectVal)); - } - break; - case 0x18: // EXT or LFO waveform - if (IS_OPM_LIKE) { - dispatchCmd(DivCommand(DIV_CMD_FM_LFO_WAVE,ch,effectVal)); - } else { - dispatchCmd(DivCommand(DIV_CMD_FM_EXTCH,ch,effectVal)); - } - break; - case 0x19: // AR global - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,-1,effectVal&31)); - break; - case 0x1a: // AR op1 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,0,effectVal&31)); - break; - case 0x1b: // AR op2 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,1,effectVal&31)); - break; - case 0x1c: // AR op3 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,2,effectVal&31)); - break; - case 0x1d: // AR op4 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,3,effectVal&31)); - break; - case 0x1e: // UNOFFICIAL: Arcade AM depth - dispatchCmd(DivCommand(DIV_CMD_FM_AM_DEPTH,ch,effectVal&127)); - break; - case 0x1f: // UNOFFICIAL: Arcade PM depth - dispatchCmd(DivCommand(DIV_CMD_FM_PM_DEPTH,ch,effectVal&127)); - break; - case 0x20: // Neo Geo PSG mode - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - } - break; - case 0x21: // Neo Geo PSG noise freq - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_FREQ,ch,effectVal)); - } - break; - case 0x22: // UNOFFICIAL: Neo Geo PSG envelope enable - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SET,ch,effectVal)); - } - break; - case 0x23: // UNOFFICIAL: Neo Geo PSG envelope period low - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_LOW,ch,effectVal)); - } - break; - case 0x24: // UNOFFICIAL: Neo Geo PSG envelope period high - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_HIGH,ch,effectVal)); - } - break; - case 0x25: // UNOFFICIAL: Neo Geo PSG envelope slide up - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SLIDE,ch,-effectVal)); - } - break; - case 0x26: // UNOFFICIAL: Neo Geo PSG envelope slide down - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SLIDE,ch,effectVal)); - } - break; - case 0x29: // auto-envelope - if (IS_YM2610) { - dispatchCmd(DivCommand(DIV_CMD_AY_AUTO_ENVELOPE,ch,effectVal)); - } - break; - // fixed frequency effects on OPZ - case 0x30: case 0x31: case 0x32: case 0x33: - case 0x34: case 0x35: case 0x36: case 0x37: - if (sysOfChan[ch]==DIV_SYSTEM_OPZ) { - dispatchCmd(DivCommand(DIV_CMD_FM_FIXFREQ,ch,0,((effect&7)<<8)|effectVal)); - } - break; - case 0x38: case 0x39: case 0x3a: case 0x3b: - case 0x3c: case 0x3d: case 0x3e: case 0x3f: - if (sysOfChan[ch]==DIV_SYSTEM_OPZ) { - dispatchCmd(DivCommand(DIV_CMD_FM_FIXFREQ,ch,1,((effect&7)<<8)|effectVal)); - } - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: - if (sysOfChan[ch]==DIV_SYSTEM_OPZ) { - dispatchCmd(DivCommand(DIV_CMD_FM_FIXFREQ,ch,2,((effect&7)<<8)|effectVal)); - } - break; - case 0x48: case 0x49: case 0x4a: case 0x4b: - case 0x4c: case 0x4d: case 0x4e: case 0x4f: - if (sysOfChan[ch]==DIV_SYSTEM_OPZ) { - dispatchCmd(DivCommand(DIV_CMD_FM_FIXFREQ,ch,3,((effect&7)<<8)|effectVal)); - } - break; - // extra FM effects here - OP_EFFECT_SINGLE(0x50,DIV_CMD_FM_AM,4,1); - OP_EFFECT_SINGLE(0x51,DIV_CMD_FM_SL,4,15); - OP_EFFECT_SINGLE(0x52,DIV_CMD_FM_RR,4,15); - OP_EFFECT_SINGLE(0x53,DIV_CMD_FM_DT,4,7); - OP_EFFECT_SINGLE(0x54,DIV_CMD_FM_RS,4,3); - OP_EFFECT_SINGLE(0x55,DIV_CMD_FM_SSG,4,(IS_OPM_LIKE?3:15)); + // Common effect handler maps - OP_EFFECT_MULTI(0x56,DIV_CMD_FM_DR,-1,31); - OP_EFFECT_MULTI(0x57,DIV_CMD_FM_DR,0,31); - OP_EFFECT_MULTI(0x58,DIV_CMD_FM_DR,1,31); - OP_EFFECT_MULTI(0x59,DIV_CMD_FM_DR,2,31); - OP_EFFECT_MULTI(0x5a,DIV_CMD_FM_DR,3,31); - - OP_EFFECT_MULTI(0x5b,DIV_CMD_FM_D2R,-1,31); - OP_EFFECT_MULTI(0x5c,DIV_CMD_FM_D2R,0,31); - OP_EFFECT_MULTI(0x5d,DIV_CMD_FM_D2R,1,31); - OP_EFFECT_MULTI(0x5e,DIV_CMD_FM_D2R,2,31); - OP_EFFECT_MULTI(0x5f,DIV_CMD_FM_D2R,3,31); - - OP_EFFECT_SINGLE(0x28,DIV_CMD_FM_REV,4,7); - OP_EFFECT_SINGLE(0x2a,DIV_CMD_FM_WS,4,7); - OP_EFFECT_SINGLE(0x2b,DIV_CMD_FM_EG_SHIFT,4,3); - OP_EFFECT_SINGLE(0x2c,DIV_CMD_FM_FINE,4,15); - default: - return false; - } - return true; + EffectHandlerMap ayPostEffectHandlerMap={ + {0x20, {DIV_CMD_STD_NOISE_MODE, "20xx: Set channel mode (bit 0: square; bit 1: noise; bit 2: envelope)"}}, + {0x21, {DIV_CMD_STD_NOISE_FREQ, "21xx: Set noise frequency (0 to 1F)"}}, + {0x22, {DIV_CMD_AY_ENVELOPE_SET, "22xy: Set envelope mode (x: shape, y: enable for this channel)"}}, + {0x23, {DIV_CMD_AY_ENVELOPE_LOW, "23xx: Set envelope period low byte"}}, + {0x24, {DIV_CMD_AY_ENVELOPE_HIGH, "24xx: Set envelope period high byte"}}, + {0x25, {DIV_CMD_AY_ENVELOPE_SLIDE, "25xx: Envelope slide up", negEffectVal}}, + {0x26, {DIV_CMD_AY_ENVELOPE_SLIDE, "26xx: Envelope slide down"}}, + {0x29, {DIV_CMD_AY_AUTO_ENVELOPE, "29xy: Set auto-envelope (x: numerator; y: denominator)"}}, + {0x2e, {DIV_CMD_AY_IO_WRITE, "2Exx: Write to I/O port A", constVal<0>, effectVal}}, + {0x2f, {DIV_CMD_AY_IO_WRITE, "2Fxx: Write to I/O port B", constVal<1>, effectVal}}, }; - auto fmOPLLPostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x11: // FB - dispatchCmd(DivCommand(DIV_CMD_FM_FB,ch,effectVal&7)); - break; - case 0x12: // TL op1 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,0,effectVal&0x3f)); - break; - case 0x13: // TL op2 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,1,effectVal&0x0f)); - break; - case 0x16: // MULT - if ((effectVal>>4)>0 && (effectVal>>4)<3) { - dispatchCmd(DivCommand(DIV_CMD_FM_MULT,ch,(effectVal>>4)-1,effectVal&15)); - } - break; - case 0x19: // AR global - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,-1,effectVal&31)); - break; - case 0x1a: // AR op1 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,0,effectVal&31)); - break; - case 0x1b: // AR op2 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,1,effectVal&31)); - break; + EffectHandlerMap ay8930PostEffectHandlerMap(ayPostEffectHandlerMap); + ay8930PostEffectHandlerMap.insert({ + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set duty cycle (0 to 8)", + [](unsigned char, unsigned char val) -> int { return 0x10+(val&15); }}}, + {0x27, {DIV_CMD_AY_NOISE_MASK_AND, "27xx: Set noise AND mask"}}, + {0x28, {DIV_CMD_AY_NOISE_MASK_OR, "28xx: Set noise OR mask"}}, + {0x2d, {DIV_CMD_AY_IO_WRITE, "2Dxx: NOT TO BE EMPLOYED BY THE COMPOSER", constVal<255>, effectVal}}, + }); - // extra FM effects here - OP_EFFECT_SINGLE(0x50,DIV_CMD_FM_AM,2,1); - OP_EFFECT_SINGLE(0x51,DIV_CMD_FM_SL,2,15); - OP_EFFECT_SINGLE(0x52,DIV_CMD_FM_RR,2,15); - OP_EFFECT_SINGLE(0x53,DIV_CMD_FM_VIB,2,1); - OP_EFFECT_SINGLE(0x54,DIV_CMD_FM_RS,2,3); - OP_EFFECT_SINGLE(0x55,DIV_CMD_FM_SUS,2,1); - - OP_EFFECT_MULTI(0x56,DIV_CMD_FM_DR,-1,15); - OP_EFFECT_MULTI(0x57,DIV_CMD_FM_DR,0,15); - OP_EFFECT_MULTI(0x58,DIV_CMD_FM_DR,1,15); - - OP_EFFECT_SINGLE(0x5b,DIV_CMD_FM_KSR,2,1); - default: - return false; - } - return true; + EffectHandlerMap fmEffectHandlerMap={ + {0x30, {DIV_CMD_FM_HARD_RESET, "30xx: Toggle hard envelope reset on new notes"}}, }; - auto fmOPLPostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // DAM - dispatchCmd(DivCommand(DIV_CMD_FM_LFO,ch,effectVal&1)); - break; - case 0x11: // FB - dispatchCmd(DivCommand(DIV_CMD_FM_FB,ch,effectVal&7)); - break; - case 0x12: // TL op1 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,0,effectVal&0x3f)); - break; - case 0x13: // TL op2 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,1,effectVal&0x3f)); - break; - case 0x14: // TL op3 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,2,effectVal&0x3f)); - break; - case 0x15: // TL op4 - dispatchCmd(DivCommand(DIV_CMD_FM_TL,ch,3,effectVal&0x3f)); - break; - case 0x16: // MULT - if ((effectVal>>4)>0 && (effectVal>>4)<5) { - dispatchCmd(DivCommand(DIV_CMD_FM_MULT,ch,(effectVal>>4)-1,effectVal&15)); - } - break; - case 0x17: // DVB - dispatchCmd(DivCommand(DIV_CMD_FM_LFO,ch,2+(effectVal&1))); - break; - case 0x19: // AR global - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,-1,effectVal&15)); - break; - case 0x1a: // AR op1 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,0,effectVal&15)); - break; - case 0x1b: // AR op2 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,1,effectVal&15)); - break; - case 0x1c: // AR op3 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,2,effectVal&15)); - break; - case 0x1d: // AR op4 - dispatchCmd(DivCommand(DIV_CMD_FM_AR,ch,3,effectVal&15)); - break; - - // extra FM effects here - OP_EFFECT_SINGLE(0x50,DIV_CMD_FM_AM,4,1); - OP_EFFECT_SINGLE(0x51,DIV_CMD_FM_SL,4,15); - OP_EFFECT_SINGLE(0x52,DIV_CMD_FM_RR,4,15); - OP_EFFECT_SINGLE(0x53,DIV_CMD_FM_VIB,4,1); - OP_EFFECT_SINGLE(0x54,DIV_CMD_FM_RS,4,3); - OP_EFFECT_SINGLE(0x55,DIV_CMD_FM_SUS,4,1); + EffectHandlerMap fmOPN2EffectHandlerMap(fmEffectHandlerMap); + fmOPN2EffectHandlerMap.insert({ + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Toggle PCM mode"}}, + {0xdf, {DIV_CMD_SAMPLE_DIR, "DFxx: Set sample playback direction (0: normal; 1: reverse)"}}, + }); - OP_EFFECT_MULTI(0x56,DIV_CMD_FM_DR,-1,15); - OP_EFFECT_MULTI(0x57,DIV_CMD_FM_DR,0,15); - OP_EFFECT_MULTI(0x58,DIV_CMD_FM_DR,1,15); - OP_EFFECT_MULTI(0x59,DIV_CMD_FM_DR,2,15); - OP_EFFECT_MULTI(0x5a,DIV_CMD_FM_DR,3,15); + EffectHandlerMap fmOPLDrumsEffectHandlerMap(fmEffectHandlerMap); + fmOPLDrumsEffectHandlerMap.insert({ + {0x18, {DIV_CMD_FM_EXTCH, "18xx: Toggle drums mode (1: enabled; 0: disabled)"}}, + }); - OP_EFFECT_SINGLE(0x5b,DIV_CMD_FM_KSR,4,1); - OP_EFFECT_SINGLE(0x2a,DIV_CMD_FM_WS,4,7); - - default: - return false; - } - return true; + EffectHandlerMap fmOPNPostEffectHandlerMap={ + {0x11, {DIV_CMD_FM_FB, "11xx: Set feedback (0 to 7)"}}, + {0x12, {DIV_CMD_FM_TL, "12xx: Set level of operator 1 (0 highest, 7F lowest)", constVal<0>, effectVal}}, + {0x13, {DIV_CMD_FM_TL, "13xx: Set level of operator 2 (0 highest, 7F lowest)", constVal<1>, effectVal}}, + {0x14, {DIV_CMD_FM_TL, "14xx: Set level of operator 3 (0 highest, 7F lowest)", constVal<2>, effectVal}}, + {0x15, {DIV_CMD_FM_TL, "15xx: Set level of operator 4 (0 highest, 7F lowest)", constVal<3>, effectVal}}, + {0x16, {DIV_CMD_FM_MULT, "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)", effectOpValNoZero<4>, effectValAnd<15>}}, + {0x19, {DIV_CMD_FM_AR, "19xx: Set attack of all operators (0 to 1F)", constVal<-1>, effectValAnd<31>}}, + {0x1a, {DIV_CMD_FM_AR, "1Axx: Set attack of operator 1 (0 to 1F)", constVal<0>, effectValAnd<31>}}, + {0x1b, {DIV_CMD_FM_AR, "1Bxx: Set attack of operator 2 (0 to 1F)", constVal<1>, effectValAnd<31>}}, + {0x1c, {DIV_CMD_FM_AR, "1Cxx: Set attack of operator 3 (0 to 1F)", constVal<2>, effectValAnd<31>}}, + {0x1d, {DIV_CMD_FM_AR, "1Dxx: Set attack of operator 4 (0 to 1F)", constVal<3>, effectValAnd<31>}}, + {0x50, {DIV_CMD_FM_AM, "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)", effectOpVal<4>, effectValAnd<1>}}, + {0x51, {DIV_CMD_FM_SL, "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)", effectOpVal<4>, effectValAnd<15>}}, + {0x52, {DIV_CMD_FM_RR, "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)", effectOpVal<4>, effectValAnd<15>}}, + {0x53, {DIV_CMD_FM_DT, "53xy: Set detune (x: operator from 1 to 4 (0 for all ops); y: detune where 3 is center)", effectOpVal<4>, effectValAnd<7>}}, + {0x54, {DIV_CMD_FM_RS, "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)", effectOpVal<4>, effectValAnd<3>}}, + {0x56, {DIV_CMD_FM_DR, "56xx: Set decay of all operators (0 to 1F)", constVal<-1>, effectValAnd<31>}}, + {0x57, {DIV_CMD_FM_DR, "57xx: Set decay of operator 1 (0 to 1F)", constVal<0>, effectValAnd<31>}}, + {0x58, {DIV_CMD_FM_DR, "58xx: Set decay of operator 2 (0 to 1F)", constVal<1>, effectValAnd<31>}}, + {0x59, {DIV_CMD_FM_DR, "59xx: Set decay of operator 3 (0 to 1F)", constVal<2>, effectValAnd<31>}}, + {0x5a, {DIV_CMD_FM_DR, "5Axx: Set decay of operator 4 (0 to 1F)", constVal<3>, effectValAnd<31>}}, + {0x5b, {DIV_CMD_FM_D2R, "5Bxx: Set decay 2 of all operators (0 to 1F)", constVal<-1>, effectValAnd<31>}}, + {0x5c, {DIV_CMD_FM_D2R, "5Cxx: Set decay 2 of operator 1 (0 to 1F)", constVal<0>, effectValAnd<31>}}, + {0x5d, {DIV_CMD_FM_D2R, "5Dxx: Set decay 2 of operator 2 (0 to 1F)", constVal<1>, effectValAnd<31>}}, + {0x5e, {DIV_CMD_FM_D2R, "5Exx: Set decay 2 of operator 3 (0 to 1F)", constVal<2>, effectValAnd<31>}}, + {0x5f, {DIV_CMD_FM_D2R, "5Fxx: Set decay 2 of operator 4 (0 to 1F)", constVal<3>, effectValAnd<31>}}, }; - auto c64PostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // cutoff - dispatchCmd(DivCommand(DIV_CMD_C64_CUTOFF,ch,effectVal)); - break; - case 0x12: // duty - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x13: // resonance - dispatchCmd(DivCommand(DIV_CMD_C64_RESONANCE,ch,effectVal)); - break; - case 0x14: // filter mode - dispatchCmd(DivCommand(DIV_CMD_C64_FILTER_MODE,ch,effectVal)); - break; - case 0x15: // reset time - dispatchCmd(DivCommand(DIV_CMD_C64_RESET_TIME,ch,effectVal)); - break; - case 0x1a: // reset mask - dispatchCmd(DivCommand(DIV_CMD_C64_RESET_MASK,ch,effectVal)); - break; - case 0x1b: // cutoff reset - dispatchCmd(DivCommand(DIV_CMD_C64_FILTER_RESET,ch,effectVal)); - break; - case 0x1c: // duty reset - dispatchCmd(DivCommand(DIV_CMD_C64_DUTY_RESET,ch,effectVal)); - break; - case 0x1e: // extended - dispatchCmd(DivCommand(DIV_CMD_C64_EXTENDED,ch,effectVal)); - break; - case 0x30: case 0x31: case 0x32: case 0x33: - case 0x34: case 0x35: case 0x36: case 0x37: - case 0x38: case 0x39: case 0x3a: case 0x3b: - case 0x3c: case 0x3d: case 0x3e: case 0x3f: // fine duty - dispatchCmd(DivCommand(DIV_CMD_C64_FINE_DUTY,ch,((effect&0x0f)<<8)|effectVal)); - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: // fine cutoff - dispatchCmd(DivCommand(DIV_CMD_C64_FINE_CUTOFF,ch,((effect&0x07)<<8)|effectVal)); - break; - default: - return false; - } - return true; + EffectHandlerMap fmOPMPostEffectHandlerMap(fmOPNPostEffectHandlerMap); + fmOPMPostEffectHandlerMap.insert({ + {0x10, {DIV_CMD_STD_NOISE_FREQ, "10xx: Set noise frequency (xx: value; 0 disables noise)"}}, + {0x17, {DIV_CMD_FM_LFO, "17xx: Set LFO speed"}}, + {0x18, {DIV_CMD_FM_LFO_WAVE, "18xx: Set LFO waveform (0 saw, 1 square, 2 triangle, 3 noise)"}}, + {0x1e, {DIV_CMD_FM_AM_DEPTH, "1Exx: Set AM depth (0 to 7F)", effectValAnd<127>}}, + {0x1f, {DIV_CMD_FM_PM_DEPTH, "1Fxx: Set PM depth (0 to 7F)", effectValAnd<127>}}, + {0x55, {DIV_CMD_FM_SSG, "55xy: Set detune 2 (x: operator from 1 to 4 (0 for all ops); y: detune from 0 to 3)", effectOpVal<4>, effectValAnd<3>}}, + }); + + EffectHandlerMap fmOPZPostEffectHandlerMap(fmOPMPostEffectHandlerMap); + fmOPZPostEffectHandlerMap.insert({ + {0x28, {DIV_CMD_FM_REV, "28xy: Set reverb (x: operator from 1 to 4 (0 for all ops); y: reverb from 0 to 7)", effectOpVal<4>, effectValAnd<7>}}, + {0x2a, {DIV_CMD_FM_WS, "2Axy: Set waveform (x: operator from 1 to 4 (0 for all ops); y: waveform from 0 to 7)", effectOpVal<4>, effectValAnd<7>}}, + {0x2b, {DIV_CMD_FM_EG_SHIFT, "2Bxy: Set envelope generator shift (x: operator from 1 to 4 (0 for all ops); y: shift from 0 to 3)", effectOpVal<4>, effectValAnd<3>}}, + {0x2c, {DIV_CMD_FM_FINE, "2Cxy: Set fine multiplier (x: operator from 1 to 4 (0 for all ops); y: fine)", effectOpVal<4>, effectValAnd<15>}}, + }); + const EffectHandler fmOPZFixFreqHandler[4]={ + {DIV_CMD_FM_FIXFREQ, "3xyy: Set fixed frequency of operator 1 (x: octave from 0 to 7; y: frequency)", constVal<0>, effectValLong<11>}, + {DIV_CMD_FM_FIXFREQ, "3xyy: Set fixed frequency of operator 2 (x: octave from 8 to F; y: frequency)", constVal<1>, effectValLong<11>}, + {DIV_CMD_FM_FIXFREQ, "4xyy: Set fixed frequency of operator 3 (x: octave from 0 to 7; y: frequency)", constVal<2>, effectValLong<11>}, + {DIV_CMD_FM_FIXFREQ, "4xyy: Set fixed frequency of operator 4 (x: octave from 8 to F; y: frequency)", constVal<3>, effectValLong<11>}, + }; + for (int i=0; i<32; i++) { + fmOPZPostEffectHandlerMap.emplace(0x30+i,fmOPZFixFreqHandler[i/8]); + } + + fmOPNPostEffectHandlerMap.insert({ + {0x10, {DIV_CMD_FM_LFO, "10xy: Setup LFO (x: enable; y: speed)"}}, + {0x18, {DIV_CMD_FM_EXTCH, "18xx: Toggle extended channel 3 mode"}}, + {0x55, {DIV_CMD_FM_SSG, "55xy: Set SSG envelope (x: operator from 1 to 4 (0 for all ops); y: 0-7 on, 8 off)", effectOpVal<4>, effectValAnd<15>}}, + }); + EffectHandlerMap fmOPN2PostEffectHandlerMap(fmOPNPostEffectHandlerMap); + + fmOPNPostEffectHandlerMap.insert(ayPostEffectHandlerMap.begin(), ayPostEffectHandlerMap.end()); + + EffectHandlerMap fmOPLLPostEffectHandlerMap={ + {0x11, {DIV_CMD_FM_FB, "11xx: Set feedback (0 to 7)"}}, + {0x12, {DIV_CMD_FM_TL, "12xx: Set level of operator 1 (0 highest, 3F lowest)", constVal<0>, effectVal}}, + {0x13, {DIV_CMD_FM_TL, "13xx: Set level of operator 2 (0 highest, 3F lowest)", constVal<1>, effectVal}}, + {0x16, {DIV_CMD_FM_MULT, "16xy: Set operator multiplier (x: operator from 1 to 2; y: multiplier)", effectOpValNoZero<2>, effectValAnd<15>}}, + {0x19, {DIV_CMD_FM_AR, "19xx: Set attack of all operators (0 to F)", constVal<-1>, effectValAnd<15>}}, + {0x1a, {DIV_CMD_FM_AR, "1Axx: Set attack of operator 1 (0 to F)", constVal<0>, effectValAnd<15>}}, + {0x1b, {DIV_CMD_FM_AR, "1Bxx: Set attack of operator 2 (0 to F)", constVal<1>, effectValAnd<15>}}, + {0x50, {DIV_CMD_FM_AM, "50xy: Set AM (x: operator from 1 to 2 (0 for all ops); y: AM)", effectOpVal<2>, effectValAnd<1>}}, + {0x51, {DIV_CMD_FM_SL, "51xy: Set sustain level (x: operator from 1 to 2 (0 for all ops); y: sustain)", effectOpVal<2>, effectValAnd<15>}}, + {0x52, {DIV_CMD_FM_RR, "52xy: Set release (x: operator from 1 to 2 (0 for all ops); y: release)", effectOpVal<2>, effectValAnd<15>}}, + {0x53, {DIV_CMD_FM_VIB, "53xy: Set vibrato (x: operator from 1 to 2 (0 for all ops); y: enabled)", effectOpVal<2>, effectValAnd<1>}}, + {0x54, {DIV_CMD_FM_RS, "54xy: Set envelope scale (x: operator from 1 to 2 (0 for all ops); y: scale from 0 to 3)", effectOpVal<2>, effectValAnd<3>}}, + {0x55, {DIV_CMD_FM_SUS, "55xy: Set envelope sustain (x: operator from 1 to 2 (0 for all ops); y: enabled)", effectOpVal<2>, effectValAnd<1>}}, + {0x56, {DIV_CMD_FM_DR, "56xx: Set decay of all operators (0 to F)", constVal<-1>, effectValAnd<15>}}, + {0x57, {DIV_CMD_FM_DR, "57xx: Set decay of operator 1 (0 to F)", constVal<0>, effectValAnd<15>}}, + {0x58, {DIV_CMD_FM_DR, "58xx: Set decay of operator 2 (0 to F)", constVal<1>, effectValAnd<15>}}, + {0x5b, {DIV_CMD_FM_KSR, "5Bxy: Set whether key will scale envelope (x: operator from 1 to 2 (0 for all ops); y: enabled)", effectOpVal<2>, effectValAnd<1>}}, }; - auto ayPostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x12: // duty on 8930 - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,0x10+(effectVal&15))); - break; - case 0x20: // mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal&15)); - break; - case 0x21: // noise freq - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_FREQ,ch,effectVal)); - break; - case 0x22: // envelope enable - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SET,ch,effectVal)); - break; - case 0x23: // envelope period low - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_LOW,ch,effectVal)); - break; - case 0x24: // envelope period high - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_HIGH,ch,effectVal)); - break; - case 0x25: // envelope slide up - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SLIDE,ch,-effectVal)); - break; - case 0x26: // envelope slide down - dispatchCmd(DivCommand(DIV_CMD_AY_ENVELOPE_SLIDE,ch,effectVal)); - break; - case 0x27: // noise and mask - dispatchCmd(DivCommand(DIV_CMD_AY_NOISE_MASK_AND,ch,effectVal)); - break; - case 0x28: // noise or mask - dispatchCmd(DivCommand(DIV_CMD_AY_NOISE_MASK_OR,ch,effectVal)); - break; - case 0x29: // auto-envelope - dispatchCmd(DivCommand(DIV_CMD_AY_AUTO_ENVELOPE,ch,effectVal)); - break; - case 0x2d: // TEST - dispatchCmd(DivCommand(DIV_CMD_AY_IO_WRITE,ch,255,effectVal)); - break; - case 0x2e: // I/O port A - dispatchCmd(DivCommand(DIV_CMD_AY_IO_WRITE,ch,0,effectVal)); - break; - case 0x2f: // I/O port B - dispatchCmd(DivCommand(DIV_CMD_AY_IO_WRITE,ch,1,effectVal)); - break; - default: - return false; - } - return true; + EffectHandlerMap fmOPLPostEffectHandlerMap={ + {0x10, {DIV_CMD_FM_LFO, "10xx: Set global AM depth (0: 1dB, 1: 4.8dB)", effectValAnd<1>}}, + {0x11, {DIV_CMD_FM_FB, "11xx: Set feedback (0 to 7)"}}, + {0x12, {DIV_CMD_FM_TL, "12xx: Set level of operator 1 (0 highest, 3F lowest)", constVal<0>, effectVal}}, + {0x13, {DIV_CMD_FM_TL, "13xx: Set level of operator 2 (0 highest, 3F lowest)", constVal<1>, effectVal}}, + {0x14, {DIV_CMD_FM_TL, "14xx: Set level of operator 3 (0 highest, 3F lowest)", constVal<2>, effectVal}}, + {0x15, {DIV_CMD_FM_TL, "15xx: Set level of operator 4 (0 highest, 3F lowest)", constVal<3>, effectVal}}, + {0x16, {DIV_CMD_FM_MULT, "16xy: Set operator multiplier (x: operator from 1 to 4; y: multiplier)", effectOpValNoZero<4>, effectValAnd<15>}}, + {0x17, {DIV_CMD_FM_LFO, "17xx: Set global vibrato depth (0: normal, 1: double)", [](unsigned char, unsigned char val) -> int { return (val&1)+2; }}}, + {0x19, {DIV_CMD_FM_AR, "19xx: Set attack of all operators (0 to F)", constVal<-1>, effectValAnd<15>}}, + {0x1a, {DIV_CMD_FM_AR, "1Axx: Set attack of operator 1 (0 to F)", constVal<0>, effectValAnd<15>}}, + {0x1b, {DIV_CMD_FM_AR, "1Bxx: Set attack of operator 2 (0 to F)", constVal<1>, effectValAnd<15>}}, + {0x1c, {DIV_CMD_FM_AR, "1Cxx: Set attack of operator 3 (0 to F)", constVal<2>, effectValAnd<15>}}, + {0x1d, {DIV_CMD_FM_AR, "1Dxx: Set attack of operator 4 (0 to F)", constVal<3>, effectValAnd<15>}}, + {0x2a, {DIV_CMD_FM_WS, "2Axy: Set waveform (x: operator from 1 to 4 (0 for all ops); y: waveform from 0 to 3 in OPL2 and 0 to 7 in OPL3)", effectOpVal<4>, effectValAnd<7>}}, + {0x50, {DIV_CMD_FM_AM, "50xy: Set AM (x: operator from 1 to 4 (0 for all ops); y: AM)", effectOpVal<4>, effectValAnd<1>}}, + {0x51, {DIV_CMD_FM_SL, "51xy: Set sustain level (x: operator from 1 to 4 (0 for all ops); y: sustain)", effectOpVal<4>, effectValAnd<15>}}, + {0x52, {DIV_CMD_FM_RR, "52xy: Set release (x: operator from 1 to 4 (0 for all ops); y: release)", effectOpVal<4>, effectValAnd<15>}}, + {0x53, {DIV_CMD_FM_VIB, "53xy: Set vibrato (x: operator from 1 to 4 (0 for all ops); y: enabled)", effectOpVal<4>, effectValAnd<1>}}, + {0x54, {DIV_CMD_FM_RS, "54xy: Set envelope scale (x: operator from 1 to 4 (0 for all ops); y: scale from 0 to 3)", effectOpVal<4>, effectValAnd<3>}}, + {0x55, {DIV_CMD_FM_SUS, "55xy: Set envelope sustain (x: operator from 1 to 4 (0 for all ops); y: enabled)", effectOpVal<4>, effectValAnd<1>}}, + {0x56, {DIV_CMD_FM_DR, "56xx: Set decay of all operators (0 to F)", constVal<-1>, effectValAnd<15>}}, + {0x57, {DIV_CMD_FM_DR, "57xx: Set decay of operator 1 (0 to F)", constVal<0>, effectValAnd<15>}}, + {0x58, {DIV_CMD_FM_DR, "58xx: Set decay of operator 2 (0 to F)", constVal<1>, effectValAnd<15>}}, + {0x59, {DIV_CMD_FM_DR, "59xx: Set decay of operator 3 (0 to F)", constVal<2>, effectValAnd<15>}}, + {0x5a, {DIV_CMD_FM_DR, "5Axx: Set decay of operator 4 (0 to F)", constVal<3>, effectValAnd<15>}}, + {0x5b, {DIV_CMD_FM_KSR, "5Bxy: Set whether key will scale envelope (x: operator from 1 to 4 (0 for all ops); y: enabled)", effectOpVal<4>, effectValAnd<1>}}, }; - auto segaPCMPostEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // PCM frequency - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_FREQ,ch,effectVal)); - break; - default: - return false; - } - return true; + EffectHandlerMap c64PostEffectHandlerMap={ + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform (bit 0: triangle; bit 1: saw; bit 2: pulse; bit 3: noise)"}}, + {0x11, {DIV_CMD_C64_CUTOFF, "11xx: Set coarse cutoff (not recommended; use 4xxx instead)"}}, + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set coarse pulse width (not recommended; use 3xxx instead)"}}, + {0x13, {DIV_CMD_C64_RESONANCE, "13xx: Set resonance (0 to F)"}}, + {0x14, {DIV_CMD_C64_FILTER_MODE, "14xx: Set filter mode (bit 0: low pass; bit 1: band pass; bit 2: high pass)"}}, + {0x15, {DIV_CMD_C64_RESET_TIME, "15xx: Set envelope reset time"}}, + {0x1a, {DIV_CMD_C64_RESET_MASK, "1Axx: Disable envelope reset for this channel (1 disables; 0 enables)"}}, + {0x1b, {DIV_CMD_C64_FILTER_RESET, "1Bxy: Reset cutoff (x: on new note; y: now)"}}, + {0x1c, {DIV_CMD_C64_DUTY_RESET, "1Cxy: Reset pulse width (x: on new note; y: now)"}}, + {0x1e, {DIV_CMD_C64_EXTENDED, "1Exy: Change additional parameters"}}, }; + const EffectHandler c64FineDutyHandler(DIV_CMD_C64_FINE_DUTY, "3xxx: Set pulse width (0 to FFF)", effectValLong<12>); + const EffectHandler c64FineCutoffHandler(DIV_CMD_C64_FINE_CUTOFF, "4xxx: Set cutoff (0 to 7FF)", effectValLong<11>); + for (int i=0; i<16; i++) c64PostEffectHandlerMap.emplace(0x30+i,c64FineDutyHandler); + for (int i=0; i<8; i++) c64PostEffectHandlerMap.emplace(0x40+i,c64FineCutoffHandler); + + EffectHandlerMap waveOnlyEffectHandlerMap={ + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + }; + + EffectHandlerMap segaPCMPostEffectHandlerMap={ + {0x20, {DIV_CMD_SAMPLE_FREQ, "20xx: Set PCM frequency"}} + }; + + // SysDefs sysDefs[DIV_SYSTEM_YMU759]=new DivSysDef( "Yamaha YMU759 (MA-2)", NULL, 0x01, 0x01, 17, true, false, 0, false, @@ -774,15 +610,8 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_NOISE}, {DIV_INS_STD, DIV_INS_STD, DIV_INS_STD, DIV_INS_STD}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // SN noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_STD_NOISE_MODE, "20xy: Set noise mode (x: preset freq/ch3 freq; y: thin pulse/noise)"}} } ); @@ -800,24 +629,12 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_WAVE, DIV_CH_NOISE}, {DIV_INS_GB, DIV_INS_GB, DIV_INS_GB, DIV_INS_GB}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: case 0x12: // duty or noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x13: // sweep params - dispatchCmd(DivCommand(DIV_CMD_GB_SWEEP_TIME,ch,effectVal)); - break; - case 0x14: // sweep direction - dispatchCmd(DivCommand(DIV_CMD_GB_SWEEP_DIR,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_STD_NOISE_MODE, "11xx: Set noise length (0: long; 1: short)"}}, + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set duty cycle (0 to 3)"}}, + {0x13, {DIV_CMD_GB_SWEEP_TIME, "13xy: Setup sweep (x: time; y: shift)"}}, + {0x14, {DIV_CMD_GB_SWEEP_DIR, "14xx: Set sweep direction (0: up; 1: down)"}} } ); @@ -829,27 +646,12 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_PCE, DIV_INS_PCE, DIV_INS_PCE, DIV_INS_PCE, DIV_INS_PCE, DIV_INS_PCE}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x12: // LFO mode - dispatchCmd(DivCommand(DIV_CMD_PCE_LFO_MODE,ch,effectVal)); - break; - case 0x13: // LFO speed - dispatchCmd(DivCommand(DIV_CMD_PCE_LFO_SPEED,ch,effectVal)); - break; - case 0x17: // PCM enable - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,(effectVal>0))); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_STD_NOISE_MODE, "11xx: Toggle noise mode"}}, + {0x12, {DIV_CMD_PCE_LFO_MODE, "12xx: Setup LFO (0: disabled; 1: 1x depth; 2: 16x depth; 3: 256x depth)"}}, + {0x13, {DIV_CMD_PCE_LFO_SPEED, "13xx: Set LFO speed"}}, + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Toggle PCM mode"}} } ); @@ -861,27 +663,12 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_WAVE, DIV_CH_NOISE, DIV_CH_PCM}, {DIV_INS_STD, DIV_INS_STD, DIV_INS_STD, DIV_INS_STD, DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x11: // DMC write - dispatchCmd(DivCommand(DIV_CMD_NES_DMC,ch,effectVal)); - break; - case 0x12: // duty or noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x13: // sweep up - dispatchCmd(DivCommand(DIV_CMD_NES_SWEEP,ch,0,effectVal)); - break; - case 0x14: // sweep down - dispatchCmd(DivCommand(DIV_CMD_NES_SWEEP,ch,1,effectVal)); - break; - case 0x18: // DPCM mode - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x11, {DIV_CMD_NES_DMC, "11xx: Write to delta modulation counter (0 to 7F)"}}, + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set duty cycle/noise mode (pulse: 0 to 3; noise: 0 or 1)"}}, + {0x13, {DIV_CMD_NES_SWEEP, "13xy: Sweep up (x: time; y: shift)",constVal<0>,effectVal}}, + {0x14, {DIV_CMD_NES_SWEEP, "14xy: Sweep down (x: time; y: shift)",constVal<1>,effectVal}}, + {0x18, {DIV_CMD_SAMPLE_MODE, "18xx: Select PCM/DPCM mode (0: PCM; 1: DPCM)"}} } ); @@ -905,8 +692,8 @@ void DivEngine::registerSystems() { {DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_C64, DIV_INS_C64, DIV_INS_C64}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - c64PostEffectHandler + {}, + c64PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_C64_8580]=new DivSysDef( @@ -917,8 +704,8 @@ void DivEngine::registerSystems() { {DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_C64, DIV_INS_C64, DIV_INS_C64}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - c64PostEffectHandler + {}, + c64PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_ARCADE]=new DivSysDef( @@ -927,17 +714,6 @@ void DivEngine::registerSystems() { {}, {}, {}, {} ); - auto fmHardResetEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x30: // toggle hard-reset - dispatchCmd(DivCommand(DIV_CMD_FM_HARD_RESET,ch,effectVal)); - break; - default: - return false; - } - return true; - }; - sysDefs[DIV_SYSTEM_YM2610]=new DivSysDef( "Neo Geo CD", NULL, 0x09, 0x09, 13, true, true, 0x151, false, "like Neo Geo, but lacking the ADPCM-B channel since they couldn't connect the pins.", @@ -946,8 +722,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_YM2610_EXT]=new DivSysDef( @@ -958,8 +734,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_AY8910]=new DivSysDef( @@ -970,8 +746,8 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE}, {DIV_INS_AY, DIV_INS_AY, DIV_INS_AY}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - ayPostEffectHandler + {}, + ayPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_AMIGA]=new DivSysDef( @@ -982,22 +758,11 @@ void DivEngine::registerSystems() { {DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // toggle filter - dispatchCmd(DivCommand(DIV_CMD_AMIGA_FILTER,ch,effectVal)); - break; - case 0x11: // toggle AM - dispatchCmd(DivCommand(DIV_CMD_AMIGA_AM,ch,effectVal)); - break; - case 0x12: // toggle PM - dispatchCmd(DivCommand(DIV_CMD_AMIGA_PM,ch,effectVal)); - break; - default: - return false; - } - return true; + {}, + { + {0x10, {DIV_CMD_AMIGA_FILTER, "10xx: Toggle filter (0 disables; 1 enables)"}}, + {0x11, {DIV_CMD_AMIGA_AM, "11xx: Toggle AM with next channel"}}, + {0x12, {DIV_CMD_AMIGA_PM, "12xx: Toggle period modulation with next channel"}}, } ); @@ -1009,24 +774,10 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPMPostEffectHandlerMap ); - auto opn2EffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x17: // DAC enable - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,(effectVal>0))); - break; - case 0x30: // toggle hard-reset - dispatchCmd(DivCommand(DIV_CMD_FM_HARD_RESET,ch,effectVal)); - break; - default: - return false; - } - return true; - }; - sysDefs[DIV_SYSTEM_YM2612]=new DivSysDef( "Yamaha YM2612 (OPN2)", NULL, 0x83, 0, 6, true, false, 0x150, false, "this chip is mostly known for being in the Sega Genesis (but it also was on the FM Towns computer).", @@ -1035,8 +786,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA}, - opn2EffectHandler, - fmPostEffectHandler + fmOPN2EffectHandlerMap, + fmOPN2PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_TIA]=new DivSysDef( @@ -1047,17 +798,8 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_TIA, DIV_INS_TIA}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - default: - return false; - } - return true; - } + {}, + waveOnlyEffectHandlerMap ); sysDefs[DIV_SYSTEM_SAA1099]=new DivSysDef( @@ -1068,22 +810,11 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE}, {DIV_INS_SAA1099, DIV_INS_SAA1099, DIV_INS_SAA1099, DIV_INS_SAA1099, DIV_INS_SAA1099, DIV_INS_SAA1099}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select channel mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x11: // set noise freq - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_FREQ,ch,effectVal)); - break; - case 0x12: // setup envelope - dispatchCmd(DivCommand(DIV_CMD_SAA_ENVELOPE,ch,effectVal)); - break; - default: - return false; - } - return true; + {}, + { + {0x10, {DIV_CMD_STD_NOISE_MODE, "10xy: Set channel mode (x: noise; y: tone)"}}, + {0x11, {DIV_CMD_STD_NOISE_FREQ, "11xx: Set noise frequency"}}, + {0x12, {DIV_CMD_SAA_ENVELOPE, "12xx: Setup envelope (refer to docs for more information)"}}, } ); @@ -1095,21 +826,10 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE}, {DIV_INS_AY8930, DIV_INS_AY8930, DIV_INS_AY8930}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - ayPostEffectHandler + {}, + ay8930PostEffectHandlerMap ); - auto waveOnlyEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - default: - return false; - } - return true; - }; - sysDefs[DIV_SYSTEM_VIC20]=new DivSysDef( "Commodore VIC-20", NULL, 0x85, 0, 4, false, true, 0, false, "Commodore's successor to the PET.\nits square wave channels are more than just square...", @@ -1118,7 +838,7 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_NOISE}, {DIV_INS_VIC, DIV_INS_VIC, DIV_INS_VIC, DIV_INS_VIC}, {}, - waveOnlyEffectHandler + waveOnlyEffectHandlerMap ); sysDefs[DIV_SYSTEM_PET]=new DivSysDef( @@ -1129,7 +849,7 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE}, {DIV_INS_PET}, {}, - waveOnlyEffectHandler + waveOnlyEffectHandlerMap ); sysDefs[DIV_SYSTEM_SNES]=new DivSysDef( @@ -1149,32 +869,12 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_WAVE}, {DIV_INS_VRC6, DIV_INS_VRC6, DIV_INS_VRC6_SAW}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_NULL}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x12: // duty or noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x17: // PCM enable - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,(effectVal>0))); - break; - default: - return false; - } - return true; + { + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set duty cycle (pulse: 0 to 7)"}}, + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Toggle PCM mode (pulse channel)"}}, } ); - auto oplEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x30: // toggle hard-reset - dispatchCmd(DivCommand(DIV_CMD_FM_HARD_RESET,ch,effectVal)); - break; - default: - return false; - } - return true; - }; - sysDefs[DIV_SYSTEM_OPLL]=new DivSysDef( "Yamaha YM2413 (OPLL)", NULL, 0x89, 0, 9, true, false, 0x150, false, "cost-reduced version of the OPL with 16 patches and only one of them is user-configurable.", @@ -1183,8 +883,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL}, {}, - oplEffectHandler, - fmOPLLPostEffectHandler + fmEffectHandlerMap, + fmOPLLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_FDS]=new DivSysDef( @@ -1195,30 +895,13 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE}, {DIV_INS_FDS}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // modulation depth - dispatchCmd(DivCommand(DIV_CMD_FDS_MOD_DEPTH,ch,effectVal)); - break; - case 0x12: // modulation enable/high - dispatchCmd(DivCommand(DIV_CMD_FDS_MOD_HIGH,ch,effectVal)); - break; - case 0x13: // modulation low - dispatchCmd(DivCommand(DIV_CMD_FDS_MOD_LOW,ch,effectVal)); - break; - case 0x14: // modulation pos - dispatchCmd(DivCommand(DIV_CMD_FDS_MOD_POS,ch,effectVal)); - break; - case 0x15: // modulation wave - dispatchCmd(DivCommand(DIV_CMD_FDS_MOD_WAVE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_FDS_MOD_DEPTH, "11xx: Set modulation depth"}}, + {0x12, {DIV_CMD_FDS_MOD_HIGH, "12xy: Set modulation speed high byte (x: enable; y: value)"}}, + {0x13, {DIV_CMD_FDS_MOD_LOW, "13xx: Set modulation speed low byte"}}, + {0x14, {DIV_CMD_FDS_MOD_POS, "14xx: Set modulator position"}}, + {0x15, {DIV_CMD_FDS_MOD_WAVE, "15xx: Set modulator table to waveform"}}, } ); @@ -1230,18 +913,8 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM}, {DIV_INS_STD, DIV_INS_STD, DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x11: // DMC write - dispatchCmd(DivCommand(DIV_CMD_NES_DMC,ch,effectVal)); - break; - case 0x12: // duty or noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set duty cycle/noise mode (pulse: 0 to 3; noise: 0 or 1)"}}, } ); @@ -1253,51 +926,20 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_N163, DIV_INS_N163, DIV_INS_N163, DIV_INS_N163, DIV_INS_N163, DIV_INS_N163, DIV_INS_N163, DIV_INS_N163}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select instrument waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // select instrument waveform position in RAM - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_POSITION,ch,effectVal)); - break; - case 0x12: // select instrument waveform length in RAM - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_LENGTH,ch,effectVal)); - break; - case 0x13: // change instrument waveform update mode - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_MODE,ch,effectVal)); - break; - case 0x14: // select waveform for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_LOAD,ch,effectVal)); - break; - case 0x15: // select waveform position for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_LOADPOS,ch,effectVal)); - break; - case 0x16: // select waveform length for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_LOADLEN,ch,effectVal)); - break; - case 0x17: // change waveform load mode - dispatchCmd(DivCommand(DIV_CMD_N163_WAVE_LOADMODE,ch,effectVal)); - break; - case 0x18: // change channel limits - dispatchCmd(DivCommand(DIV_CMD_N163_CHANNEL_LIMIT,ch,effectVal)); - break; - case 0x20: // (global) select waveform for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_GLOBAL_WAVE_LOAD,ch,effectVal)); - break; - case 0x21: // (global) select waveform position for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_GLOBAL_WAVE_LOADPOS,ch,effectVal)); - break; - case 0x22: // (global) select waveform length for load to RAM - dispatchCmd(DivCommand(DIV_CMD_N163_GLOBAL_WAVE_LOADLEN,ch,effectVal)); - break; - case 0x23: // (global) change waveform load mode - dispatchCmd(DivCommand(DIV_CMD_N163_GLOBAL_WAVE_LOADMODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Select waveform"}}, + {0x11, {DIV_CMD_N163_WAVE_POSITION, "11xx: Set waveform position in RAM (single nibble unit)"}}, + {0x12, {DIV_CMD_N163_WAVE_LENGTH, "12xx: Set waveform length in RAM (04 to FC, 4 nibble unit)"}}, + {0x13, {DIV_CMD_N163_WAVE_MODE, "130x: Change waveform update mode (0: off; bit 0: update now; bit 1: update when every waveform changes)"}}, + {0x14, {DIV_CMD_N163_WAVE_LOAD, "14xx: Select waveform for load to RAM"}}, + {0x15, {DIV_CMD_N163_WAVE_LOADPOS, "15xx: Set waveform position for load to RAM (single nibble unit)"}}, + {0x16, {DIV_CMD_N163_WAVE_LOADLEN, "16xx: Set waveform length for load to RAM (04 to FC, 4 nibble unit)"}}, + {0x17, {DIV_CMD_N163_WAVE_LOADMODE, "170x: Change waveform load mode (0: off; bit 0: load now; bit 1: load when every waveform changes)"}}, + {0x18, {DIV_CMD_N163_CHANNEL_LIMIT, "180x: Change channel limits (0 to 7, x + 1)"}}, + {0x20, {DIV_CMD_N163_GLOBAL_WAVE_LOAD, "20xx: (Global) Select waveform for load to RAM"}}, + {0x21, {DIV_CMD_N163_GLOBAL_WAVE_LOADPOS, "21xx: (Global) Set waveform position for load to RAM (single nibble unit)"}}, + {0x22, {DIV_CMD_N163_GLOBAL_WAVE_LOADLEN, "22xx: (Global) Set waveform length for load to RAM (04 to FC, 4 nibble unit)"}}, + {0x23, {DIV_CMD_N163_GLOBAL_WAVE_LOADMODE, "230x: (Global) Change waveform load mode (0: off; bit 0: load now; bit 1: load when every waveform changes)"}}, } ); @@ -1309,20 +951,20 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPN_EXT]=new DivSysDef( "Yamaha YM2203 (OPN) Extended Channel 3", NULL, 0xb6, 0, 9, true, true, 0x151, false, - "cost-reduced version of the OPM with a different register layout and no stereo...\n...but it has a built-in AY-3-8910! (actually an YM2149)\nthis one is in Extended Channel mode, which turns the second FM channel into four operators with independent notes/frequencies", + "cost-reduced version of the OPM with a different register layout and no stereo...\n...but it has a built-in AY-3-8910! (actually an YM2149)\nthis one is in Extended Channel mode, which turns the third FM channel into four operators with independent notes/frequencies", {"FM 1", "FM 2", "FM 3 OP1", "FM 3 OP2", "FM 3 OP3", "FM 3 OP4", "PSG 1", "PSG 2", "PSG 3"}, {"F1", "F2", "O1", "O2", "O3", "O4", "S1", "S2", "S3"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_PC98]=new DivSysDef( @@ -1333,20 +975,20 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_PC98_EXT]=new DivSysDef( "Yamaha YM2608 (OPNA) Extended Channel 3", NULL, 0xb7, 0, 19, true, true, 0x151, false, - "OPN but twice the FM channels, stereo makes a come-back and has rhythm and ADPCM channels.\nthis one is in Extended Channel mode, which turns the second FM channel into four operators with independent notes/frequencies", + "OPN but twice the FM channels, stereo makes a come-back and has rhythm and ADPCM channels.\nthis one is in Extended Channel mode, which turns the third FM channel into four operators with independent notes/frequencies", {"FM 1", "FM 2", "FM 3 OP1", "FM 3 OP2", "FM 3 OP3", "FM 3 OP4", "FM 4", "FM 5", "FM 6", "Square 1", "Square 2", "Square 3", "Kick", "Snare", "Top", "HiHat", "Tom", "Rim", "ADPCM"}, {"F1", "F2", "O1", "O2", "O3", "O4", "F4", "F5", "F6", "S1", "S2", "S3", "BD", "SD", "TP", "HH", "TM", "RM", "P"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPL]=new DivSysDef( @@ -1357,8 +999,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, {}, - oplEffectHandler, - fmOPLPostEffectHandler + fmEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPL2]=new DivSysDef( @@ -1369,8 +1011,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, {}, - oplEffectHandler, - fmOPLPostEffectHandler + fmEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPL3]=new DivSysDef( @@ -1381,8 +1023,8 @@ void DivEngine::registerSystems() { {DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, {}, - oplEffectHandler, - fmOPLPostEffectHandler + fmEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_MULTIPCM]=new DivSysDef( @@ -1429,27 +1071,12 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_PCM, DIV_CH_WAVE, DIV_CH_NOISE}, {DIV_INS_SWAN, DIV_INS_SWAN, DIV_INS_SWAN, DIV_INS_SWAN}, {DIV_INS_NULL, DIV_INS_AMIGA, DIV_INS_NULL, DIV_INS_NULL}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x12: // sweep period - dispatchCmd(DivCommand(DIV_CMD_WS_SWEEP_TIME,ch,effectVal)); - break; - case 0x13: // sweep amount - dispatchCmd(DivCommand(DIV_CMD_WS_SWEEP_AMOUNT,ch,effectVal)); - break; - case 0x17: // PCM enable - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,(effectVal>0))); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_STD_NOISE_MODE, "11xx: Setup noise mode (0: disabled; 1-8: enabled/tap)"}}, + {0x12, {DIV_CMD_WS_SWEEP_TIME, "12xx: Setup sweep period (0: disabled; 1-20: enabled/period)"}}, + {0x13, {DIV_CMD_WS_SWEEP_AMOUNT, "13xx: Set sweep amount"}}, + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Toggle PCM mode"}}, } ); @@ -1461,17 +1088,10 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ, DIV_INS_OPZ}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x2f: // toggle hard-reset - dispatchCmd(DivCommand(DIV_CMD_FM_HARD_RESET,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x2f, {DIV_CMD_FM_HARD_RESET, "2Fxx: Toggle hard envelope reset on new notes"}}, }, - fmPostEffectHandler + fmOPZPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_POKEMINI]=new DivSysDef( @@ -1491,8 +1111,8 @@ void DivEngine::registerSystems() { {DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - segaPCMPostEffectHandler + {}, + segaPCMPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_VBOY]=new DivSysDef( @@ -1512,20 +1132,20 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL}, {}, - oplEffectHandler, - fmOPLLPostEffectHandler + fmEffectHandlerMap, + fmOPLLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_YM2610B]=new DivSysDef( - "Yamaha YM2610B (OPNB-B)", NULL, 0x9e, 0, 16, true, false, 0x151, false, + "Yamaha YM2610B (OPNB2)", NULL, 0x9e, 0, 16, true, false, 0x151, false, "so Taito asked Yamaha if they could get the two missing FM channels back, and Yamaha gladly provided them with this chip.", {"FM 1", "FM 2", "FM 3", "FM 4", "FM 5", "FM 6", "PSG 1", "PSG 2", "PSG 3", "ADPCM-A 1", "ADPCM-A 2", "ADPCM-A 3", "ADPCM-A 4", "ADPCM-A 5", "ADPCM-A 6", "ADPCM-B"}, {"F1", "F2", "F3", "F4", "F5", "F6", "S1", "S2", "S3", "P1", "P2", "P3", "P4", "P5", "P6", "B"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_SFX_BEEPER]=new DivSysDef( @@ -1536,31 +1156,22 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_BEEPER, DIV_INS_BEEPER, DIV_INS_BEEPER, DIV_INS_BEEPER, DIV_INS_BEEPER, DIV_INS_BEEPER}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x12: // pulse width - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x17: // overlay sample - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set pulse width"}}, + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Trigger overlay drum"}}, } ); sysDefs[DIV_SYSTEM_YM2612_EXT]=new DivSysDef( "Yamaha YM2612 (OPN2) Extended Channel 3", NULL, 0xa0, 0, 9, true, false, 0x150, false, - "this chip is mostly known for being in the Sega Genesis (but it also was on the FM Towns computer).\nthis one is in Extended Channel mode, which turns the second FM channel into four operators with independent notes/frequencies.", + "this chip is mostly known for being in the Sega Genesis (but it also was on the FM Towns computer).\nthis one is in Extended Channel mode, which turns the third FM channel into four operators with independent notes/frequencies.", {"FM 1", "FM 2", "FM 3 OP1", "FM 3 OP2", "FM 3 OP3", "FM 3 OP4", "FM 4", "FM 5", "FM 6"}, {"F1", "F2", "O1", "O2", "O3", "O4", "F4", "F5", "F6"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA}, - opn2EffectHandler, - fmPostEffectHandler + fmOPN2EffectHandlerMap, + fmOPN2PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_SCC]=new DivSysDef( @@ -1571,23 +1182,9 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC}, {}, - waveOnlyEffectHandler + waveOnlyEffectHandlerMap ); - auto oplDrumsEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x18: // drum mode toggle - dispatchCmd(DivCommand(DIV_CMD_FM_EXTCH,ch,effectVal)); - break; - case 0x30: // toggle hard-reset - dispatchCmd(DivCommand(DIV_CMD_FM_HARD_RESET,ch,effectVal)); - break; - default: - return false; - } - return true; - }; - sysDefs[DIV_SYSTEM_OPL_DRUMS]=new DivSysDef( "Yamaha YM3526 (OPL) with drums", NULL, 0xa2, 0, 11, true, false, 0x151, false, "the OPL chip but with drums mode enabled.", @@ -1596,8 +1193,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, - oplDrumsEffectHandler, - fmOPLPostEffectHandler + fmOPLDrumsEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPL2_DRUMS]=new DivSysDef( @@ -1608,8 +1205,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, - oplDrumsEffectHandler, - fmOPLPostEffectHandler + fmOPLDrumsEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPL3_DRUMS]=new DivSysDef( @@ -1620,8 +1217,8 @@ void DivEngine::registerSystems() { {DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL}, - oplDrumsEffectHandler, - fmOPLPostEffectHandler + fmOPLDrumsEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_YM2610_FULL]=new DivSysDef( @@ -1632,8 +1229,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_YM2610_FULL_EXT]=new DivSysDef( @@ -1644,8 +1241,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_OPLL_DRUMS]=new DivSysDef( @@ -1656,10 +1253,16 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL, DIV_INS_OPLL}, {}, - oplDrumsEffectHandler, - fmOPLLPostEffectHandler + fmOPLDrumsEffectHandlerMap, + fmOPLLPostEffectHandlerMap ); + EffectHandlerMap lynxEffectHandlerMap; + const EffectHandler lynxLFSRHandler(DIV_CMD_LYNX_LFSR_LOAD, "3xxx: Load LFSR (0 to FFF)", effectValLong<12>); + for (int i=0; i<16; i++) { + lynxEffectHandlerMap.emplace(0x30+i, lynxLFSRHandler); + } + sysDefs[DIV_SYSTEM_LYNX]=new DivSysDef( "Atari Lynx", NULL, 0xa8, 0, 4, false, true, 0, false, "a portable console made by Atari. it has all of Atari's trademark waveforms.", @@ -1668,17 +1271,20 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_MIKEY, DIV_INS_MIKEY, DIV_INS_MIKEY, DIV_INS_MIKEY}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - if (effect>=0x30 && effect<0x40) { - int value=((int)(effect&0x0f)<<8)|effectVal; - dispatchCmd(DivCommand(DIV_CMD_LYNX_LFSR_LOAD,ch,value)); - return true; - } - return false; - } + {}, + lynxEffectHandlerMap ); + EffectHandlerMap qSoundEffectHandlerMap={ + {0x10, {DIV_CMD_QSOUND_ECHO_FEEDBACK, "10xx: Set echo feedback level (00 to FF)"}}, + {0x11, {DIV_CMD_QSOUND_ECHO_LEVEL, "11xx: Set channel echo level (00 to FF)"}}, + {0x12, {DIV_CMD_QSOUND_SURROUND, "12xx: Toggle QSound algorithm (0: disabled; 1: enabled)"}}, + }; + const EffectHandler qSoundEchoDelayHandler(DIV_CMD_QSOUND_ECHO_DELAY, "3xxx: Set echo delay buffer length (000 to AA5)", effectValLong<12>); + for (int i=0; i<16; i++) { + qSoundEffectHandlerMap.emplace(0x30+i, qSoundEchoDelayHandler); + } + sysDefs[DIV_SYSTEM_QSOUND]=new DivSysDef( "Capcom QSound", NULL, 0xe0, 0, 19, false, true, 0x161, false, "used in some of Capcom's arcade boards. surround-like sampled sound with echo.", @@ -1687,27 +1293,7 @@ void DivEngine::registerSystems() { {DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // echo feedback - dispatchCmd(DivCommand(DIV_CMD_QSOUND_ECHO_FEEDBACK,ch,effectVal)); - break; - case 0x11: // echo level - dispatchCmd(DivCommand(DIV_CMD_QSOUND_ECHO_LEVEL,ch,effectVal)); - break; - case 0x12: // surround - dispatchCmd(DivCommand(DIV_CMD_QSOUND_SURROUND,ch,effectVal)); - break; - default: - if ((effect&0xf0)==0x30) { - dispatchCmd(DivCommand(DIV_CMD_QSOUND_ECHO_DELAY,ch,((effect & 0x0f) << 8) | effectVal)); - } else { - return false; - } - break; - } - return true; - } + qSoundEffectHandlerMap ); sysDefs[DIV_SYSTEM_VERA]=new DivSysDef( @@ -1718,31 +1304,22 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM}, {DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_VERA, DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x22: // duty - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_WAVE, "20xx: Set waveform"}}, + {0x22, {DIV_CMD_STD_NOISE_MODE, "22xx: Set duty cycle (0 to 3F)"}}, } ); sysDefs[DIV_SYSTEM_YM2610B_EXT]=new DivSysDef( - "Yamaha YM2610B (OPNB-B) Extended Channel 3", NULL, 0xde, 0, 19, true, false, 0x151, false, - "so Taito asked Yamaha if they could get the two missing FM channels back, and Yamaha gladly provided them with this chip.\nthis one is in Extended Channel mode, which turns the second FM channel into four operators with independent notes/frequencies.", + "Yamaha YM2610B (OPNB2) Extended Channel 3", NULL, 0xde, 0, 19, true, false, 0x151, false, + "so Taito asked Yamaha if they could get the two missing FM channels back, and Yamaha gladly provided them with this chip.\nthis one is in Extended Channel mode, which turns the third FM channel into four operators with independent notes/frequencies.", {"FM 1", "FM 2", "FM 3 OP1", "FM 3 OP2", "FM 3 OP3", "FM 3 OP4", "FM 4", "FM 5", "FM 6", "PSG 1", "PSG 2", "PSG 3", "ADPCM-A 1", "ADPCM-A 2", "ADPCM-A 3", "ADPCM-A 4", "ADPCM-A 5", "ADPCM-A 6", "ADPCM-B"}, {"F1", "F2", "O1", "O2", "O3", "O4", "F4", "F5", "F6", "S1", "S2", "S3", "P1", "P2", "P3", "P4", "P5", "P6", "B"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AY, DIV_INS_AY, DIV_INS_AY, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - fmHardResetEffectHandler, - fmPostEffectHandler + fmEffectHandlerMap, + fmOPNPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_SEGAPCM_COMPAT]=new DivSysDef( @@ -1753,8 +1330,8 @@ void DivEngine::registerSystems() { {DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - segaPCMPostEffectHandler + {}, + segaPCMPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_X1_010]=new DivSysDef( @@ -1765,46 +1342,18 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010, DIV_INS_X1_010}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // select envelope shape - dispatchCmd(DivCommand(DIV_CMD_X1_010_ENVELOPE_SHAPE,ch,effectVal)); - break; - case 0x17: // PCM enable - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,(effectVal>0))); - break; - default: - return false; - } - return true; + { + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_X1_010_ENVELOPE_SHAPE, "11xx: Set envelope shape"}}, + {0x17, {DIV_CMD_SAMPLE_MODE, "17xx: Toggle PCM mode"}}, }, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // PCM frequency - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_FREQ,ch,effectVal)); - break; - case 0x22: // envelope mode - dispatchCmd(DivCommand(DIV_CMD_X1_010_ENVELOPE_MODE,ch,effectVal)); - break; - case 0x23: // envelope period - dispatchCmd(DivCommand(DIV_CMD_X1_010_ENVELOPE_PERIOD,ch,effectVal)); - break; - case 0x25: // envelope slide up - dispatchCmd(DivCommand(DIV_CMD_X1_010_ENVELOPE_SLIDE,ch,effectVal)); - break; - case 0x26: // envelope slide down - dispatchCmd(DivCommand(DIV_CMD_X1_010_ENVELOPE_SLIDE,ch,-effectVal)); - break; - case 0x29: // auto-envelope - dispatchCmd(DivCommand(DIV_CMD_X1_010_AUTO_ENVELOPE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_SAMPLE_FREQ, "20xx: Set PCM frequency (1 to FF)"}}, + {0x22, {DIV_CMD_X1_010_ENVELOPE_MODE, "22xx: Set envelope mode (bit 0: enable; bit 1: one-shot; bit 2: split shape to L/R; bit 3/5: H.invert right/left; bit 4/6: V.invert right/left)"}}, + {0x23, {DIV_CMD_X1_010_ENVELOPE_PERIOD, "23xx: Set envelope period"}}, + {0x25, {DIV_CMD_X1_010_ENVELOPE_SLIDE, "25xx: Envelope slide up"}}, + {0x26, {DIV_CMD_X1_010_ENVELOPE_SLIDE, "26xx: Envelope slide down", negEffectVal}}, + {0x29, {DIV_CMD_X1_010_AUTO_ENVELOPE, "29xy: Set auto-envelope (x: numerator; y: denominator)"}}, } ); @@ -1816,7 +1365,7 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_SCC, DIV_INS_SCC}, {}, - waveOnlyEffectHandler + waveOnlyEffectHandlerMap ); // to Grauw: feel free to change this to 24 during development of OPL4's PCM part. @@ -1855,8 +1404,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PCM}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_AMIGA}, {}, - oplEffectHandler, - fmOPLPostEffectHandler + fmEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_Y8950_DRUMS]=new DivSysDef( @@ -1867,8 +1416,8 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_PCM}, {DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_OPL_DRUMS, DIV_INS_AMIGA}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_OPL, DIV_INS_NULL}, - oplEffectHandler, - fmOPLPostEffectHandler + fmEffectHandlerMap, + fmOPLPostEffectHandlerMap ); sysDefs[DIV_SYSTEM_SCC_PLUS]=new DivSysDef( @@ -1879,9 +1428,34 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC, DIV_INS_SCC}, {}, - waveOnlyEffectHandler + waveOnlyEffectHandlerMap ); + EffectHandlerMap suEffectHandlerMap={ + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform (0 to 7)"}}, + {0x12, {DIV_CMD_STD_NOISE_MODE, "12xx: Set pulse width (0 to 7F)"}}, + {0x13, {DIV_CMD_C64_RESONANCE, "13xx: Set resonance (0 to FF)"}}, + {0x14, {DIV_CMD_C64_FILTER_MODE, "14xx: Set filter mode (bit 0: ring mod; bit 1: low pass; bit 2: high pass; bit 3: band pass)"}}, + {0x15, {DIV_CMD_SU_SWEEP_PERIOD_LOW, "15xx: Set frequency sweep period low byte", constVal<0>, effectVal}}, + {0x16, {DIV_CMD_SU_SWEEP_PERIOD_HIGH, "16xx: Set frequency sweep period high byte", constVal<0>, effectVal}}, + {0x17, {DIV_CMD_SU_SWEEP_PERIOD_LOW, "17xx: Set volume sweep period low byte", constVal<1>, effectVal}}, + {0x18, {DIV_CMD_SU_SWEEP_PERIOD_HIGH, "18xx: Set volume sweep period high byte", constVal<1>, effectVal}}, + {0x19, {DIV_CMD_SU_SWEEP_PERIOD_LOW, "19xx: Set cutoff sweep period low byte", constVal<2>, effectVal}}, + {0x1a, {DIV_CMD_SU_SWEEP_PERIOD_HIGH, "1Axx: Set cutoff sweep period high byte", constVal<2>, effectVal}}, + {0x1b, {DIV_CMD_SU_SWEEP_BOUND, "1Bxx: Set frequency sweep boundary", constVal<0>, effectVal}}, + {0x1c, {DIV_CMD_SU_SWEEP_BOUND, "1Cxx: Set volume sweep boundary", constVal<1>, effectVal}}, + {0x1d, {DIV_CMD_SU_SWEEP_BOUND, "1Dxx: Set cutoff sweep boundary", constVal<2>, effectVal}}, + {0x1e, {DIV_CMD_SU_SYNC_PERIOD_LOW, "1Exx: Set phase reset period low byte"}}, + {0x1f, {DIV_CMD_SU_SYNC_PERIOD_HIGH, "1Fxx: Set phase reset period high byte"}}, + {0x20, {DIV_CMD_SU_SWEEP_ENABLE, "20xx: Toggle frequency sweep (bit 0-6: speed; bit 7: direction is up)", constVal<0>, effectVal}}, + {0x21, {DIV_CMD_SU_SWEEP_ENABLE, "21xx: Toggle volume sweep (bit 0-4: speed; bit 5: direciton is up; bit 6: loop; bit 7: alternate)", constVal<1>, effectVal}}, + {0x22, {DIV_CMD_SU_SWEEP_ENABLE, "22xx: Toggle cutoff sweep (bit 0-6: speed; bit 7: direction is up)", constVal<2>, effectVal}}, + }; + const EffectHandler suCutoffHandler(DIV_CMD_C64_FINE_CUTOFF, "4xxx: Set cutoff (0 to FFF)", effectValLong<12>); + for (int i=0; i<16; i++) { + suEffectHandlerMap.emplace(0x40+i, suCutoffHandler); + } + sysDefs[DIV_SYSTEM_SOUND_UNIT]=new DivSysDef( "tildearrow Sound Unit", NULL, 0xb5, 0, 8, false, true, 0, false, "tildearrow's fantasy sound chip. put SID, AY and VERA in a blender, and you get this!", @@ -1890,74 +1464,8 @@ void DivEngine::registerSystems() { {DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE, DIV_CH_NOISE}, {DIV_INS_SU, DIV_INS_SU, DIV_INS_SU, DIV_INS_SU, DIV_INS_SU, DIV_INS_SU, DIV_INS_SU, DIV_INS_SU}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, - [](int,unsigned char,unsigned char) -> bool {return false;}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x12: // duty cycle - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - case 0x13: // resonance - dispatchCmd(DivCommand(DIV_CMD_C64_RESONANCE,ch,effectVal)); - break; - case 0x14: // filter mode - dispatchCmd(DivCommand(DIV_CMD_C64_FILTER_MODE,ch,effectVal)); - break; - case 0x15: // freq sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_LOW,ch,0,effectVal)); - break; - case 0x16: // freq sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_HIGH,ch,0,effectVal)); - break; - case 0x17: // vol sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_LOW,ch,1,effectVal)); - break; - case 0x18: // vol sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_HIGH,ch,1,effectVal)); - break; - case 0x19: // cut sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_LOW,ch,2,effectVal)); - break; - case 0x1a: // cut sweep - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_PERIOD_HIGH,ch,2,effectVal)); - break; - case 0x1b: // freq sweep bound - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_BOUND,ch,0,effectVal)); - break; - case 0x1c: // vol sweep bound - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_BOUND,ch,1,effectVal)); - break; - case 0x1d: // cut sweep bound - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_BOUND,ch,2,effectVal)); - break; - case 0x1e: // sync low - dispatchCmd(DivCommand(DIV_CMD_SU_SYNC_PERIOD_LOW,ch,effectVal)); - break; - case 0x1f: // sync high - dispatchCmd(DivCommand(DIV_CMD_SU_SYNC_PERIOD_HIGH,ch,effectVal)); - break; - case 0x20: // freq sweep enable - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_ENABLE,ch,0,effectVal)); - break; - case 0x21: // vol sweep enable - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_ENABLE,ch,1,effectVal)); - break; - case 0x22: // cut sweep enable - dispatchCmd(DivCommand(DIV_CMD_SU_SWEEP_ENABLE,ch,2,effectVal)); - break; - case 0x40: case 0x41: case 0x42: case 0x43: - case 0x44: case 0x45: case 0x46: case 0x47: - case 0x48: case 0x49: case 0x4a: case 0x4b: - case 0x4c: case 0x4d: case 0x4e: case 0x4f: // cutoff - dispatchCmd(DivCommand(DIV_CMD_C64_FINE_CUTOFF,ch,(((effect&0x0f)<<8)|effectVal)*4)); - break; - default: - return false; - } - return true; - } + {}, + suEffectHandlerMap ); sysDefs[DIV_SYSTEM_MSM6295]=new DivSysDef( @@ -1968,15 +1476,8 @@ void DivEngine::registerSystems() { {DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // select rate - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_FREQ,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_SAMPLE_FREQ, "20xx: Set chip output rate (0: clock/132; 1: clock/165)"}}, } ); @@ -1988,18 +1489,9 @@ void DivEngine::registerSystems() { {DIV_CH_PCM}, {DIV_INS_AMIGA}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // select rate - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_FREQ,ch,effectVal)); - break; - case 0x21: // select clock - dispatchCmd(DivCommand(DIV_CMD_SAMPLE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_SAMPLE_FREQ, "20xx: Set frequency divider (0-2)"}}, + {0x21, {DIV_CMD_SAMPLE_MODE, "21xx: Select clock rate (0: full; 1: half)"}}, } ); @@ -2012,18 +1504,9 @@ void DivEngine::registerSystems() { {DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA, DIV_INS_AMIGA} ); - auto namcoEffectHandler=[this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x10: // select waveform - dispatchCmd(DivCommand(DIV_CMD_WAVE,ch,effectVal)); - break; - case 0x11: // noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + EffectHandlerMap namcoEffectHandlerMap={ + {0x10, {DIV_CMD_WAVE, "10xx: Set waveform"}}, + {0x11, {DIV_CMD_STD_NOISE_MODE, "11xx: Toggle noise mode"}}, }; sysDefs[DIV_SYSTEM_NAMCO]=new DivSysDef( @@ -2034,7 +1517,7 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO}, {}, - namcoEffectHandler + namcoEffectHandlerMap ); sysDefs[DIV_SYSTEM_NAMCO_15XX]=new DivSysDef( @@ -2045,7 +1528,7 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO}, {}, - namcoEffectHandler + namcoEffectHandlerMap ); sysDefs[DIV_SYSTEM_NAMCO_CUS30]=new DivSysDef( @@ -2056,7 +1539,7 @@ void DivEngine::registerSystems() { {DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE, DIV_CH_WAVE}, {DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO, DIV_INS_NAMCO}, {}, - namcoEffectHandler + namcoEffectHandlerMap ); // replace with an 8-channel chip in a future @@ -2077,20 +1560,20 @@ void DivEngine::registerSystems() { {DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_FM, DIV_CH_PCM, DIV_CH_PCM}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AMIGA}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA, DIV_INS_NULL}, - opn2EffectHandler, - fmPostEffectHandler + fmOPN2EffectHandlerMap, + fmOPN2PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_YM2612_FRAC_EXT]=new DivSysDef( "Yamaha YM2612 (OPN2) Extended Channel 3 with DualPCM and CSM", NULL, 0xbd, 0, 11, true, false, 0, false, - "this chip is mostly known for being in the Sega Genesis (but it also was on the FM Towns computer).\nthis system uses software mixing to provide two sample channels.\nthis one is in Extended Channel mode, which turns the second FM channel into four operators with independent notes/frequencies.", + "this chip is mostly known for being in the Sega Genesis (but it also was on the FM Towns computer).\nthis system uses software mixing to provide two sample channels.\nthis one is in Extended Channel mode, which turns the third FM channel into four operators with independent notes/frequencies.", {"FM 1", "FM 2", "FM 3 OP1", "FM 3 OP2", "FM 3 OP3", "FM 3 OP4", "FM 4", "FM 5", "FM 6/PCM 1", "PCM 2", "CSM Timer"}, {"F1", "F2", "O1", "O2", "O3", "O4", "F4", "F5", "P1", "P2", "CSM"}, {DIV_CH_FM, DIV_CH_FM, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_OP, DIV_CH_FM, DIV_CH_FM, DIV_CH_PCM, DIV_CH_PCM, DIV_CH_NOISE}, {DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_FM, DIV_INS_AMIGA, DIV_INS_FM}, {DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_NULL, DIV_INS_AMIGA, DIV_INS_NULL, DIV_INS_NULL}, - opn2EffectHandler, - fmPostEffectHandler + fmOPN2EffectHandlerMap, + fmOPN2PostEffectHandlerMap ); sysDefs[DIV_SYSTEM_T6W28]=new DivSysDef( @@ -2101,15 +1584,8 @@ void DivEngine::registerSystems() { {DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_PULSE, DIV_CH_NOISE}, {DIV_INS_STD, DIV_INS_STD, DIV_INS_STD, DIV_INS_STD}, {}, - [this](int ch, unsigned char effect, unsigned char effectVal) -> bool { - switch (effect) { - case 0x20: // SN noise mode - dispatchCmd(DivCommand(DIV_CMD_STD_NOISE_MODE,ch,effectVal)); - break; - default: - return false; - } - return true; + { + {0x20, {DIV_CMD_STD_NOISE_MODE, "20xy: Set noise mode (x: preset/variable; y: thin pulse/noise)"}} } ); diff --git a/src/engine/wavetable.cpp b/src/engine/wavetable.cpp index 0b13497ef..9de8544fe 100644 --- a/src/engine/wavetable.cpp +++ b/src/engine/wavetable.cpp @@ -59,7 +59,9 @@ DivDataErrors DivWavetable::readWaveData(SafeReader& reader, short version) { if (len>256 || min!=0 || max>255) return DIV_DATA_INVALID_DATA; - reader.read(data,4*len); + for (int i=0; isong.snNoLowPeriods); + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("when enabled, any SN period under 8 will be written as 1 instead.\nthis replicates DefleMask behavior, but reduces available period range."); + } ImGui::Text("Pitch linearity:"); if (ImGui::RadioButton("None",e->song.linearPitch==0)) { @@ -189,6 +193,26 @@ void FurnaceGUI::drawCompatFlags() { ImGui::SetTooltip("select to not reset channels on loop."); } + ImGui::Text("Cut/delay effect policy:"); + if (ImGui::RadioButton("Strict",e->song.delayBehavior==0)) { + e->song.delayBehavior=0; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("only when time is less than speed (like DefleMask/ProTracker)"); + } + if (ImGui::RadioButton("Strict (old)",e->song.delayBehavior==1)) { + e->song.delayBehavior=1; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("only when time is less than or equal to speed (original buggy behavior)"); + } + if (ImGui::RadioButton("Lax",e->song.delayBehavior==2)) { + e->song.delayBehavior=2; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("no checks (like FamiTracker)"); + } + ImGui::Separator(); ImGui::TextWrapped("the following flags are for compatibility with older Furnace versions."); diff --git a/src/gui/doAction.cpp b/src/gui/doAction.cpp index 5c840df4e..e0f0ca30a 100644 --- a/src/gui/doAction.cpp +++ b/src/gui/doAction.cpp @@ -241,6 +241,9 @@ void FurnaceGUI::doAction(int what) { case GUI_ACTION_WINDOW_PAT_MANAGER: nextWindow=GUI_WINDOW_PAT_MANAGER; break; + case GUI_ACTION_WINDOW_SYS_MANAGER: + nextWindow=GUI_WINDOW_SYS_MANAGER; + break; case GUI_ACTION_WINDOW_REGISTER_VIEW: nextWindow=GUI_WINDOW_REGISTER_VIEW; break; @@ -328,6 +331,9 @@ void FurnaceGUI::doAction(int what) { case GUI_WINDOW_PAT_MANAGER: patManagerOpen=false; break; + case GUI_WINDOW_SYS_MANAGER: + sysManagerOpen=false; + break; case GUI_WINDOW_REGISTER_VIEW: regViewOpen=false; break; diff --git a/src/gui/editing.cpp b/src/gui/editing.cpp index 21b1a72eb..391a39f62 100644 --- a/src/gui/editing.cpp +++ b/src/gui/editing.cpp @@ -577,7 +577,7 @@ void FurnaceGUI::doChangeIns(int ins) { if (!e->curSubSong->chanShow[iCoarse]) continue; DivPattern* pat=e->curPat[iCoarse].getPattern(e->curOrders->ord[iCoarse][curOrder],true); for (int j=selStart.y; j<=selEnd.y; j++) { - if (pat->data[j][2]!=-1 || !(pat->data[j][0]==0 && pat->data[j][1]==0)) { + if (pat->data[j][2]!=-1 || !((pat->data[j][0]==0 || pat->data[j][0]==100 || pat->data[j][0]==101 || pat->data[j][0]==102) && pat->data[j][1]==0)) { pat->data[j][2]=ins; } } @@ -616,9 +616,9 @@ void FurnaceGUI::doInterpolate() { } } else { for (int j=selStart.y; j<=selEnd.y; j++) { - if (pat->data[j][0]!=0 && pat->data[j][1]!=0) { + if (pat->data[j][0]!=0 || pat->data[j][1]!=0) { if (pat->data[j][0]!=100 && pat->data[j][0]!=101 && pat->data[j][0]!=102) { - points.emplace(points.end(),j,pat->data[j][0]+pat->data[j][1]*12); + points.emplace(points.end(),j,pat->data[j][0]+(signed char)pat->data[j][1]*12); } } } diff --git a/src/gui/effectList.cpp b/src/gui/effectList.cpp index a71a2fec7..488d4e794 100644 --- a/src/gui/effectList.cpp +++ b/src/gui/effectList.cpp @@ -10,7 +10,7 @@ void FurnaceGUI::drawEffectList() { } if (!effectListOpen) return; if (ImGui::Begin("Effect List",&effectListOpen,globalWinFlags)) { - ImGui::Text("System at cursor: %s",e->getSystemName(e->sysOfChan[cursor.xCoarse])); + ImGui::Text("Chip at cursor: %s",e->getSystemName(e->sysOfChan[cursor.xCoarse])); if (ImGui::BeginTable("effectList",2)) { ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthFixed); ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthStretch); diff --git a/src/gui/gui.cpp b/src/gui/gui.cpp index 3fcfed8eb..edbe98644 100644 --- a/src/gui/gui.cpp +++ b/src/gui/gui.cpp @@ -195,23 +195,30 @@ void FurnaceGUI::decodeKeyMap(std::map& map, String source) { } } -void FurnaceGUI::encodeMMLStr(String& target, int* macro, int macroLen, int macroLoop, int macroRel, bool hex) { +void FurnaceGUI::encodeMMLStr(String& target, int* macro, int macroLen, int macroLoop, int macroRel, bool hex, bool bit30) { target=""; char buf[32]; for (int i=0; imacroMax) macro[macroLen]=macroMax; + if (setBit30) macro[macroLen]^=0x40000000; + setBit30=false; macroLen++; buf=0; } @@ -315,10 +330,12 @@ void FurnaceGUI::decodeMMLStr(String& source, int* macro, unsigned char& macroLe negaBuf=false; if (macro[macroLen]macroMax) macro[macroLen]=macroMax; + if (setBit30) macro[macroLen]^=0x40000000; + setBit30=false; macroLen++; buf=0; } - if (macroLoop==-1) { + if (macroLoop==255) { macroLoop=macroLen; } break; @@ -329,22 +346,26 @@ void FurnaceGUI::decodeMMLStr(String& source, int* macro, unsigned char& macroLe negaBuf=false; if (macro[macroLen]macroMax) macro[macroLen]=macroMax; + if (setBit30) macro[macroLen]^=0x40000000; + setBit30=false; macroLen++; buf=0; } - if (macroRel==-1) { + if (macroRel==255) { macroRel=macroLen; } break; } - if (macroLen>=128) break; + if (macroLen>=255) break; } - if (hasVal && macroLen<128) { + if (hasVal && macroLen<255) { hasVal=false; macro[macroLen]=negaBuf?-buf:buf; negaBuf=false; if (macro[macroLen]macroMax) macro[macroLen]=macroMax; + if (setBit30) macro[macroLen]^=0x40000000; + setBit30=false; macroLen++; buf=0; } @@ -1582,6 +1603,7 @@ void FurnaceGUI::openFileDialog(FurnaceGUIFileDialogs type) { int FurnaceGUI::save(String path, int dmfVersion) { SafeWriter* w; if (dmfVersion) { + if (dmfVersion<24) dmfVersion=24; w=e->saveDMF(dmfVersion); } else { w=e->saveFur(); @@ -1768,8 +1790,35 @@ void FurnaceGUI::showError(String what) { displayError=true; } +// what monster did I just create here? +#define B30(tt) (macroDragBit30?((((tt)&0xc0000000)==0x40000000 || ((tt)&0xc0000000)==0x80000000)?0x40000000:0):0) + #define MACRO_DRAG(t) \ - if (macroDragBitMode) { \ + if (macroDragSettingBit30) { \ + if (macroDragLastX!=x || macroDragLastY!=y) { \ + macroDragLastX=x; \ + macroDragLastY=y; \ + if (macroDragInitialValueSet) { \ + if (!macroDragInitialValue) { \ + if (t[x]&0x80000000) { \ + t[x]&=~0x40000000; \ + } else { \ + t[x]|=0x40000000; \ + } \ + } else { \ + if (t[x]&0x80000000) { \ + t[x]|=0x40000000; \ + } else { \ + t[x]&=~0x40000000; \ + } \ + } \ + } else { \ + macroDragInitialValue=(((t[x])&0xc0000000)==0x40000000 || ((t[x])&0xc0000000)==0x80000000); \ + macroDragInitialValueSet=true; \ + t[x]^=0x40000000; \ + } \ + } \ + } else if (macroDragBitMode) { \ if (macroDragLastX!=x || macroDragLastY!=y) { \ macroDragLastX=x; \ macroDragLastY=y; \ @@ -1800,25 +1849,25 @@ void FurnaceGUI::showError(String what) { } \ if (macroDragMouseMoved) { \ if ((int)round(x-macroDragLineInitial.x)==0) { \ - t[x]=macroDragLineInitial.y; \ + t[x]=B30(t[x])^(int)(macroDragLineInitial.y); \ } else { \ if ((int)round(x-macroDragLineInitial.x)<0) { \ for (int i=0; i<=(int)round(macroDragLineInitial.x-x); i++) { \ int index=(int)round(x+i); \ if (index<0) continue; \ - t[index]=y+(macroDragLineInitial.y-y)*((float)i/(float)(macroDragLineInitial.x-x)); \ + t[index]=B30(t[index])^(int)(y+(macroDragLineInitial.y-y)*((float)i/(float)(macroDragLineInitial.x-x))); \ } \ } else { \ for (int i=0; i<=(int)round(x-macroDragLineInitial.x); i++) { \ int index=(int)round(i+macroDragLineInitial.x); \ if (index<0) continue; \ - t[index]=macroDragLineInitial.y+(y-macroDragLineInitial.y)*((float)i/(x-macroDragLineInitial.x)); \ + t[index]=B30(t[index])^(int)(macroDragLineInitial.y+(y-macroDragLineInitial.y)*((float)i/(x-macroDragLineInitial.x))); \ } \ } \ } \ } \ } else { \ - t[x]=y; \ + t[x]=B30(t[x])^(y); \ } \ } @@ -1903,20 +1952,6 @@ void FurnaceGUI::processDrags(int dragX, int dragY) { } } -#define sysAddOption(x) \ - if (ImGui::MenuItem(getSystemName(x))) { \ - if (!e->addSystem(x)) { \ - showError("cannot add chip! ("+e->getLastError()+")"); \ - } \ - updateWindowTitle(); \ - } - -#define sysChangeOption(x,y) \ - if (ImGui::MenuItem(getSystemName(y),NULL,e->song.system[x]==y)) { \ - e->changeSystem(x,y,preserveChanPos); \ - updateWindowTitle(); \ - } - #define checkExtension(x) \ String lowerCase=fileName; \ for (char& i: lowerCase) { \ @@ -3033,9 +3068,13 @@ bool FurnaceGUI::loop() { } ImGui::Separator(); if (ImGui::BeginMenu("add chip...")) { - for (int j=0; availableSystems[j]; j++) { - if (!settings.hiddenSystems && (availableSystems[j]==DIV_SYSTEM_YMU759 || availableSystems[j]==DIV_SYSTEM_DUMMY)) continue; - sysAddOption((DivSystem)availableSystems[j]); + DivSystem picked=systemPicker(); + if (picked!=DIV_SYSTEM_NULL) { + if (!e->addSystem(picked)) { + showError("cannot add chip! ("+e->getLastError()+")"); + } + ImGui::CloseCurrentPopup(); + updateWindowTitle(); } ImGui::EndMenu(); } @@ -3052,9 +3091,11 @@ bool FurnaceGUI::loop() { ImGui::Checkbox("Preserve channel positions",&preserveChanPos); for (int i=0; isong.systemLen; i++) { if (ImGui::BeginMenu(fmt::sprintf("%d. %s##_SYSC%d",i+1,getSystemName(e->song.system[i]),i).c_str())) { - for (int j=0; availableSystems[j]; j++) { - if (!settings.hiddenSystems && (availableSystems[j]==DIV_SYSTEM_YMU759 || availableSystems[j]==DIV_SYSTEM_DUMMY)) continue; - sysChangeOption(i,(DivSystem)availableSystems[j]); + DivSystem picked=systemPicker(); + if (picked!=DIV_SYSTEM_NULL) { + e->changeSystem(i,picked,preserveChanPos); + updateWindowTitle(); + ImGui::CloseCurrentPopup(); } ImGui::EndMenu(); } @@ -3138,6 +3179,7 @@ bool FurnaceGUI::loop() { if (ImGui::MenuItem("mixer",BIND_FOR(GUI_ACTION_WINDOW_MIXER),mixerOpen)) mixerOpen=!mixerOpen; if (ImGui::MenuItem("channels",BIND_FOR(GUI_ACTION_WINDOW_CHANNELS),channelsOpen)) channelsOpen=!channelsOpen; if (ImGui::MenuItem("pattern manager",BIND_FOR(GUI_ACTION_WINDOW_PAT_MANAGER),patManagerOpen)) patManagerOpen=!patManagerOpen; + if (ImGui::MenuItem("chip manager",BIND_FOR(GUI_ACTION_WINDOW_SYS_MANAGER),sysManagerOpen)) sysManagerOpen=!sysManagerOpen; if (ImGui::MenuItem("compatibility flags",BIND_FOR(GUI_ACTION_WINDOW_COMPAT_FLAGS),compatFlagsOpen)) compatFlagsOpen=!compatFlagsOpen; if (ImGui::MenuItem("song comments",BIND_FOR(GUI_ACTION_WINDOW_NOTES),notesOpen)) notesOpen=!notesOpen; ImGui::Separator(); @@ -3273,6 +3315,7 @@ bool FurnaceGUI::loop() { drawNotes(); drawChannels(); drawPatManager(); + drawSysManager(); drawRegView(); drawLog(); drawEffectList(); @@ -4167,6 +4210,16 @@ bool FurnaceGUI::loop() { ImGui::CloseCurrentPopup(); } break; + case GUI_WARN_SYSTEM_DEL: + if (ImGui::Button("Yes")) { + e->removeSystem(sysToDelete,preserveChanPos); + ImGui::CloseCurrentPopup(); + } + ImGui::SameLine(); + if (ImGui::Button("No")) { + ImGui::CloseCurrentPopup(); + } + break; case GUI_WARN_GENERIC: if (ImGui::Button("OK")) { ImGui::CloseCurrentPopup(); @@ -4421,6 +4474,7 @@ bool FurnaceGUI::init() { notesOpen=e->getConfBool("notesOpen",false); channelsOpen=e->getConfBool("channelsOpen",false); patManagerOpen=e->getConfBool("patManagerOpen",false); + sysManagerOpen=e->getConfBool("sysManagerOpen",false); regViewOpen=e->getConfBool("regViewOpen",false); logOpen=e->getConfBool("logOpen",false); effectListOpen=e->getConfBool("effectListOpen",false); @@ -4665,6 +4719,7 @@ bool FurnaceGUI::finish() { e->setConf("notesOpen",notesOpen); e->setConf("channelsOpen",channelsOpen); e->setConf("patManagerOpen",patManagerOpen); + e->setConf("sysManagerOpen",sysManagerOpen); e->setConf("regViewOpen",regViewOpen); e->setConf("logOpen",logOpen); e->setConf("effectListOpen",effectListOpen); @@ -4764,6 +4819,7 @@ FurnaceGUI::FurnaceGUI(): zsmExportTickRate(60), macroPointSize(16), waveEditStyle(0), + curSysSection(NULL), pendingRawSampleDepth(8), pendingRawSampleChannels(1), pendingRawSampleUnsigned(false), @@ -4847,6 +4903,7 @@ FurnaceGUI::FurnaceGUI(): findOpen(false), spoilerOpen(false), patManagerOpen(false), + sysManagerOpen(false), selecting(false), selectingFull(false), dragging(false), @@ -4923,6 +4980,8 @@ FurnaceGUI::FurnaceGUI(): macroDragInitialValueSet(false), macroDragInitialValue(false), macroDragChar(false), + macroDragBit30(false), + macroDragSettingBit30(false), macroDragLineMode(false), macroDragMouseMoved(false), macroDragLineInitial(0,0), @@ -4961,6 +5020,8 @@ FurnaceGUI::FurnaceGUI(): eventTimeEnd(0), eventTimeDelta(0), chanToMove(-1), + sysToMove(-1), + sysToDelete(-1), transposeAmount(0), randomizeMin(0), randomizeMax(255), diff --git a/src/gui/gui.h b/src/gui/gui.h index 8e0c791a7..b7588cb74 100644 --- a/src/gui/gui.h +++ b/src/gui/gui.h @@ -251,6 +251,7 @@ enum FurnaceGUIWindows { GUI_WINDOW_NOTES, GUI_WINDOW_CHANNELS, GUI_WINDOW_PAT_MANAGER, + GUI_WINDOW_SYS_MANAGER, GUI_WINDOW_REGISTER_VIEW, GUI_WINDOW_LOG, GUI_WINDOW_EFFECT_LIST, @@ -311,6 +312,7 @@ enum FurnaceGUIWarnings { GUI_WARN_CLOSE_SETTINGS, GUI_WARN_CLEAR, GUI_WARN_SUBSONG_DEL, + GUI_WARN_SYSTEM_DEL, GUI_WARN_GENERIC }; @@ -372,6 +374,7 @@ enum FurnaceGUIActions { GUI_ACTION_WINDOW_NOTES, GUI_ACTION_WINDOW_CHANNELS, GUI_ACTION_WINDOW_PAT_MANAGER, + GUI_ACTION_WINDOW_SYS_MANAGER, GUI_ACTION_WINDOW_REGISTER_VIEW, GUI_ACTION_WINDOW_LOG, GUI_ACTION_WINDOW_EFFECT_LIST, @@ -869,10 +872,10 @@ struct FurnaceGUIMacroDesc { const char* modeName; ImVec4 color; unsigned int bitOffset; - bool isBitfield, blockMode; + bool isBitfield, blockMode, bit30; String (*hoverFunc)(int,float); - FurnaceGUIMacroDesc(const char* name, DivInstrumentMacro* m, int macroMin, int macroMax, float macroHeight, ImVec4 col=ImVec4(1.0f,1.0f,1.0f,1.0f), bool block=false, const char* mName=NULL, String (*hf)(int,float)=NULL, bool bitfield=false, const char** bfVal=NULL, unsigned int bitOff=0): + FurnaceGUIMacroDesc(const char* name, DivInstrumentMacro* m, int macroMin, int macroMax, float macroHeight, ImVec4 col=ImVec4(1.0f,1.0f,1.0f,1.0f), bool block=false, const char* mName=NULL, String (*hf)(int,float)=NULL, bool bitfield=false, const char** bfVal=NULL, unsigned int bitOff=0, bool bit30Special=false): macro(m), height(macroHeight), displayName(name), @@ -882,6 +885,7 @@ struct FurnaceGUIMacroDesc { bitOffset(bitOff), isBitfield(bitfield), blockMode(block), + bit30(bit30Special), hoverFunc(hf) { // MSVC -> hell this->min=macroMin; @@ -967,13 +971,16 @@ class FurnaceGUI { int sampleTexW, sampleTexH; bool updateSampleTex; - String workingDir, fileName, clipboard, warnString, errorString, lastError, curFileName, nextFile; + String workingDir, fileName, clipboard, warnString, errorString, lastError, curFileName, nextFile, sysSearchQuery, newSongQuery; String workingDirSong, workingDirIns, workingDirWave, workingDirSample, workingDirAudioExport; String workingDirVGMExport, workingDirZSMExport, workingDirROMExport, workingDirFont, workingDirColors, workingDirKeybinds; String workingDirLayout, workingDirROM, workingDirTest; String mmlString[32]; String mmlStringW; + std::vector sysSearchResults; + std::vector newSongSearchResults; + bool quit, warnQuit, willCommit, edit, modified, displayError, displayExporting, vgmExportLoop, zsmExportLoop, vgmExportPatternHints; bool wantCaptureKeyboard, oldWantCaptureKeyboard, displayMacroMenu; bool displayNew, fullScreen, preserveChanPos, wantScrollList, noteInputPoly; @@ -984,6 +991,7 @@ class FurnaceGUI { int zsmExportTickRate; int macroPointSize; int waveEditStyle; + const int* curSysSection; String pendingRawSample; int pendingRawSampleDepth, pendingRawSampleChannels; @@ -1086,6 +1094,8 @@ class FurnaceGUI { int roundedMenus; int loadJapanese; int loadChinese; + int loadChineseTraditional; + int loadKorean; int fmLayout; int sampleLayout; int waveLayout; @@ -1130,6 +1140,11 @@ class FurnaceGUI { int noThreadedInput; int clampSamples; int saveUnusedPatterns; + int channelColors; + int channelTextColors; + int channelStyle; + int channelVolStyle; + int channelFeedbackStyle; unsigned int maxUndoSteps; String mainFontPath; String patFontPath; @@ -1198,6 +1213,8 @@ class FurnaceGUI { roundedMenus(0), loadJapanese(0), loadChinese(0), + loadChineseTraditional(0), + loadKorean(0), fmLayout(0), sampleLayout(0), waveLayout(0), @@ -1242,6 +1259,11 @@ class FurnaceGUI { noThreadedInput(0), clampSamples(0), saveUnusedPatterns(0), + channelColors(1), + channelTextColors(0), + channelStyle(0), + channelVolStyle(0), + channelFeedbackStyle(1), maxUndoSteps(100), mainFontPath(""), patFontPath(""), @@ -1271,7 +1293,7 @@ class FurnaceGUI { bool waveListOpen, waveEditOpen, sampleListOpen, sampleEditOpen, aboutOpen, settingsOpen; bool mixerOpen, debugOpen, inspectorOpen, oscOpen, volMeterOpen, statsOpen, compatFlagsOpen; bool pianoOpen, notesOpen, channelsOpen, regViewOpen, logOpen, effectListOpen, chanOscOpen; - bool subSongsOpen, findOpen, spoilerOpen, patManagerOpen; + bool subSongsOpen, findOpen, spoilerOpen, patManagerOpen, sysManagerOpen; SelectionPoint selStart, selEnd, cursor, cursorDrag, dragStart, dragEnd; bool selecting, selectingFull, dragging, curNibble, orderNibble, followOrders, followPattern, changeAllOrders, mobileUI; @@ -1386,6 +1408,8 @@ class FurnaceGUI { bool macroDragInitialValueSet; bool macroDragInitialValue; bool macroDragChar; + bool macroDragBit30; + bool macroDragSettingBit30; bool macroDragLineMode; bool macroDragMouseMoved; ImVec2 macroDragLineInitial; @@ -1397,7 +1421,7 @@ class FurnaceGUI { ImVec2 macroLoopDragStart; ImVec2 macroLoopDragAreaSize; - signed char* macroLoopDragTarget; + unsigned char* macroLoopDragTarget; int macroLoopDragLen; bool macroLoopDragActive; @@ -1417,7 +1441,7 @@ class FurnaceGUI { int renderTimeBegin, renderTimeEnd, renderTimeDelta; int eventTimeBegin, eventTimeEnd, eventTimeDelta; - int chanToMove; + int chanToMove, sysToMove, sysToDelete; ImVec2 patWindowPos, patWindowSize; @@ -1581,6 +1605,7 @@ class FurnaceGUI { void drawNotes(); void drawChannels(); void drawPatManager(); + void drawSysManager(); void drawRegView(); void drawAbout(); void drawSettings(); @@ -1648,6 +1673,7 @@ class FurnaceGUI { void doReplace(); void doDrag(); void editOptions(bool topMenu); + DivSystem systemPicker(); void noteInput(int num, int key, int vol=-1); void valueInput(int num, bool direct=false, int target=-1); @@ -1676,8 +1702,8 @@ class FurnaceGUI { void applyUISettings(bool updateFonts=true); void initSystemPresets(); - void encodeMMLStr(String& target, int* macro, int macroLen, int macroLoop, int macroRel, bool hex=false); - void decodeMMLStr(String& source, int* macro, unsigned char& macroLen, signed char& macroLoop, int macroMin, int macroMax, signed char& macroRel); + void encodeMMLStr(String& target, int* macro, int macroLen, int macroLoop, int macroRel, bool hex=false, bool bit30=false); + void decodeMMLStr(String& source, int* macro, unsigned char& macroLen, unsigned char& macroLoop, int macroMin, int macroMax, unsigned char& macroRel, bool bit30=false); void decodeMMLStrW(String& source, int* macro, int& macroLen, int macroMax, bool hex=false); String encodeKeyMap(std::map& map); diff --git a/src/gui/guiConst.cpp b/src/gui/guiConst.cpp index 7c38237a5..a72b40b05 100644 --- a/src/gui/guiConst.cpp +++ b/src/gui/guiConst.cpp @@ -488,6 +488,7 @@ const FurnaceGUIActionDef guiActions[GUI_ACTION_MAX]={ D("WINDOW_NOTES", "Song Comments", 0), D("WINDOW_CHANNELS", "Channels", 0), D("WINDOW_PAT_MANAGER", "Pattern Manager", 0), + D("WINDOW_SYS_MANAGER", "Chip Manager", 0), D("WINDOW_REGISTER_VIEW", "Register View", 0), D("WINDOW_LOG", "Log Viewer", 0), D("EFFECT_LIST", "Effect List", 0), @@ -839,7 +840,9 @@ const FurnaceGUIColorDef guiColors[GUI_COLOR_MAX]={ }; #undef D -// define systems. +// define chips here + +// all chips const int availableSystems[]={ DIV_SYSTEM_YM2612, DIV_SYSTEM_YM2612_EXT, @@ -911,3 +914,115 @@ const int availableSystems[]={ 0 // don't remove this last one! }; +// FM +const int chipsFM[]={ + DIV_SYSTEM_YM2612, + DIV_SYSTEM_YM2612_EXT, + DIV_SYSTEM_YM2612_FRAC, + DIV_SYSTEM_YM2612_FRAC_EXT, + DIV_SYSTEM_YM2151, + DIV_SYSTEM_YM2610, + DIV_SYSTEM_YM2610_EXT, + DIV_SYSTEM_YM2610_FULL, + DIV_SYSTEM_YM2610_FULL_EXT, + DIV_SYSTEM_YM2610B, + DIV_SYSTEM_YM2610B_EXT, + DIV_SYSTEM_YMU759, + DIV_SYSTEM_OPN, + DIV_SYSTEM_OPN_EXT, + DIV_SYSTEM_PC98, + DIV_SYSTEM_PC98_EXT, + DIV_SYSTEM_OPLL, + DIV_SYSTEM_OPLL_DRUMS, + DIV_SYSTEM_VRC7, + DIV_SYSTEM_OPL, + DIV_SYSTEM_OPL_DRUMS, + DIV_SYSTEM_Y8950, + DIV_SYSTEM_Y8950_DRUMS, + DIV_SYSTEM_OPL2, + DIV_SYSTEM_OPL2_DRUMS, + DIV_SYSTEM_OPL3, + DIV_SYSTEM_OPL3_DRUMS, + DIV_SYSTEM_OPZ, + 0 // don't remove this last one! +}; + +// square +const int chipsSquare[]={ + DIV_SYSTEM_SMS, + DIV_SYSTEM_AY8910, + DIV_SYSTEM_PCSPKR, + DIV_SYSTEM_SAA1099, + DIV_SYSTEM_VIC20, + 0 // don't remove this last one! +}; + +// wavetable +const int chipsWave[]={ + DIV_SYSTEM_PCE, + DIV_SYSTEM_X1_010, + DIV_SYSTEM_SWAN, + DIV_SYSTEM_BUBSYS_WSG, + DIV_SYSTEM_N163, + DIV_SYSTEM_FDS, + DIV_SYSTEM_SCC, + DIV_SYSTEM_SCC_PLUS, + DIV_SYSTEM_NAMCO, + DIV_SYSTEM_NAMCO_15XX, + DIV_SYSTEM_NAMCO_CUS30, + 0 // don't remove this last one! +}; + +// specialized +const int chipsSpecial[]={ + DIV_SYSTEM_GB, + DIV_SYSTEM_NES, + DIV_SYSTEM_C64_8580, + DIV_SYSTEM_C64_6581, + DIV_SYSTEM_SFX_BEEPER, + DIV_SYSTEM_DUMMY, + DIV_SYSTEM_SOUND_UNIT, + DIV_SYSTEM_TIA, + DIV_SYSTEM_AY8930, + DIV_SYSTEM_LYNX, + DIV_SYSTEM_VERA, + DIV_SYSTEM_PET, + DIV_SYSTEM_VRC6, + DIV_SYSTEM_MMC5, + 0 // don't remove this last one! +}; + +// sample +const int chipsSample[]={ + DIV_SYSTEM_SEGAPCM, + DIV_SYSTEM_SEGAPCM_COMPAT, + DIV_SYSTEM_AMIGA, + DIV_SYSTEM_QSOUND, + DIV_SYSTEM_X1_010, + DIV_SYSTEM_YMZ280B, + DIV_SYSTEM_MSM6258, + DIV_SYSTEM_MSM6295, + DIV_SYSTEM_RF5C68, + DIV_SYSTEM_PCM_DAC, + 0 // don't remove this last one! +}; + +const int* chipCategories[]={ + availableSystems, + chipsFM, + chipsSquare, + chipsWave, + chipsSpecial, + chipsSample, + NULL +}; + +const char* chipCategoryNames[]={ + "All chips", + "FM", + "Square", + "Wavetable", + "Special", + "Sample", + NULL +}; \ No newline at end of file diff --git a/src/gui/guiConst.h b/src/gui/guiConst.h index a6df68f62..24bdac47f 100644 --- a/src/gui/guiConst.h +++ b/src/gui/guiConst.h @@ -42,7 +42,14 @@ extern const char* pitchLabel[11]; extern const char* insTypes[]; extern const char* sampleDepths[]; extern const char* resampleStrats[]; +extern const char* chipCategoryNames[]; extern const int availableSystems[]; +extern const int chipsFM[]; +extern const int chipsSquare[]; +extern const int chipsWavetable[]; +extern const int chipsSpecial[]; +extern const int chipsSample[]; +extern const int* chipCategories[]; extern const FurnaceGUIActionDef guiActions[]; extern const FurnaceGUIColorDef guiColors[]; extern const int altValues[24]; diff --git a/src/gui/insEdit.cpp b/src/gui/insEdit.cpp index d4e76611f..c89652a37 100644 --- a/src/gui/insEdit.cpp +++ b/src/gui/insEdit.cpp @@ -19,6 +19,7 @@ #include "gui.h" #include "imgui_internal.h" +#include "../engine/macroInt.h" #include "IconsFontAwesome4.h" #include "misc/cpp/imgui_stdlib.h" #include "guiConst.h" @@ -250,6 +251,10 @@ const char* suControlBits[5]={ "ring mod", "low pass", "high pass", "band pass", NULL }; +const char* es5506FilterModes[4]={ + "HP/K2, HP/K2", "HP/K2, LP/K1", "LP/K2, LP/K2", "LP/K2, LP/K1", +}; + const char* panBits[3]={ "right", "left", NULL }; @@ -258,6 +263,14 @@ const char* oneBit[2]={ "on", NULL }; +const char* es5506EnvelopeModes[3]={ + "k1 slowdown", "k2 slowdown", NULL +}; + +const char* es5506ControlModes[2]={ + "pause", NULL +}; + const int orderedOps[4]={ 0, 2, 1, 3 }; @@ -293,10 +306,14 @@ const char* gbHWSeqCmdTypes[6]={ "Loop until Release" }; +// do not change these! +// anything other than a checkbox will look ugly! +// +// if you really need to, and have a good rationale (and by good I mean a VERY +// good one), please tell me and we'll sort it out. const char* macroAbsoluteMode="Fixed"; const char* macroRelativeMode="Relative"; const char* macroQSoundMode="QSound"; - const char* macroDummyMode="Bug"; String macroHoverNote(int id, float val) { @@ -314,6 +331,32 @@ String macroHoverLoop(int id, float val) { return ""; } +String macroHoverBit30(int id, float val) { + if (val>0) return "Fixed"; + return "Relative"; +} + +String macroHoverES5506FilterMode(int id, float val) { + String mode="???"; + switch (((int)val)&3) { + case 0: + mode="HP/K2, HP/K2"; + break; + case 1: + mode="HP/K2, LP/K1"; + break; + case 2: + mode="LP/K2, LP/K2"; + break; + case 3: + mode="LP/K2, LP/K1"; + break; + default: + break; + } + return fmt::sprintf("%d: %s",id,mode); +} + String macroLFOWaves(int id, float val) { switch (((int)val)&3) { case 0: @@ -1154,10 +1197,22 @@ String genericGuide(float value) { return fmt::sprintf("%d",(int)value); } +inline int deBit30(const int val) { + if ((val&0xc0000000)==0x40000000 || (val&0xc0000000)==0x80000000) return val^0x40000000; + return val; +} + +inline bool enBit30(const int val) { + if ((val&0xc0000000)==0x40000000 || (val&0xc0000000)==0x80000000) return true; + return false; +} + void FurnaceGUI::drawMacros(std::vector& macros) { float asFloat[256]; int asInt[256]; float loopIndicator[256]; + float bit30Indicator[256]; + bool doHighlight[256]; int index=0; float reservedSpace=(settings.oldMacroVSlider)?(20.0f*dpiScale+ImGui::GetStyle().ItemSpacing.x):ImGui::GetStyle().ScrollbarSize; @@ -1176,14 +1231,14 @@ void FurnaceGUI::drawMacros(std::vector& macros) { } ImGui::TableNextColumn(); float availableWidth=ImGui::GetContentRegionAvail().x-reservedSpace; - int totalFit=MIN(128,availableWidth/MAX(1,macroPointSize*dpiScale)); - if (macroDragScroll>128-totalFit) { - macroDragScroll=128-totalFit; + int totalFit=MIN(255,availableWidth/MAX(1,macroPointSize*dpiScale)); + if (macroDragScroll>255-totalFit) { + macroDragScroll=255-totalFit; } ImGui::SetNextItemWidth(availableWidth); - if (CWSliderInt("##MacroScroll",¯oDragScroll,0,128-totalFit,"")) { + if (CWSliderInt("##MacroScroll",¯oDragScroll,0,255-totalFit,"")) { if (macroDragScroll<0) macroDragScroll=0; - if (macroDragScroll>128-totalFit) macroDragScroll=128-totalFit; + if (macroDragScroll>255-totalFit) macroDragScroll=255-totalFit; } // draw macros @@ -1200,9 +1255,36 @@ void FurnaceGUI::drawMacros(std::vector& macros) { } if (i.macro->open) { ImGui::SetNextItemWidth(lenAvail); - if (ImGui::InputScalar("##IMacroLen",ImGuiDataType_U8,&i.macro->len,&_ONE,&_THREE)) { MARK_MODIFIED - if (i.macro->len>128) i.macro->len=128; + int macroLen=i.macro->len; + if (ImGui::InputScalar("##IMacroLen",ImGuiDataType_U8,¯oLen,&_ONE,&_THREE)) { MARK_MODIFIED + if (macroLen<0) macroLen=0; + if (macroLen>255) macroLen=255; + i.macro->len=macroLen; } + if (ImGui::Button(ICON_FA_BAR_CHART "##IMacroType")) { + + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("Coming soon!"); + } + ImGui::SameLine(); + ImGui::Button(ICON_FA_ELLIPSIS_H "##IMacroSet"); + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("Delay/Step Length"); + } + if (ImGui::BeginPopupContextItem("IMacroSetP",ImGuiPopupFlags_MouseButtonLeft)) { + if (ImGui::InputScalar("Step Length (ticks)##IMacroSpeed",ImGuiDataType_U8,&i.macro->speed,&_ONE,&_THREE)) { + if (i.macro->speed<1) i.macro->speed=1; + MARK_MODIFIED; + } + if (ImGui::InputScalar("Delay##IMacroDelay",ImGuiDataType_U8,&i.macro->delay,&_ONE,&_THREE)) { + MARK_MODIFIED; + } + ImGui::EndPopup(); + } + // do not change this! + // anything other than a checkbox will look ugly! + // if you really need more than two macro modes please tell me. if (i.modeName!=NULL) { bool modeVal=i.macro->mode; String modeName=fmt::sprintf("%s##IMacroMode",i.modeName); @@ -1215,17 +1297,19 @@ void FurnaceGUI::drawMacros(std::vector& macros) { // macro area ImGui::TableNextColumn(); for (int j=0; j<256; j++) { + bit30Indicator[j]=0; if (j+macroDragScroll>=i.macro->len) { asFloat[j]=0; asInt[j]=0; } else { - asFloat[j]=i.macro->val[j+macroDragScroll]; - asInt[j]=i.macro->val[j+macroDragScroll]+i.bitOffset; + asFloat[j]=deBit30(i.macro->val[j+macroDragScroll]); + asInt[j]=deBit30(i.macro->val[j+macroDragScroll])+i.bitOffset; + if (i.bit30) bit30Indicator[j]=enBit30(i.macro->val[j+macroDragScroll]); } if (j+macroDragScroll>=i.macro->len || (j+macroDragScroll>i.macro->rel && i.macro->looprel)) { loopIndicator[j]=0; } else { - loopIndicator[j]=((i.macro->loop!=-1 && (j+macroDragScroll)>=i.macro->loop))|((i.macro->rel!=-1 && (j+macroDragScroll)==i.macro->rel)<<1); + loopIndicator[j]=((i.macro->loop!=255 && (j+macroDragScroll)>=i.macro->loop))|((i.macro->rel!=255 && (j+macroDragScroll)==i.macro->rel)<<1); } } ImGui::PushStyleVar(ImGuiStyleVar_FramePadding,ImVec2(0.0f,0.0f)); @@ -1245,11 +1329,33 @@ void FurnaceGUI::drawMacros(std::vector& macros) { if (i.macro->vZoom>(i.max-i.min)) { i.macro->vZoom=i.max-i.min; } - + + memset(doHighlight,0,256*sizeof(bool)); + if (e->isRunning()) for (int j=0; jgetTotalChannelCount(); j++) { + DivChannelState* chanState=e->getChanState(j); + if (chanState==NULL) continue; + + if (chanState->keyOff) continue; + if (chanState->lastIns!=curIns) continue; + + DivMacroInt* macroInt=e->getMacroInt(j); + if (macroInt==NULL) continue; + + DivMacroStruct* macroStruct=macroInt->structByName(i.macro->name); + if (macroStruct==NULL) continue; + + if (macroStruct->lastPos>i.macro->len) continue; + if (macroStruct->lastPoslastPos>255) continue; + if (!macroStruct->actualHad) continue; + + doHighlight[macroStruct->lastPos-macroDragScroll]=true; + } + if (i.isBitfield) { - PlotBitfield("##IMacro",asInt,totalFit,0,i.bitfieldBits,i.max,ImVec2(availableWidth,(i.macro->open)?(i.height*dpiScale):(32.0f*dpiScale))); + PlotBitfield("##IMacro",asInt,totalFit,0,i.bitfieldBits,i.max,ImVec2(availableWidth,(i.macro->open)?(i.height*dpiScale):(32.0f*dpiScale)),sizeof(float),doHighlight); } else { - PlotCustom("##IMacro",asFloat,totalFit,macroDragScroll,NULL,i.min+i.macro->vScroll,i.min+i.macro->vScroll+i.macro->vZoom,ImVec2(availableWidth,(i.macro->open)?(i.height*dpiScale):(32.0f*dpiScale)),sizeof(float),i.color,i.macro->len-macroDragScroll,i.hoverFunc,i.blockMode,i.macro->open?genericGuide:NULL); + PlotCustom("##IMacro",asFloat,totalFit,macroDragScroll,NULL,i.min+i.macro->vScroll,i.min+i.macro->vScroll+i.macro->vZoom,ImVec2(availableWidth,(i.macro->open)?(i.height*dpiScale):(32.0f*dpiScale)),sizeof(float),i.color,i.macro->len-macroDragScroll,i.hoverFunc,i.blockMode,i.macro->open?genericGuide:NULL,doHighlight); } if (i.macro->open && (ImGui::IsItemClicked(ImGuiMouseButton_Left) || ImGui::IsItemClicked(ImGuiMouseButton_Right))) { macroDragStart=ImGui::GetItemRectMin(); @@ -1267,6 +1373,8 @@ void FurnaceGUI::drawMacros(std::vector& macros) { macroDragInitialValue=false; macroDragLen=totalFit; macroDragActive=true; + macroDragBit30=i.bit30; + macroDragSettingBit30=false; macroDragTarget=i.macro->val; macroDragChar=false; macroDragLineMode=(i.isBitfield)?false:ImGui::IsItemClicked(ImGuiMouseButton_Right); @@ -1334,6 +1442,27 @@ void FurnaceGUI::drawMacros(std::vector& macros) { } } + // bit 30 area + if (i.bit30) { + PlotCustom("##IMacroBit30",bit30Indicator,totalFit,macroDragScroll,NULL,0,1,ImVec2(availableWidth,12.0f*dpiScale),sizeof(float),i.color,i.macro->len-macroDragScroll,¯oHoverBit30); + if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) { + macroDragStart=ImGui::GetItemRectMin(); + macroDragAreaSize=ImVec2(availableWidth,12.0f*dpiScale); + macroDragInitialValueSet=false; + macroDragInitialValue=false; + macroDragLen=totalFit; + macroDragActive=true; + macroDragBit30=i.bit30; + macroDragSettingBit30=true; + macroDragTarget=i.macro->val; + macroDragChar=false; + macroDragLineMode=false; + macroDragLineInitial=ImVec2(0,0); + lastMacroDesc=i; + processDrags(ImGui::GetMousePos().x,ImGui::GetMousePos().y); + } + } + // loop area PlotCustom("##IMacroLoop",loopIndicator,totalFit,macroDragScroll,NULL,0,2,ImVec2(availableWidth,12.0f*dpiScale),sizeof(float),i.color,i.macro->len-macroDragScroll,¯oHoverLoop); if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) { @@ -1350,18 +1479,18 @@ void FurnaceGUI::drawMacros(std::vector& macros) { } if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) { if (ImGui::IsKeyDown(ImGuiKey_LeftShift) || ImGui::IsKeyDown(ImGuiKey_RightShift)) { - i.macro->rel=-1; + i.macro->rel=255; } else { - i.macro->loop=-1; + i.macro->loop=255; } } ImGui::SetNextItemWidth(availableWidth); String& mmlStr=mmlString[index]; if (ImGui::InputText("##IMacroMML",&mmlStr)) { - decodeMMLStr(mmlStr,i.macro->val,i.macro->len,i.macro->loop,i.min,(i.isBitfield)?((1<<(i.isBitfield?i.max:0))-1):i.max,i.macro->rel); + decodeMMLStr(mmlStr,i.macro->val,i.macro->len,i.macro->loop,i.min,(i.isBitfield)?((1<<(i.isBitfield?i.max:0))-1):i.max,i.macro->rel,i.bit30); } if (!ImGui::IsItemActive()) { - encodeMMLStr(mmlStr,i.macro->val,i.macro->len,i.macro->loop,i.macro->rel); + encodeMMLStr(mmlStr,i.macro->val,i.macro->len,i.macro->loop,i.macro->rel,false,i.bit30); } } ImGui::PopStyleVar(); @@ -1373,9 +1502,9 @@ void FurnaceGUI::drawMacros(std::vector& macros) { ImGui::TableNextColumn(); ImGui::TableNextColumn(); ImGui::SetNextItemWidth(availableWidth); - if (CWSliderInt("##MacroScroll",¯oDragScroll,0,128-totalFit,"")) { + if (CWSliderInt("##MacroScroll",¯oDragScroll,0,255-totalFit,"")) { if (macroDragScroll<0) macroDragScroll=0; - if (macroDragScroll>128-totalFit) macroDragScroll=128-totalFit; + if (macroDragScroll>255-totalFit) macroDragScroll=255-totalFit; } ImGui::EndTable(); } @@ -2969,24 +3098,60 @@ void FurnaceGUI::drawInsEdit() { P(ImGui::Checkbox("Initialize envelope on every note",&ins->gb.alwaysInit)); ImGui::BeginDisabled(ins->gb.softEnv); - P(CWSliderScalar("Volume",ImGuiDataType_U8,&ins->gb.envVol,&_ZERO,&_FIFTEEN)); rightClickable - P(CWSliderScalar("Envelope Length",ImGuiDataType_U8,&ins->gb.envLen,&_ZERO,&_SEVEN)); rightClickable - P(CWSliderScalar("Sound Length",ImGuiDataType_U8,&ins->gb.soundLen,&_ZERO,&_SIXTY_FOUR,ins->gb.soundLen>63?"Infinity":"%d")); rightClickable - ImGui::Text("Envelope Direction:"); + if (ImGui::BeginTable("GBParams",2)) { + ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthStretch,0.6f); + ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthStretch,0.4f); - bool goesUp=ins->gb.envDir; - ImGui::SameLine(); - if (ImGui::RadioButton("Up",goesUp)) { PARAMETER - goesUp=true; - ins->gb.envDir=goesUp; - } - ImGui::SameLine(); - if (ImGui::RadioButton("Down",!goesUp)) { PARAMETER - goesUp=false; - ins->gb.envDir=goesUp; - } + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + if (ImGui::BeginTable("GBParamsI",2)) { + ImGui::TableSetupColumn("ci0",ImGuiTableColumnFlags_WidthFixed); + ImGui::TableSetupColumn("ci1",ImGuiTableColumnFlags_WidthStretch); - drawGBEnv(ins->gb.envVol,ins->gb.envLen,ins->gb.soundLen,ins->gb.envDir,ImVec2(ImGui::GetContentRegionAvail().x,100.0f*dpiScale)); + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::Text("Volume"); + ImGui::TableNextColumn(); + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + P(CWSliderScalar("##GBVolume",ImGuiDataType_U8,&ins->gb.envVol,&_ZERO,&_FIFTEEN)); rightClickable + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::Text("Length"); + ImGui::TableNextColumn(); + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + P(CWSliderScalar("##GBEnvLen",ImGuiDataType_U8,&ins->gb.envLen,&_ZERO,&_SEVEN)); rightClickable + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::Text("Sound Length"); + ImGui::TableNextColumn(); + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + P(CWSliderScalar("##GBSoundLen",ImGuiDataType_U8,&ins->gb.soundLen,&_ZERO,&_SIXTY_FOUR,ins->gb.soundLen>63?"Infinity":"%d")); rightClickable + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::Text("Direction"); + ImGui::TableNextColumn(); + bool goesUp=ins->gb.envDir; + if (ImGui::RadioButton("Up",goesUp)) { PARAMETER + goesUp=true; + ins->gb.envDir=goesUp; + } + ImGui::SameLine(); + if (ImGui::RadioButton("Down",!goesUp)) { PARAMETER + goesUp=false; + ins->gb.envDir=goesUp; + } + + ImGui::EndTable(); + } + + ImGui::TableNextColumn(); + drawGBEnv(ins->gb.envVol,ins->gb.envLen,ins->gb.soundLen,ins->gb.envDir,ImVec2(ImGui::GetContentRegionAvail().x,100.0f*dpiScale)); + + ImGui::EndTable(); + } if (ImGui::BeginChild("HWSeq",ImGui::GetContentRegionAvail(),true,ImGuiWindowFlags_MenuBar)) { ImGui::BeginMenuBar(); @@ -3142,13 +3307,13 @@ void FurnaceGUI::drawInsEdit() { if (ImGui::Button(ICON_FA_CHEVRON_DOWN "##HWCmdDown")) { if (igb.hwSeqLen-1) { e->lockEngine([ins,i]() { - ins->gb.hwSeq[i-1].cmd^=ins->gb.hwSeq[i].cmd; - ins->gb.hwSeq[i].cmd^=ins->gb.hwSeq[i-1].cmd; - ins->gb.hwSeq[i-1].cmd^=ins->gb.hwSeq[i].cmd; + ins->gb.hwSeq[i+1].cmd^=ins->gb.hwSeq[i].cmd; + ins->gb.hwSeq[i].cmd^=ins->gb.hwSeq[i+1].cmd; + ins->gb.hwSeq[i+1].cmd^=ins->gb.hwSeq[i].cmd; - ins->gb.hwSeq[i-1].data^=ins->gb.hwSeq[i].data; - ins->gb.hwSeq[i].data^=ins->gb.hwSeq[i-1].data; - ins->gb.hwSeq[i-1].data^=ins->gb.hwSeq[i].data; + ins->gb.hwSeq[i+1].data^=ins->gb.hwSeq[i].data; + ins->gb.hwSeq[i].data^=ins->gb.hwSeq[i+1].data; + ins->gb.hwSeq[i+1].data^=ins->gb.hwSeq[i].data; }); } MARK_MODIFIED; @@ -3295,7 +3460,10 @@ void FurnaceGUI::drawInsEdit() { P(ImGui::Checkbox("Don't test/gate before new note",&ins->c64.noTest)); ImGui::EndTabItem(); } - if (ins->type==DIV_INS_AMIGA || ins->type==DIV_INS_SU) if (ImGui::BeginTabItem((ins->type==DIV_INS_SU)?"Sound Unit":"Sample")) { + if (ins->type==DIV_INS_AMIGA || + ins->type==DIV_INS_SU || + ins->type==DIV_INS_SNES || + ins->type==DIV_INS_ES5506) if (ImGui::BeginTabItem((ins->type==DIV_INS_SU)?"Sound Unit":"Sample")) { String sName; if (ins->amiga.initSample<0 || ins->amiga.initSample>=e->song.sampleLen) { sName="none selected"; @@ -3452,6 +3620,42 @@ void FurnaceGUI::drawInsEdit() { } ImGui::EndTabItem(); } + if (ins->type==DIV_INS_ES5506) if (ImGui::BeginTabItem("ES5506")) { + if (ImGui::BeginTable("ESParams",2,ImGuiTableFlags_SizingStretchSame)) { + ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthStretch,0.0); + ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthStretch,0.0); + // filter + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWSliderScalar("Filter 4,3 Mode",ImGuiDataType_U8,&ins->es5506.filter.mode,&_ZERO,&_THREE,es5506FilterModes[ins->es5506.filter.mode&3])); rightClickable + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWSliderScalar("Filter K1",ImGuiDataType_U16,&ins->es5506.filter.k1,&_ZERO,&_SIXTY_FIVE_THOUSAND_FIVE_HUNDRED_THIRTY_FIVE)); rightClickable + ImGui::TableNextColumn(); + P(CWSliderScalar("Filter K2",ImGuiDataType_U16,&ins->es5506.filter.k2,&_ZERO,&_SIXTY_FIVE_THOUSAND_FIVE_HUNDRED_THIRTY_FIVE)); rightClickable + // envelope + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWSliderScalar("Envelope count",ImGuiDataType_U16,&ins->es5506.envelope.ecount,&_ZERO,&_FIVE_HUNDRED_ELEVEN)); rightClickable + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWSliderScalar("Left Volume Ramp",ImGuiDataType_S8,&ins->es5506.envelope.lVRamp,&_MINUS_ONE_HUNDRED_TWENTY_EIGHT,&_ONE_HUNDRED_TWENTY_SEVEN)); rightClickable + ImGui::TableNextColumn(); + P(CWSliderScalar("Right Volume Ramp",ImGuiDataType_S8,&ins->es5506.envelope.rVRamp,&_MINUS_ONE_HUNDRED_TWENTY_EIGHT,&_ONE_HUNDRED_TWENTY_SEVEN)); rightClickable + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWSliderScalar("Filter K1 Ramp",ImGuiDataType_S8,&ins->es5506.envelope.k1Ramp,&_MINUS_ONE_HUNDRED_TWENTY_EIGHT,&_ONE_HUNDRED_TWENTY_SEVEN)); rightClickable + ImGui::TableNextColumn(); + P(CWSliderScalar("Filter K2 Ramp",ImGuiDataType_S8,&ins->es5506.envelope.k2Ramp,&_MINUS_ONE_HUNDRED_TWENTY_EIGHT,&_ONE_HUNDRED_TWENTY_SEVEN)); rightClickable + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::Checkbox("K1 Ramp Slowdown",&ins->es5506.envelope.k1Slow); + ImGui::TableNextColumn(); + ImGui::Checkbox("K2 Ramp Slowdown",&ins->es5506.envelope.k2Slow); + ImGui::EndTable(); + } + ImGui::EndTabItem(); + } if (ins->type==DIV_INS_MULTIPCM) { if (ImGui::BeginTabItem("MultiPCM")) { String sName; @@ -3554,6 +3758,101 @@ void FurnaceGUI::drawInsEdit() { ImGui::EndTabItem(); } } + if (ins->type==DIV_INS_SNES) if (ImGui::BeginTabItem("SNES")) { + P(ImGui::Checkbox("Use envelope",&ins->snes.useEnv)); + ImVec2 sliderSize=ImVec2(20.0f*dpiScale,128.0*dpiScale); + if (ins->snes.useEnv) { + if (ImGui::BeginTable("SNESEnvParams",5,ImGuiTableFlags_NoHostExtendX)) { + ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthFixed,sliderSize.x); + ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthFixed,sliderSize.x); + ImGui::TableSetupColumn("c2",ImGuiTableColumnFlags_WidthFixed,sliderSize.x); + ImGui::TableSetupColumn("c3",ImGuiTableColumnFlags_WidthFixed,sliderSize.x); + ImGui::TableSetupColumn("c4",ImGuiTableColumnFlags_WidthStretch); + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + CENTER_TEXT("A"); + ImGui::TextUnformatted("A"); + ImGui::TableNextColumn(); + CENTER_TEXT("D"); + ImGui::TextUnformatted("D"); + ImGui::TableNextColumn(); + CENTER_TEXT("S"); + ImGui::TextUnformatted("S"); + ImGui::TableNextColumn(); + CENTER_TEXT("R"); + ImGui::TextUnformatted("R"); + ImGui::TableNextColumn(); + CENTER_TEXT("Envelope"); + ImGui::TextUnformatted("Envelope"); + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + P(CWVSliderScalar("##Attack",sliderSize,ImGuiDataType_U8,&ins->snes.a,&_ZERO,&_FIFTEEN)); + ImGui::TableNextColumn(); + P(CWVSliderScalar("##Decay",sliderSize,ImGuiDataType_U8,&ins->snes.d,&_ZERO,&_SEVEN)); + ImGui::TableNextColumn(); + P(CWVSliderScalar("##Sustain",sliderSize,ImGuiDataType_U8,&ins->snes.s,&_ZERO,&_SEVEN)); + ImGui::TableNextColumn(); + P(CWVSliderScalar("##Release",sliderSize,ImGuiDataType_U8,&ins->snes.r,&_ZERO,&_THIRTY_ONE)); + ImGui::TableNextColumn(); + drawFMEnv(0,ins->snes.a+1,1+ins->snes.d*2,ins->snes.r,ins->snes.r,(14-ins->snes.s*2),(ins->snes.r==0),0,0,7,16,ImVec2(ImGui::GetContentRegionAvail().x,sliderSize.y),ins->type); + + ImGui::EndTable(); + } + } else { + if (ImGui::BeginTable("SNESGainParams",3,ImGuiTableFlags_NoHostExtendX)) { + ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthFixed); + ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthFixed,sliderSize.x); + ImGui::TableSetupColumn("c2",ImGuiTableColumnFlags_WidthStretch); + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + CENTER_TEXT("Gain Mode"); + ImGui::TextUnformatted("Gain Mode"); + ImGui::TableNextColumn(); + CENTER_TEXT("Gain"); + ImGui::TextUnformatted("Gain"); + ImGui::TableNextColumn(); + CENTER_TEXT("Envelope"); + ImGui::TextUnformatted("Envelope"); + + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + if (ImGui::RadioButton("Direct",ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_DIRECT)) { + ins->snes.gainMode=DivInstrumentSNES::GAIN_MODE_DIRECT; + PARAMETER; + } + if (ImGui::RadioButton("Decrease (linear)",ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_DEC_LINEAR)) { + ins->snes.gainMode=DivInstrumentSNES::GAIN_MODE_DEC_LINEAR; + PARAMETER; + } + if (ImGui::RadioButton("Decrease (logarithmic)",ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_DEC_LOG)) { + ins->snes.gainMode=DivInstrumentSNES::GAIN_MODE_DEC_LOG; + PARAMETER; + } + if (ImGui::RadioButton("Increase (linear)",ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_INC_LINEAR)) { + ins->snes.gainMode=DivInstrumentSNES::GAIN_MODE_INC_LINEAR; + PARAMETER; + } + if (ImGui::RadioButton("Increase (bent line)",ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_INC_INVLOG)) { + ins->snes.gainMode=DivInstrumentSNES::GAIN_MODE_INC_INVLOG; + PARAMETER; + } + + ImGui::TableNextColumn(); + unsigned char gainMax=(ins->snes.gainMode==DivInstrumentSNES::GAIN_MODE_DIRECT)?127:31; + if (ins->snes.gain>gainMax) ins->snes.gain=gainMax; + P(CWVSliderScalar("##Gain",sliderSize,ImGuiDataType_U8,&ins->snes.gain,&_ZERO,&gainMax)); + + ImGui::TableNextColumn(); + ImGui::Text("Envelope goes here..."); + + ImGui::EndTable(); + } + } + ImGui::EndTabItem(); + } if (ins->type==DIV_INS_GB || (ins->type==DIV_INS_AMIGA && ins->amiga.useWave) || ins->type==DIV_INS_X1_010 || @@ -3562,6 +3861,7 @@ void FurnaceGUI::drawInsEdit() { ins->type==DIV_INS_SWAN || ins->type==DIV_INS_PCE || ins->type==DIV_INS_SCC || + ins->type==DIV_INS_SNES || ins->type==DIV_INS_NAMCO) { if (ImGui::BeginTabItem("Wavetable")) { if (ImGui::Checkbox("Enable synthesizer",&ins->ws.enabled)) { @@ -3749,6 +4049,9 @@ void FurnaceGUI::drawInsEdit() { if (ins->type==DIV_INS_FDS) { volMax=32; } + if (ins->type==DIV_INS_ES5506) { + volMax=65535; + } const char* dutyLabel="Duty/Noise"; int dutyMin=0; @@ -3811,6 +4114,10 @@ void FurnaceGUI::drawInsEdit() { if (ins->type==DIV_INS_SU) { dutyMax=127; } + if (ins->type==DIV_INS_ES5506) { + dutyLabel="Filter Mode"; + dutyMax=3; + } const char* waveLabel="Waveform"; int waveMax=(ins->type==DIV_INS_AY || ins->type==DIV_INS_AY8930 || ins->type==DIV_INS_VERA)?3:255; @@ -3866,6 +4173,10 @@ void FurnaceGUI::drawInsEdit() { ex2Max=255; } if (ins->type==DIV_INS_SAA1099) ex1Max=8; + if (ins->type==DIV_INS_ES5506) { + ex1Max=65535; + ex2Max=65535; + } int panMin=0; int panMax=0; @@ -3901,14 +4212,19 @@ void FurnaceGUI::drawInsEdit() { panMax=127; panSingleNoBit=true; } + if (ins->type==DIV_INS_ES5506) { + panMax=65535; + } if (volMax>0) { macroList.push_back(FurnaceGUIMacroDesc(volumeLabel,&ins->std.volMacro,volMin,volMax,160,uiColors[GUI_COLOR_MACRO_VOLUME])); } - macroList.push_back(FurnaceGUIMacroDesc("Arpeggio",&ins->std.arpMacro,-120,120,160,uiColors[GUI_COLOR_MACRO_PITCH],true,macroAbsoluteMode,ins->std.arpMacro.mode?(¯oHoverNote):NULL)); + macroList.push_back(FurnaceGUIMacroDesc("Arpeggio",&ins->std.arpMacro,-120,120,160,uiColors[GUI_COLOR_MACRO_PITCH],true,NULL,NULL,false,NULL,0,true)); if (dutyMax>0) { if (ins->type==DIV_INS_MIKEY) { macroList.push_back(FurnaceGUIMacroDesc(dutyLabel,&ins->std.dutyMacro,0,dutyMax,160,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true,mikeyFeedbackBits)); + } else if (ins->type==DIV_INS_ES5506) { + macroList.push_back(FurnaceGUIMacroDesc(dutyLabel,&ins->std.dutyMacro,dutyMin,dutyMax,160,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,¯oHoverES5506FilterMode)); } else { macroList.push_back(FurnaceGUIMacroDesc(dutyLabel,&ins->std.dutyMacro,dutyMin,dutyMax,160,uiColors[GUI_COLOR_MACRO_OTHER])); } @@ -3921,15 +4237,15 @@ void FurnaceGUI::drawInsEdit() { macroList.push_back(FurnaceGUIMacroDesc("Panning",&ins->std.panLMacro,0,2,32,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true,panBits)); } else { if (panSingleNoBit || (ins->type==DIV_INS_AMIGA && ins->std.panLMacro.mode)) { - macroList.push_back(FurnaceGUIMacroDesc("Panning",&ins->std.panLMacro,panMin,panMax,(31+panMax-panMin),uiColors[GUI_COLOR_MACRO_OTHER],false,(ins->type==DIV_INS_AMIGA)?macroQSoundMode:NULL)); + macroList.push_back(FurnaceGUIMacroDesc("Panning",&ins->std.panLMacro,panMin,panMax,CLAMP(31+panMax-panMin,32,160),uiColors[GUI_COLOR_MACRO_OTHER],false,(ins->type==DIV_INS_AMIGA)?macroQSoundMode:NULL)); } else { - macroList.push_back(FurnaceGUIMacroDesc("Panning (left)",&ins->std.panLMacro,panMin,panMax,(31+panMax-panMin),uiColors[GUI_COLOR_MACRO_OTHER],false,(ins->type==DIV_INS_AMIGA)?macroQSoundMode:NULL)); + macroList.push_back(FurnaceGUIMacroDesc("Panning (left)",&ins->std.panLMacro,panMin,panMax,CLAMP(31+panMax-panMin,32,160),uiColors[GUI_COLOR_MACRO_OTHER],false,(ins->type==DIV_INS_AMIGA)?macroQSoundMode:NULL)); } if (!panSingleNoBit) { if (ins->type==DIV_INS_AMIGA && ins->std.panLMacro.mode) { macroList.push_back(FurnaceGUIMacroDesc("Surround",&ins->std.panRMacro,0,1,32,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true)); } else { - macroList.push_back(FurnaceGUIMacroDesc("Panning (right)",&ins->std.panRMacro,panMin,panMax,(31+panMax-panMin),uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Panning (right)",&ins->std.panRMacro,panMin,panMax,CLAMP(31+panMax-panMin,32,160),uiColors[GUI_COLOR_MACRO_OTHER])); } } } @@ -3949,7 +4265,8 @@ void FurnaceGUI::drawInsEdit() { ins->type==DIV_INS_SWAN || ins->type==DIV_INS_MULTIPCM || ins->type==DIV_INS_SU || - ins->type==DIV_INS_MIKEY) { + ins->type==DIV_INS_MIKEY || + ins->type==DIV_INS_ES5506) { macroList.push_back(FurnaceGUIMacroDesc("Phase Reset",&ins->std.phaseResetMacro,0,1,32,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true)); } if (ex1Max>0) { @@ -3965,6 +4282,8 @@ void FurnaceGUI::drawInsEdit() { macroList.push_back(FurnaceGUIMacroDesc("Mod Depth",&ins->std.ex1Macro,0,ex1Max,160,uiColors[GUI_COLOR_MACRO_OTHER])); } else if (ins->type==DIV_INS_SU) { macroList.push_back(FurnaceGUIMacroDesc("Cutoff",&ins->std.ex1Macro,0,ex1Max,160,uiColors[GUI_COLOR_MACRO_OTHER])); + } else if (ins->type==DIV_INS_ES5506) { + macroList.push_back(FurnaceGUIMacroDesc("Filter K1",&ins->std.ex1Macro,((ins->std.ex1Macro.mode==1)?(-ex1Max):0),ex1Max,160,uiColors[GUI_COLOR_MACRO_OTHER],false,macroRelativeMode)); } else { macroList.push_back(FurnaceGUIMacroDesc("Duty",&ins->std.ex1Macro,0,ex1Max,160,uiColors[GUI_COLOR_MACRO_OTHER])); } @@ -3978,6 +4297,8 @@ void FurnaceGUI::drawInsEdit() { macroList.push_back(FurnaceGUIMacroDesc("Mod Speed",&ins->std.ex2Macro,0,ex2Max,160,uiColors[GUI_COLOR_MACRO_OTHER])); } else if (ins->type==DIV_INS_SU) { macroList.push_back(FurnaceGUIMacroDesc("Resonance",&ins->std.ex2Macro,0,ex2Max,160,uiColors[GUI_COLOR_MACRO_OTHER])); + } else if (ins->type==DIV_INS_ES5506) { + macroList.push_back(FurnaceGUIMacroDesc("Filter K2",&ins->std.ex2Macro,((ins->std.ex2Macro.mode==1)?(-ex2Max):0),ex2Max,160,uiColors[GUI_COLOR_MACRO_OTHER],false,macroRelativeMode)); } else { macroList.push_back(FurnaceGUIMacroDesc("Envelope",&ins->std.ex2Macro,0,ex2Max,ex2Bit?64:160,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,ex2Bit,ayEnvBits)); } @@ -4008,6 +4329,15 @@ void FurnaceGUI::drawInsEdit() { macroList.push_back(FurnaceGUIMacroDesc("Control",&ins->std.ex3Macro,0,4,64,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true,suControlBits)); macroList.push_back(FurnaceGUIMacroDesc("Phase Reset Timer",&ins->std.ex4Macro,0,65535,160,uiColors[GUI_COLOR_MACRO_OTHER])); // again reuse code from resonance macro but use ex4 instead } + if (ins->type==DIV_INS_ES5506) { + macroList.push_back(FurnaceGUIMacroDesc("Envelope counter",&ins->std.ex3Macro,0,511,160,uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Envelope left volume ramp",&ins->std.ex4Macro,-128,127,160,uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Envelope right volume ramp",&ins->std.ex5Macro,-128,127,160,uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Envelope K1 ramp",&ins->std.ex6Macro,-128,127,160,uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Envelope K2 ramp",&ins->std.ex7Macro,-128,127,160,uiColors[GUI_COLOR_MACRO_OTHER])); + macroList.push_back(FurnaceGUIMacroDesc("Envelope mode",&ins->std.ex8Macro,0,2,64,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true,es5506EnvelopeModes)); + macroList.push_back(FurnaceGUIMacroDesc("Control",&ins->std.algMacro,0,1,32,uiColors[GUI_COLOR_MACRO_OTHER],false,NULL,NULL,true,es5506ControlModes)); + } drawMacros(macroList); ImGui::EndTabItem(); @@ -4046,8 +4376,8 @@ void FurnaceGUI::drawInsEdit() { ImGui::Separator(); if (ImGui::MenuItem("clear")) { lastMacroDesc.macro->len=0; - lastMacroDesc.macro->loop=-1; - lastMacroDesc.macro->rel=-1; + lastMacroDesc.macro->loop=255; + lastMacroDesc.macro->rel=255; for (int i=0; i<256; i++) { lastMacroDesc.macro->val[i]=0; } @@ -4076,15 +4406,15 @@ void FurnaceGUI::drawInsEdit() { lastMacroDesc.macro->val[i]=val; } - if (lastMacroDesc.macro->loop>=0 && lastMacroDesc.macro->looplen) { + if (lastMacroDesc.macro->looplen) { lastMacroDesc.macro->loop+=macroOffX; } else { - lastMacroDesc.macro->loop=-1; + lastMacroDesc.macro->loop=255; } if ((lastMacroDesc.macro->rel+macroOffX)>=0 && (lastMacroDesc.macro->rel+macroOffX)len) { lastMacroDesc.macro->rel+=macroOffX; } else { - lastMacroDesc.macro->rel=-1; + lastMacroDesc.macro->rel=255; } ImGui::CloseCurrentPopup(); diff --git a/src/gui/intConst.cpp b/src/gui/intConst.cpp index 8bee0f88c..9a41486e1 100644 --- a/src/gui/intConst.cpp +++ b/src/gui/intConst.cpp @@ -31,6 +31,9 @@ const int _SIXTY_FOUR=64; const int _ONE_HUNDRED=100; const int _ONE_HUNDRED_TWENTY_SEVEN=127; const int _TWO_HUNDRED_FIFTY_FIVE=255; +const int _FIVE_HUNDRED_ELEVEN=511; const int _TWO_THOUSAND_FORTY_SEVEN=2047; const int _FOUR_THOUSAND_NINETY_FIVE=4095; +const int _SIXTY_FIVE_THOUSAND_FIVE_HUNDRED_THIRTY_FIVE=65535; const int _MINUS_ONE_HUNDRED_TWENTY_SEVEN=-127; +const int _MINUS_ONE_HUNDRED_TWENTY_EIGHT=-128; diff --git a/src/gui/intConst.h b/src/gui/intConst.h index 98c6c34ff..ff11a4968 100644 --- a/src/gui/intConst.h +++ b/src/gui/intConst.h @@ -33,6 +33,9 @@ extern const int _SIXTY_FOUR; extern const int _ONE_HUNDRED; extern const int _ONE_HUNDRED_TWENTY_SEVEN; extern const int _TWO_HUNDRED_FIFTY_FIVE; +extern const int _FIVE_HUNDRED_ELEVEN; extern const int _TWO_THOUSAND_FORTY_SEVEN; extern const int _FOUR_THOUSAND_NINETY_FIVE; +extern const int _SIXTY_FIVE_THOUSAND_FIVE_HUNDRED_THIRTY_FIVE; extern const int _MINUS_ONE_HUNDRED_TWENTY_SEVEN; +extern const int _MINUS_ONE_HUNDRED_TWENTY_EIGHT; diff --git a/src/gui/newSong.cpp b/src/gui/newSong.cpp index 26fddf9fb..c819ffd3a 100644 --- a/src/gui/newSong.cpp +++ b/src/gui/newSong.cpp @@ -18,7 +18,8 @@ */ #include "gui.h" -#include +#include "misc/cpp/imgui_stdlib.h" +#include void FurnaceGUI::drawNewSong() { bool accepted=false; @@ -32,35 +33,76 @@ void FurnaceGUI::drawNewSong() { avail.y-=ImGui::GetFrameHeightWithSpacing(); if (ImGui::BeginChild("sysPickerC",avail,false,ImGuiWindowFlags_NoScrollWithMouse|ImGuiWindowFlags_NoScrollbar)) { - if (ImGui::BeginTable("sysPicker",2,ImGuiTableFlags_BordersInnerV)) { - ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthFixed,0.0f); + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + if (ImGui::InputTextWithHint("##SysSearch","Search...",&newSongQuery)) { + String lowerCase=newSongQuery; + for (char& i: lowerCase) { + if (i>='A' && i<='Z') i+='a'-'A'; + } + auto lastItem=std::remove_if(lowerCase.begin(),lowerCase.end(),[](char c) { + return (c==' ' || c=='_' || c=='-'); + }); + lowerCase.erase(lastItem,lowerCase.end()); + newSongSearchResults.clear(); + for (FurnaceGUISysCategory& i: sysCategories) { + for (FurnaceGUISysDef& j: i.systems) { + String lowerCase1=j.name; + for (char& i: lowerCase1) { + if (i>='A' && i<='Z') i+='a'-'A'; + } + auto lastItem=std::remove_if(lowerCase1.begin(),lowerCase1.end(),[](char c) { + return (c==' ' || c=='_' || c=='-'); + }); + lowerCase1.erase(lastItem,lowerCase1.end()); + if (lowerCase1.find(lowerCase)!=String::npos) { + newSongSearchResults.push_back(j); + } + } + std::sort(newSongSearchResults.begin(),newSongSearchResults.end(),[](const FurnaceGUISysDef& a, const FurnaceGUISysDef& b) { + return strcmp(a.name,b.name)<0; + }); + auto lastItem=std::unique(newSongSearchResults.begin(),newSongSearchResults.end(),[](const FurnaceGUISysDef& a, const FurnaceGUISysDef& b) { + return strcmp(a.name,b.name)==0; + }); + newSongSearchResults.erase(lastItem,newSongSearchResults.end()); + } + } + if (ImGui::BeginTable("sysPicker",newSongQuery.empty()?2:1,ImGuiTableFlags_BordersInnerV)) { + if (newSongQuery.empty()) { + ImGui::TableSetupColumn("c0",ImGuiTableColumnFlags_WidthFixed,0.0f); + } ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthStretch,0.0f); - ImGui::TableNextRow(ImGuiTableRowFlags_Headers); - ImGui::TableNextColumn(); - ImGui::Text("Categories"); - ImGui::TableNextColumn(); - ImGui::Text("Systems"); + if (newSongQuery.empty()) { + ImGui::TableNextRow(ImGuiTableRowFlags_Headers); + ImGui::TableNextColumn(); + ImGui::Text("Categories"); + ImGui::TableNextColumn(); + ImGui::Text("Systems"); + } ImGui::TableNextRow(); // CATEGORIES - ImGui::TableNextColumn(); - int index=0; - for (FurnaceGUISysCategory& i: sysCategories) { - if (ImGui::Selectable(i.name,newSongCategory==index,ImGuiSelectableFlags_DontClosePopups)) { \ - newSongCategory=index; + if (newSongQuery.empty()) { + ImGui::TableNextColumn(); + int index=0; + for (FurnaceGUISysCategory& i: sysCategories) { + if (ImGui::Selectable(i.name,newSongCategory==index,ImGuiSelectableFlags_DontClosePopups)) { \ + newSongCategory=index; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("%s",i.description); + } + index++; } - if (ImGui::IsItemHovered()) { - ImGui::SetTooltip("%s",i.description); - } - index++; } // SYSTEMS ImGui::TableNextColumn(); if (ImGui::BeginTable("Systems",1,ImGuiTableFlags_BordersInnerV|ImGuiTableFlags_ScrollY)) { - for (FurnaceGUISysDef& i: sysCategories[newSongCategory].systems) { + std::vector& category=(newSongQuery.empty())?(sysCategories[newSongCategory].systems):(newSongSearchResults); + for (FurnaceGUISysDef& i: category) { ImGui::TableNextRow(); ImGui::TableNextColumn(); if (ImGui::Selectable(i.name,false,ImGuiSelectableFlags_DontClosePopups)) { diff --git a/src/gui/patManager.cpp b/src/gui/patManager.cpp index d597bd9c2..22d5b645e 100644 --- a/src/gui/patManager.cpp +++ b/src/gui/patManager.cpp @@ -47,21 +47,24 @@ void FurnaceGUI::drawPatManager() { }); } - for (int i=0; igetTotalChannelCount(); i++) { - memset(isUsed,0,256); - memset(isNull,0,256*sizeof(bool)); - for (int j=0; jcurSubSong->ordersLen; j++) { - isUsed[e->curSubSong->orders.ord[i][j]]++; - } - for (int j=0; j<256; j++) { - isNull[j]=(e->curSubSong->pat[i].data[j]==NULL); - } - ImGui::Text("%d. %s",i+1,e->getChannelName(i)); - ImGui::PushID(1000+i); + if (ImGui::BeginTable("PatManTable",257,ImGuiTableFlags_ScrollX|ImGuiTableFlags_SizingFixedFit)) { ImGui::PushFont(patFont); - if (ImGui::BeginTable("PatManTable",32)) { + + for (int i=0; igetTotalChannelCount(); i++) { + ImGui::TableNextRow(); + memset(isUsed,0,256); + memset(isNull,0,256*sizeof(bool)); + for (int j=0; jcurSubSong->ordersLen; j++) { + isUsed[e->curSubSong->orders.ord[i][j]]++; + } + for (int j=0; j<256; j++) { + isNull[j]=(e->curSubSong->pat[i].data[j]==NULL); + } + ImGui::TableNextColumn(); + ImGui::Text("%s",e->getChannelShortName(i)); + + ImGui::PushID(1000+i); for (int k=0; k<256; k++) { - if ((k&31)==0) ImGui::TableNextRow(); ImGui::TableNextColumn(); snprintf(id,1023,"%.2X",k); @@ -98,10 +101,11 @@ void FurnaceGUI::drawPatManager() { } ImGui::PopStyleColor(); } - ImGui::EndTable(); + ImGui::PopID(); } ImGui::PopFont(); - ImGui::PopID(); + + ImGui::EndTable(); } } if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) curWindow=GUI_WINDOW_PAT_MANAGER; diff --git a/src/gui/plot_nolerp.cpp b/src/gui/plot_nolerp.cpp index 64ffc4100..d802cbc52 100644 --- a/src/gui/plot_nolerp.cpp +++ b/src/gui/plot_nolerp.cpp @@ -183,7 +183,7 @@ void PlotNoLerp(const char* label, const float* values, int values_count, int va PlotNoLerpEx(ImGuiPlotType_Lines, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size); } -int PlotBitfieldEx(const char* label, int (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char** overlay_text, int bits, ImVec2 frame_size) +int PlotBitfieldEx(const char* label, int (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char** overlay_text, int bits, ImVec2 frame_size, const bool* values_highlight, ImVec4 highlightColor) { ImGuiContext& g = *GImGui; ImGuiWindow* window = ImGui::GetCurrentWindow(); @@ -253,7 +253,11 @@ int PlotBitfieldEx(const char* label, int (*values_getter)(void* data, int idx), if (pos1.y <= pos0.y - 2.0f) pos1.y += 1.0f; if (v1&(1<DrawList->AddRectFilled(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base); + ImU32 rCol=(idx_hovered == v1_idx ? col_hovered : col_base); + if (values_highlight!=NULL) { + if (values_highlight[v1_idx]) rCol=ImGui::GetColorU32(highlightColor); + } + window->DrawList->AddRectFilled(pos0, pos1, rCol); } } tp0 = tp1; @@ -283,13 +287,13 @@ int PlotBitfieldEx(const char* label, int (*values_getter)(void* data, int idx), return idx_hovered; } -void PlotBitfield(const char* label, const int* values, int values_count, int values_offset, const char** overlay_text, int bits, ImVec2 graph_size, int stride) +void PlotBitfield(const char* label, const int* values, int values_count, int values_offset, const char** overlay_text, int bits, ImVec2 graph_size, int stride, const bool* values_highlight, ImVec4 highlightColor) { FurnacePlotIntArrayGetterData data(values, stride); - PlotBitfieldEx(label, &Plot_IntArrayGetter, (void*)&data, values_count, values_offset, overlay_text, bits, graph_size); + PlotBitfieldEx(label, &Plot_IntArrayGetter, (void*)&data, values_count, values_offset, overlay_text, bits, graph_size, values_highlight, highlightColor); } -int PlotCustomEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_display_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size, ImVec4 color, int highlight, std::string (*hoverFunc)(int,float), bool blockMode, std::string (*guideFunc)(float)) +int PlotCustomEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_display_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size, ImVec4 color, int highlight, std::string (*hoverFunc)(int,float), bool blockMode, std::string (*guideFunc)(float), const bool* values_highlight, ImVec4 highlightColor) { ImGuiContext& g = *GImGui; ImGuiWindow* window = ImGui::GetCurrentWindow(); @@ -413,7 +417,11 @@ int PlotCustomEx(ImGuiPlotType plot_type, const char* label, float (*values_gett pos0.y-=(inner_bb.Max.y-inner_bb.Min.y)*inv_scale; //pos1.y+=1.0f; } - window->DrawList->AddRectFilled(pos0, pos1, idx_hovered == v1_idx ? col_hovered : col_base); + ImU32 rCol=(idx_hovered == v1_idx ? col_hovered : col_base); + if (values_highlight!=NULL) { + if (values_highlight[v1_idx]) rCol=ImGui::GetColorU32(highlightColor); + } + window->DrawList->AddRectFilled(pos0, pos1, rCol); } t0 = t1; @@ -451,8 +459,8 @@ int PlotCustomEx(ImGuiPlotType plot_type, const char* label, float (*values_gett return idx_hovered; } -void PlotCustom(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride, ImVec4 color, int highlight, std::string (*hoverFunc)(int,float), bool blockMode, std::string (*guideFunc)(float)) +void PlotCustom(const char* label, const float* values, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride, ImVec4 color, int highlight, std::string (*hoverFunc)(int,float), bool blockMode, std::string (*guideFunc)(float), const bool* values_highlight, ImVec4 highlightColor) { FurnacePlotArrayGetterData data(values, stride); - PlotCustomEx(ImGuiPlotType_Histogram, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, color, highlight, hoverFunc, blockMode, guideFunc); + PlotCustomEx(ImGuiPlotType_Histogram, label, &Plot_ArrayGetter, (void*)&data, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, color, highlight, hoverFunc, blockMode, guideFunc, values_highlight, highlightColor); } \ No newline at end of file diff --git a/src/gui/plot_nolerp.h b/src/gui/plot_nolerp.h index 5862dfadc..b353e6f8b 100644 --- a/src/gui/plot_nolerp.h +++ b/src/gui/plot_nolerp.h @@ -21,5 +21,5 @@ #include void PlotNoLerp(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float)); -void PlotBitfield(const char* label, const int* values, int values_count, int values_offset = 0, const char** overlay_text = NULL, int bits = 8, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float)); -void PlotCustom(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float), ImVec4 fgColor = ImVec4(1.0f,1.0f,1.0f,1.0f), int highlight = 0, std::string (*hoverFunc)(int,float) = NULL, bool blockMode=false, std::string (*guideFunc)(float) = NULL); \ No newline at end of file +void PlotBitfield(const char* label, const int* values, int values_count, int values_offset = 0, const char** overlay_text = NULL, int bits = 8, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float), const bool* values_highlight = NULL, ImVec4 highlightColor = ImVec4(1.0f,1.0f,1.0f,1.0f)); +void PlotCustom(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float), ImVec4 fgColor = ImVec4(1.0f,1.0f,1.0f,1.0f), int highlight = 0, std::string (*hoverFunc)(int,float) = NULL, bool blockMode=false, std::string (*guideFunc)(float) = NULL, const bool* values_highlight = NULL, ImVec4 highlightColor = ImVec4(1.0f,1.0f,1.0f,1.0f)); \ No newline at end of file diff --git a/src/gui/presets.cpp b/src/gui/presets.cpp index 571cda441..1bd637a23 100644 --- a/src/gui/presets.cpp +++ b/src/gui/presets.cpp @@ -79,7 +79,7 @@ void FurnaceGUI::initSystemPresets() { } )); cat.systems.push_back(FurnaceGUISysDef( - "Yamaha YM2610B (OPNB-B)", { + "Yamaha YM2610B (OPNB2)", { DIV_SYSTEM_YM2610B, 64, 0, 0, 0 } @@ -854,6 +854,41 @@ void FurnaceGUI::initSystemPresets() { 0 } )); + cat.systems.push_back(FurnaceGUISysDef( + "MSX + Neotron", { + DIV_SYSTEM_AY8910, 64, 0, 16, + DIV_SYSTEM_YM2610_FULL, 64, 0, 0, + 0 + } + )); + cat.systems.push_back(FurnaceGUISysDef( + "MSX + Neotron (extended channel 2)", { + DIV_SYSTEM_AY8910, 64, 0, 16, + DIV_SYSTEM_YM2610_FULL_EXT, 64, 0, 0, + 0 + } + )); + cat.systems.push_back(FurnaceGUISysDef( + "MSX + Neotron (with YM2610B)", { + DIV_SYSTEM_AY8910, 64, 0, 16, + DIV_SYSTEM_YM2610B, 64, 0, 0, + 0 + } + )); + cat.systems.push_back(FurnaceGUISysDef( + "MSX + Neotron (with YM2610B; extended channel 3)", { + DIV_SYSTEM_AY8910, 64, 0, 16, + DIV_SYSTEM_YM2610B_EXT, 64, 0, 0, + 0 + } + )); + cat.systems.push_back(FurnaceGUISysDef( + "MSX + SIMPL", { + DIV_SYSTEM_AY8910, 64, 0, 16, + DIV_SYSTEM_PCM_DAC, 64, 0, 55929|(7<<16), // variable rate, Mono DAC + 0 + } + )); cat.systems.push_back(FurnaceGUISysDef( "NEC PC-98 (with PC-9801-26/K)", { DIV_SYSTEM_OPN, 64, 0, 4, // 3.9936MHz but some compatible card has 4MHz diff --git a/src/gui/settings.cpp b/src/gui/settings.cpp index b2859f7ff..9f69a72b1 100644 --- a/src/gui/settings.cpp +++ b/src/gui/settings.cpp @@ -1085,6 +1085,32 @@ void FurnaceGUI::drawSettings() { ); } + bool loadChineseTraditionalB=settings.loadChineseTraditional; + if (ImGui::Checkbox("Display Chinese (Traditional) characters",&loadChineseTraditionalB)) { + settings.loadChineseTraditional=loadChineseTraditionalB; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip( + "Only toggle this option if you have enough graphics memory.\n" + "This is a temporary solution until dynamic font atlas is implemented in Dear ImGui.\n\n" + "請在確保你有足夠的顯存后再啟動此設定\n" + "這是一個在ImGui實現動態字體加載之前的臨時解決方案" + ); + } + + bool loadKoreanB=settings.loadKorean; + if (ImGui::Checkbox("Display Korean characters",&loadKoreanB)) { + settings.loadKorean=loadKoreanB; + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip( + "Only toggle this option if you have enough graphics memory.\n" + "This is a temporary solution until dynamic font atlas is implemented in Dear ImGui.\n\n" + "그래픽 메모리가 충분한 경우에만 이 옵션을 선택하십시오.\n" + "이 옵션은 Dear ImGui에 동적 글꼴 아틀라스가 구현될 때까지 임시 솔루션입니다." + ); + } + ImGui::Separator(); ImGui::Text("Pattern view labels:"); @@ -1222,6 +1248,79 @@ void FurnaceGUI::drawSettings() { ImGui::Separator(); + ImGui::Text("Channel colors:"); + if (ImGui::RadioButton("Single##CHC0",settings.channelColors==0)) { + settings.channelColors=0; + } + if (ImGui::RadioButton("Channel type##CHC1",settings.channelColors==1)) { + settings.channelColors=1; + } + if (ImGui::RadioButton("Instrument type##CHC2",settings.channelColors==2)) { + settings.channelColors=2; + } + + ImGui::Text("Channel name colors:"); + if (ImGui::RadioButton("Single##CTC0",settings.channelColors==0)) { + settings.channelColors=0; + } + if (ImGui::RadioButton("Channel type##CTC1",settings.channelColors==1)) { + settings.channelColors=1; + } + if (ImGui::RadioButton("Instrument type##CTC2",settings.channelColors==2)) { + settings.channelColors=2; + } + + ImGui::Text("Channel style:"); + if (ImGui::RadioButton("Classic##CHS0",settings.channelStyle==0)) { + settings.channelStyle=0; + } + if (ImGui::RadioButton("Line##CHS1",settings.channelStyle==1)) { + settings.channelStyle=1; + } + if (ImGui::RadioButton("Round##CHS2",settings.channelStyle==2)) { + settings.channelStyle=2; + } + if (ImGui::RadioButton("Split button##CHS3",settings.channelStyle==3)) { + settings.channelStyle=3; + } + if (ImGui::RadioButton("Square border##CH42",settings.channelStyle==4)) { + settings.channelStyle=4; + } + if (ImGui::RadioButton("Round border##CHS5",settings.channelStyle==5)) { + settings.channelStyle=5; + } + + ImGui::Text("Channel volume bar:"); + if (ImGui::RadioButton("None##CHV0",settings.channelVolStyle==0)) { + settings.channelVolStyle=0; + } + if (ImGui::RadioButton("Simple##CHV1",settings.channelVolStyle==1)) { + settings.channelVolStyle=1; + } + if (ImGui::RadioButton("Stereo##CHV2",settings.channelVolStyle==2)) { + settings.channelVolStyle=2; + } + if (ImGui::RadioButton("Real##CHV3",settings.channelVolStyle==3)) { + settings.channelVolStyle=3; + } + + ImGui::Text("Channel feedback style:"); + + if (ImGui::RadioButton("Off##CHF0",settings.channelFeedbackStyle==0)) { + settings.channelFeedbackStyle=0; + } + if (ImGui::RadioButton("Note##CHF1",settings.channelFeedbackStyle==1)) { + settings.channelFeedbackStyle=1; + } + if (ImGui::RadioButton("Volume##CHF2",settings.channelFeedbackStyle==2)) { + settings.channelFeedbackStyle=2; + } + if (ImGui::RadioButton("Active##CHF3",settings.channelFeedbackStyle==3)) { + settings.channelFeedbackStyle=3; + } + + ImGui::Separator(); + bool insEditColorizeB=settings.insEditColorize; if (ImGui::Checkbox("Colorize instrument editor using instrument type",&insEditColorizeB)) { settings.insEditColorize=insEditColorizeB; @@ -2099,6 +2198,8 @@ void FurnaceGUI::syncSettings() { settings.roundedMenus=e->getConfInt("roundedMenus",0); settings.loadJapanese=e->getConfInt("loadJapanese",0); settings.loadChinese=e->getConfInt("loadChinese",0); + settings.loadChineseTraditional=e->getConfInt("loadChineseTraditional",0); + settings.loadKorean=e->getConfInt("loadKorean",0); settings.fmLayout=e->getConfInt("fmLayout",0); settings.sampleLayout=e->getConfInt("sampleLayout",0); settings.waveLayout=e->getConfInt("waveLayout",0); @@ -2149,6 +2250,11 @@ void FurnaceGUI::syncSettings() { settings.emptyLabel=e->getConfString("emptyLabel","..."); settings.emptyLabel2=e->getConfString("emptyLabel2",".."); settings.saveUnusedPatterns=e->getConfInt("saveUnusedPatterns",0); + settings.channelColors=e->getConfInt("channelColors",1); + settings.channelTextColors=e->getConfInt("channelTextColors",0); + settings.channelStyle=e->getConfInt("channelStyle",0); + settings.channelVolStyle=e->getConfInt("channelVolStyle",0); + settings.channelFeedbackStyle=e->getConfInt("channelFeedbackStyle",1); clampSetting(settings.mainFontSize,2,96); clampSetting(settings.patFontSize,2,96); @@ -2198,6 +2304,8 @@ void FurnaceGUI::syncSettings() { clampSetting(settings.roundedMenus,0,1); clampSetting(settings.loadJapanese,0,1); clampSetting(settings.loadChinese,0,1); + clampSetting(settings.loadChineseTraditional,0,1); + clampSetting(settings.loadKorean,0,1); clampSetting(settings.fmLayout,0,6); clampSetting(settings.susPosition,0,1); clampSetting(settings.effectCursorDir,0,2); @@ -2238,6 +2346,11 @@ void FurnaceGUI::syncSettings() { clampSetting(settings.noThreadedInput,0,1); clampSetting(settings.clampSamples,0,1); clampSetting(settings.saveUnusedPatterns,0,1); + clampSetting(settings.channelColors,0,2); + clampSetting(settings.channelTextColors,0,2); + clampSetting(settings.channelStyle,0,5); + clampSetting(settings.channelVolStyle,0,3); + clampSetting(settings.channelFeedbackStyle,0,3); settings.initialSys=e->decodeSysDesc(e->getConfString("initialSys","")); if (settings.initialSys.size()<4) { @@ -2332,6 +2445,8 @@ void FurnaceGUI::commitSettings() { e->setConf("roundedMenus",settings.roundedMenus); e->setConf("loadJapanese",settings.loadJapanese); e->setConf("loadChinese",settings.loadChinese); + e->setConf("loadChineseTraditional",settings.loadChineseTraditional); + e->setConf("loadKorean",settings.loadKorean); e->setConf("fmLayout",settings.fmLayout); e->setConf("sampleLayout",settings.sampleLayout); e->setConf("waveLayout",settings.waveLayout); @@ -2383,6 +2498,11 @@ void FurnaceGUI::commitSettings() { e->setConf("emptyLabel",settings.emptyLabel); e->setConf("emptyLabel2",settings.emptyLabel2); e->setConf("saveUnusedPatterns",settings.saveUnusedPatterns); + e->setConf("channelColors",settings.channelColors); + e->setConf("channelTextColors",settings.channelTextColors); + e->setConf("channelStyle",settings.channelStyle); + e->setConf("channelVolStyle",settings.channelVolStyle); + e->setConf("channelFeedbackStyle",settings.channelFeedbackStyle); // colors for (int i=0; iGetGlyphRangesChineseSimplifiedCommon()); } + if (settings.loadChineseTraditional) { + range.AddRanges(ImGui::GetIO().Fonts->GetGlyphRangesChineseFull()); + } + if (settings.loadKorean) { + range.AddRanges(ImGui::GetIO().Fonts->GetGlyphRangesKorean()); + } // I'm terribly sorry range.UsedChars[0x80>>5]=0; diff --git a/src/gui/sysManager.cpp b/src/gui/sysManager.cpp new file mode 100644 index 000000000..98f939d0f --- /dev/null +++ b/src/gui/sysManager.cpp @@ -0,0 +1,124 @@ +/** + * Furnace Tracker - multi-system chiptune tracker + * Copyright (C) 2021-2022 tildearrow and contributors + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "gui.h" +#include "misc/cpp/imgui_stdlib.h" +#include "IconsFontAwesome4.h" +#include +#include + +void FurnaceGUI::drawSysManager() { + if (nextWindow==GUI_WINDOW_SYS_MANAGER) { + sysManagerOpen=true; + ImGui::SetNextWindowFocus(); + nextWindow=GUI_WINDOW_NOTHING; + } + if (!sysManagerOpen) return; + if (ImGui::Begin("Chip Manager",&sysManagerOpen,globalWinFlags)) { + ImGui::Checkbox("Preserve channel order",&preserveChanPos); + if (ImGui::BeginTable("SystemList",3)) { + ImGui::TableSetupColumn("c1",ImGuiTableColumnFlags_WidthFixed); + ImGui::TableSetupColumn("c2",ImGuiTableColumnFlags_WidthStretch); + ImGui::TableSetupColumn("c3",ImGuiTableColumnFlags_WidthFixed); + ImGui::TableNextRow(ImGuiTableRowFlags_Headers); + ImGui::TableNextColumn(); + ImGui::TableNextColumn(); + ImGui::Text("Name"); + ImGui::TableNextColumn(); + ImGui::Text("Actions"); + for (unsigned char i=0; isong.systemLen; i++) { + ImGui::PushID(i); + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + if (ImGui::Button(ICON_FA_ARROWS)) { + } + if (ImGui::BeginDragDropSource()) { + sysToMove=i; + ImGui::SetDragDropPayload("FUR_SYS",NULL,0,ImGuiCond_Once); + ImGui::Button(ICON_FA_ARROWS "##SysDrag"); + ImGui::EndDragDropSource(); + } else if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("(drag to swap chips)"); + } + if (ImGui::BeginDragDropTarget()) { + const ImGuiPayload* dragItem=ImGui::AcceptDragDropPayload("FUR_SYS"); + if (dragItem!=NULL) { + if (dragItem->IsDataType("FUR_SYS")) { + if (sysToMove!=i && sysToMove>=0) { + e->swapSystem(sysToMove,i,preserveChanPos); + } + sysToMove=-1; + } + } + ImGui::EndDragDropTarget(); + } + ImGui::TableNextColumn(); + if (ImGui::TreeNode(fmt::sprintf("%d. %s##_SYSM%d",i+1,getSystemName(e->song.system[i]),i).c_str())) { + drawSysConf(i,e->song.system[i],e->song.systemFlags[i],true); + ImGui::TreePop(); + } + ImGui::TableNextColumn(); + ImGui::Button(ICON_FA_CHEVRON_DOWN "##SysChange"); + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("Change"); + } + if (ImGui::BeginPopupContextItem("SysPickerC",ImGuiPopupFlags_MouseButtonLeft)) { + DivSystem picked=systemPicker(); + if (picked!=DIV_SYSTEM_NULL) { + e->changeSystem(i,picked,preserveChanPos); + updateWindowTitle(); + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } + ImGui::SameLine(); + ImGui::BeginDisabled(e->song.systemLen<=1); + if (ImGui::Button(ICON_FA_TIMES "##SysRemove")) { + sysToDelete=i; + showWarning("Are you sure you want to remove this chip?",GUI_WARN_SYSTEM_DEL); + } + if (ImGui::IsItemHovered()) { + ImGui::SetTooltip("Remove"); + } + ImGui::EndDisabled(); + ImGui::PopID(); + } + if (e->song.systemLen<32) { + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + ImGui::TableNextColumn(); + ImGui::Button(ICON_FA_PLUS "##SysAdd"); + if (ImGui::BeginPopupContextItem("SysPickerA",ImGuiPopupFlags_MouseButtonLeft)) { + DivSystem picked=systemPicker(); + if (picked!=DIV_SYSTEM_NULL) { + if (!e->addSystem(picked)) { + showError("cannot add chip! ("+e->getLastError()+")"); + } + updateWindowTitle(); + ImGui::CloseCurrentPopup(); + } + ImGui::EndPopup(); + } + } + ImGui::EndTable(); + } + } + if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) curWindow=GUI_WINDOW_SYS_MANAGER; + ImGui::End(); +} diff --git a/src/gui/sysPicker.cpp b/src/gui/sysPicker.cpp new file mode 100644 index 000000000..f59e547ad --- /dev/null +++ b/src/gui/sysPicker.cpp @@ -0,0 +1,97 @@ +/** + * Furnace Tracker - multi-system chiptune tracker + * Copyright (C) 2021-2022 tildearrow and contributors + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "gui.h" +#include "misc/cpp/imgui_stdlib.h" +#include "IconsFontAwesome4.h" +#include "guiConst.h" +#include + +DivSystem FurnaceGUI::systemPicker() { + DivSystem ret=DIV_SYSTEM_NULL; + DivSystem hoveredSys=DIV_SYSTEM_NULL; + bool reissueSearch=false; + if (curSysSection==NULL) { + curSysSection=availableSystems; + } + + ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x); + if (ImGui::InputTextWithHint("##SysSearch","Search...",&sysSearchQuery)) reissueSearch=true; + if (ImGui::BeginTabBar("SysCats")) { + for (int i=0; chipCategories[i]; i++) { + if (ImGui::BeginTabItem(chipCategoryNames[i])) { + if (ImGui::IsItemActive()) { + reissueSearch=true; + } + curSysSection=chipCategories[i]; + ImGui::EndTabItem(); + } + } + ImGui::EndTabBar(); + } + if (reissueSearch) { + String lowerCase=sysSearchQuery; + for (char& i: lowerCase) { + if (i>='A' && i<='Z') i+='a'-'A'; + } + sysSearchResults.clear(); + for (int j=0; curSysSection[j]; j++) { + String lowerCase1=e->getSystemName((DivSystem)curSysSection[j]); + for (char& i: lowerCase1) { + if (i>='A' && i<='Z') i+='a'-'A'; + } + if (lowerCase1.find(lowerCase)!=String::npos) { + sysSearchResults.push_back((DivSystem)curSysSection[j]); + } + } + } + if (ImGui::BeginTable("SysList",1,ImGuiTableFlags_ScrollY,ImVec2(500.0f*dpiScale,200.0*dpiScale))) { + if (sysSearchQuery.empty()) { + // display chip list + for (int j=0; curSysSection[j]; j++) { + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + if (ImGui::Selectable(e->getSystemName((DivSystem)curSysSection[j]),false,0,ImVec2(500.0f*dpiScale,0.0f))) ret=(DivSystem)curSysSection[j]; + if (ImGui::IsItemHovered()) { + hoveredSys=(DivSystem)curSysSection[j]; + } + } + } else { + // display search results + for (DivSystem i: sysSearchResults) { + ImGui::TableNextRow(); + ImGui::TableNextColumn(); + if (ImGui::Selectable(e->getSystemName(i),false,0,ImVec2(500.0f*dpiScale,0.0f))) ret=i; + if (ImGui::IsItemHovered()) { + hoveredSys=i; + } + } + } + ImGui::EndTable(); + } + ImGui::Separator(); + if (ImGui::BeginChild("SysDesc",ImVec2(0.0f,150.0f*dpiScale),false,ImGuiWindowFlags_NoScrollbar|ImGuiWindowFlags_NoScrollWithMouse)) { + if (hoveredSys!=DIV_SYSTEM_NULL) { + const DivSysDef* sysDef=e->getSystemDef(hoveredSys); + ImGui::TextWrapped("%s",sysDef->description); + } + } + ImGui::EndChild(); + return ret; +} \ No newline at end of file