instrument_clip_view.h

/*
 * Copyright © 2014-2023 Synthstrom Audible Limited
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware 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 3 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, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "definitions_cxx.hpp"
#include "gui/views/clip_view.h"
#include "hid/button.h"
#include "model/clip/instrument_clip_minder.h"
#include "model/iterance/iterance.h"
#include "model/note/note_row.h"
#include "modulation/automation/copied_param_automation.h"
#include "modulation/params/param_node.h"
#include "util/d_string.h"
#include <span>
 
class InstrumentClip;
class NoteRow;
class Note;
class Editor;
class Instrument;
class Sound;
class ModControllable;
class Kit;
class Drum;
class SoundDrum;
class ParamManagerForTimeline;
class Action;
class ParamCollection;
class CopiedNoteRow;
class ParamNode;
class ModelStackWithTimelineCounter;
class ModelStackWithNoteRow;
 
struct EditPadPress {
    bool isActive;
    uint8_t yDisplay;
    uint8_t xDisplay;
    bool deleteOnDepress; // Can also mean to delete tail
    uint8_t intendedVelocity;
    uint8_t intendedProbability;
    Iterance intendedIterance;
    uint8_t intendedFill;
    bool deleteOnScroll;
    bool isBlurredSquare;
    bool mpeCachedYet;
    StolenParamNodes stolenMPE[kNumExpressionDimensions];
    uint32_t intendedPos;    // For "blurred squares", means start of square
    uint32_t intendedLength; // For "blurred squares", means length of square
};
 
#define MPE_RECORD_LENGTH_FOR_NOTE_EDITING 3
#define MPE_RECORD_INTERVAL_TIME (kSampleRate >> 2) // 250ms
static constexpr const char* PATTERN_FILE_VERSION = "0.0.1";
 
enum class NudgeMode { QUANTIZE, QUANTIZE_ALL };
 
class InstrumentClipView final : public ClipView, public InstrumentClipMinder {
public:
    InstrumentClipView();
    bool opened() override;
    void focusRegained() override;
    void displayOrLanguageChanged() override;
 
    // BUTTON ACTION button press / release handling
 
    ActionResult buttonAction(deluge::hid::Button b, bool on, bool inCardRoutine) override;
    // Used to reveal Session macros only after the Session button has passed the long-press threshold.
    ActionResult timerCallback() override;
    ActionResult handleScaleButtonAction(bool on, bool inCardRoutine);
    bool handleInstrumentChange(OutputType outputType);
 
    // PAD ACTION pad press / release handling
 
    ActionResult padAction(int32_t x, int32_t y, int32_t velocity) override;
    ActionResult potentiallyRandomizeDrumSamples();
    ActionResult potentiallyRandomizeDrumSample(Kit* kit, Drum* drum, char* chosenFilename);
    ActionResult commandEnterNoteVelocityEditor(int32_t x, int32_t y);
    ActionResult commandLearnMutePad(int32_t y, int32_t velocity);
    ActionResult commandLearnAuditionPad(InstrumentClip* clip, Output* output, OutputType outputType, int32_t yDisplay,
                                         int32_t velocity);
    ActionResult commandSaveKitRow(InstrumentClip* clip, Output* output, OutputType outputType, int32_t yDisplay);
    ActionResult commandActivateSongMacro(int32_t y, int32_t velocity);
 
    // SCALE MODE related commands.

    ActionResult commandLearnUserScale();
    ActionResult commandCycleThroughScales();
    ActionResult commandFlashRootNote();
    ActionResult commandEnterScaleModeWithRoot(uint8_t root);
    ActionResult commandEnterScaleMode();
    ActionResult commandExitScaleMode();
    ActionResult commandChangeRootNote(uint8_t yDisplay);

    ActionResult verticalEncoderAction(int32_t offset, bool inCardRoutine) override;
    ActionResult commandTransposeKey(int32_t offset, bool inCardRoutine);
    void commandTransposeScreen(int32_t offset, bool inOctave);
    void commandShiftColour(int32_t offset);
    ActionResult scrollVertical(int32_t scrollAmount, bool inCardRoutine, bool draggingNoteRow = false,
                                ModelStackWithTimelineCounter* modelStack = nullptr);
    ActionResult scrollVertical_limit(int32_t scrollAmount, bool inCardRoutine, bool draggingNoteRow,
                                      ModelStackWithTimelineCounter* modelStack, InstrumentClip* clip, bool isKit,
                                      bool preventOverScrolling, int32_t& noteRowToShiftI, int32_t& noteRowToSwapWithI);
    void scrollVertical_potentiallySwitchOffAuditionedNotes(bool draggingNoteRow,
                                                            ModelStackWithTimelineCounter* modelStack,
                                                            InstrumentClip* clip, bool currentClipIsActive);
    void scrollVertical_grabNotesPressed(ModelStackWithTimelineCounter* modelStack, InstrumentClip* clip);
    void scrollVertical_dragSelectedNoteRow(InstrumentClip* clip, Output* output, bool isKit, int32_t noteRowToShiftI,
                                            int32_t noteRowToSwapWithI);
    void scrollVertical_potentiallySwitchOnAuditionedNotes(bool draggingNoteRow,
                                                           ModelStackWithTimelineCounter* modelStack,
                                                           InstrumentClip* clip, Output* output, OutputType outputType,
                                                           bool isKit, bool inSoundEditor, bool currentClipIsActive,
                                                           bool renderDisplay, bool updateDrumSelection);
    void scrollVertical_placeNotesPressed(ModelStackWithTimelineCounter* modelStack, InstrumentClip* clip, bool isKit);

    uint8_t getEditPadPressXDisplayOnScreen(uint8_t yDisplay);
    void editPadAction(bool state, uint8_t yDisplay, uint8_t xDisplay, uint32_t xZoom);
    void mutePadPress(uint8_t yDisplay);
    bool ensureNoteRowExistsForYDisplay(uint8_t yDisplay);
    void recalculateColours();
    void recalculateColour(uint8_t yDisplay);
    void reassessAllAuditionStatus();
    void reassessAuditionStatus(uint8_t yDisplay);
    uint8_t getVelocityForAudition(uint8_t yDisplay, uint32_t* sampleSyncLength);
    uint8_t getNumNoteRowsAuditioning();
    uint8_t oneNoteAuditioning();
    void offsetNoteCodeAction(int32_t newOffset);
    int32_t getYVisualFromYDisplay(int32_t yDisplay);
    int32_t getYVisualWithinOctaveFromYDisplay(int32_t yDisplay);
    ActionResult auditionPadAction(int32_t velocity, int32_t yDisplay, bool shiftButtonDown);
    void potentiallyUpdateMultiRangeMenu(int32_t velocity, int32_t yDisplay, Instrument* instrument);
    void potentiallyRecordAuditionPadAction(bool clipIsActiveOnInstrument, int32_t velocity, int32_t yDisplay,
                                            Instrument* instrument, bool isKit,
                                            ModelStackWithTimelineCounter* modelStackWithTimelineCounter,
                                            ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip, Drum* drum);
    void recordNoteOnEarly(int32_t velocity, int32_t yDisplay, Instrument* instrument, bool isKit,
                           ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip, Drum* drum);
    void recordNoteOn(int32_t velocity, int32_t yDisplay, Instrument* instrument,
                      ModelStackWithTimelineCounter* modelStackWithTimelineCounter,
                      ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip);
    NoteRow* getNoteRowOnActiveClip(int32_t yDisplay, Instrument* instrument, bool clipIsActiveOnInstrument,
                                    ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip, Drum* drum);
    void potentiallyRefreshNoteRowMenu();
    bool startAuditioningRow(int32_t velocity, int32_t yDisplay, bool shiftButtonDown, bool isKit,
                             NoteRow* noteRowOnActiveClip, Drum* drum, bool displayNoteCode = true);
    void finishAuditioningRow(int32_t yDisplay, ModelStackWithNoteRow* modelStack, NoteRow* noteRowOnActiveClip);
    void enterScaleMode(uint8_t yDisplay = 255);
    void exitScaleMode();
    void drawMuteSquare(NoteRow* thisNoteRow, RGB thisImage[], uint8_t thisOccupancyMask[]);
    void cutAuditionedNotesToOne();
    ActionResult horizontalEncoderAction(int32_t offset) override;
    void fillOffScreenImageStores();
    void graphicsRoutine() override;
 
    void drawAuditionSquare(uint8_t yDisplay, RGB thisImage[]);
    void flashDefaultRootNote();
    void selectEncoderAction(int8_t offset) override;
    void doubleClipLengthAction();
    void setSelectedDrum(Drum* drum, bool shouldRedrawStuff = true, Kit* selectedKit = nullptr,
                         bool shouldSendMidiFeedback = true);
    bool isDrumAuditioned(Drum* drum);
    int32_t setupForEnteringScaleMode(int32_t newRootNote = 2147483647, int32_t yDisplay = (kDisplayHeight / 2));
    int32_t setupForExitingScaleMode();
    void setupChangingOfRootNote(int32_t newRootNote, int32_t yDisplay = (kDisplayHeight / 2));
    void deleteDrum(SoundDrum* drum);
    void cancelAllAuditioning();
    void modEncoderButtonAction(uint8_t whichModEncoder, bool on) override;
 
    void drawDrumName(Drum* drum, bool justPopUp = false);
    void notifyPlaybackBegun() override;
    void openedInBackground();
    bool renderMainPads(uint32_t whichRows, RGB image[][kDisplayWidth + kSideBarWidth],
                        uint8_t occupancyMask[][kDisplayWidth + kSideBarWidth], bool drawUndefinedArea = true) override;
    void performActualRender(uint32_t whichRows, RGB* image, uint8_t occupancyMask[][kDisplayWidth + kSideBarWidth],
                             int32_t xScroll, uint32_t xZoom, int32_t renderWidth, int32_t imageWidth,
                             bool drawUndefinedArea = true);
    bool renderSidebar(uint32_t whichRows, RGB image[][kDisplayWidth + kSideBarWidth],
                       uint8_t occupancyMask[][kDisplayWidth + kSideBarWidth]) override;
 
    void playbackEnded() override;
    void scrollFinished() override;
    void clipNeedsReRendering(Clip* clip) override;
    void modEncoderAction(int32_t whichModEncoder, int32_t offset) override;
    ClipMinder* toClipMinder() override { return this; }
    void reportMPEInitialValuesForNoteEditing(ModelStackWithNoteRow* modelStack, int16_t const* mpeValues);
    void reportMPEValueForNoteEditing(int32_t expressionDimension, int32_t value);
    void reportNoteOffForMPEEditing(ModelStackWithNoteRow* modelStack);
    void dontDeleteNotesOnDepress();
 
    // tempo encoder commands
    void tempoEncoderAction(int8_t offset, bool encoderButtonPressed, bool shiftButtonPressed);
    ActionResult commandStopQuantize(int32_t y);
 
    void sendAuditionNote(bool on, uint8_t yDisplay, uint8_t velocity, uint32_t sampleSyncLength);
 
    // made these public so they can be accessed by the automation clip view
    void setLedStates();
    uint32_t getSquareWidth(int32_t square, int32_t effectiveLength);
    void drawNoteCode(uint8_t yDisplay);
    bool createNewInstrument(OutputType instrumentType, bool is_fm = false);
    bool changeOutputType(OutputType newOutputType);
    Sound* getSoundForNoteRow(NoteRow* noteRow, ParamManagerForTimeline** getParamManager);
    void someAuditioningHasEnded(bool recalculateLastAuditionedNoteOnScreen);
    bool getAffectEntire() override;
    void checkIfAllEditPadPressesEnded(bool mayRenderSidebar = true);
    void endEditPadPress(uint8_t i);
    void endAllEditPadPresses();
    void copyAutomation(int32_t whichModEncoder, int32_t navSysId = NAVIGATION_CLIP);
    void pasteAutomation(int32_t whichModEncoder, int32_t navSysId = NAVIGATION_CLIP);
    // made these public so they can be accessed by the automation clip view
 
    void renderOLED(deluge::hid::display::oled_canvas::Canvas& canvas) override {
        InstrumentClipMinder::renderOLED(canvas);
    }
 
    CopiedParamAutomation copiedParamAutomation{};
    // Sometimes the user will want to hold an audition pad without actually sounding the note, by holding an encoder
    bool auditioningSilently{};
    // Archaic leftover feature that users wouldn't let me get rid of
    bool fileBrowserShouldNotPreview{};
 
    int16_t mpeValuesAtHighestPressure[MPE_RECORD_LENGTH_FOR_NOTE_EDITING][kNumExpressionDimensions]{};
    int16_t mpeMostRecentPressure{};
    uint32_t mpeRecordLastUpdateTime{};
 
    // made these public so they can be accessed by the automation clip view
    EditPadPress editPadPresses[kEditPadPressBufferSize];
    uint8_t lastAuditionedVelocityOnScreen[kDisplayHeight]{}; // 255 seems to mean none
    uint8_t auditionPadIsPressed[kDisplayHeight]{};
    uint8_t numEditPadPressesPerNoteRowOnScreen[kDisplayHeight]{};
    uint8_t lastAuditionedYDisplay{};
    uint8_t numEditPadPresses;
    uint32_t timeLastEditPadPress;
    uint32_t timeFirstEditPadPress{};
    // Only to be looked at if shouldIgnoreHorizontalScrollKnobActionIfNotAlsoPressedForThisNotePress is true after they
    // rotated a NoteRow and might now be wanting to instead edit its length after releasing the knob
    uint32_t timeHorizontalKnobLastReleased{};
    bool shouldIgnoreVerticalScrollKnobActionIfNotAlsoPressedForThisNotePress{};
    bool shouldIgnoreHorizontalScrollKnobActionIfNotAlsoPressedForThisNotePress{};
    // Because in this case we can assume that if they press a main pad while auditioning, they're not intending to do
    // that shortcut into the SoundEditor!
    bool editedAnyPerNoteRowStuffSinceAuditioningBegan{};
    // made these public so they can be accessed by the automation clip view
 
    // ui
    UIType getUIType() override { return UIType::INSTRUMENT_CLIP; }
    UIModControllableContext getUIModControllableContext() override { return UIModControllableContext::CLIP; }
 
    // note editor
    bool enterNoteEditor();
    std::span<EditPadPress> get_note_edit_targets();
    void exitNoteEditor();
    void handleNoteEditorEditPadAction(int32_t x, int32_t y, int32_t on);
    void deselectNoteAndGoUpOneLevel();
    ActionResult handleNoteEditorVerticalEncoderAction(int32_t offset, bool inCardRoutine);
    ActionResult handleNoteEditorHorizontalEncoderAction(int32_t offset);
    ActionResult handleNoteEditorButtonAction(deluge::hid::Button b, bool on, bool inCardRoutine);
 
    SquareInfo gridSquareInfo[kDisplayHeight][kDisplayWidth]{};
 
    // adjust note parameters
    void adjustVelocity(int32_t velocityChange, bool display_value = true);
    void updateVelocityValue(int32_t& velocityValue, int32_t newVelocity);
    void displayVelocity(int32_t velocityValue, int32_t velocityChange);
    void popupVelocity(char const* displayString);
 
    void handleProbabilityOrIteranceEditing(int8_t offset, bool editNoteRow);
    void adjustNoteProbabilityWithOffset(int32_t offset);
    void adjustNoteIteranceWithOffset(int32_t offset, bool allowTogglingBetweenPresetsAndCustom = true);
    void adjustNoteIteranceWithFinalValue(Iterance finalValue);
    void adjustNoteFillWithOffset(int32_t offset);
    Note* getLeftMostNotePressed();
    void adjustNoteParameterValue(int32_t withOffset, int32_t withFinalValue, int32_t changeType,
                                  int32_t parameterMinValue, int32_t parameterMaxValue,
                                  bool allowTogglingBetweenPresetsAndCustom = true);
 
    // other note functions
    void editNoteRepeat(int32_t offset);
 
    // pulse selected note
    void pulseSelectedNote();
 
    // note row editor
    bool enterNoteRowEditor();
    void exitNoteRowEditor();
    bool handleNoteRowEditorPadAction(int32_t x, int32_t y, int32_t on);
    bool handleNoteRowEditorMainPadAction(int32_t x, int32_t y, int32_t on);
    void handleNoteRowEditorAuditionPadAction(int32_t y);
    void copyNotesToFile(Serializer& writer, bool selectedDrumOnly = false);
    Error pasteNotesFromFile(Deserializer& reader, bool overwriteExisting, bool noScaling, bool previewOnly,
                             bool selectedDrumOnly);
    void patternPreview();
    void patternClear();
    ActionResult handleNoteRowEditorVerticalEncoderAction(int32_t offset, bool inCardRoutine);
    ActionResult handleNoteRowEditorHorizontalEncoderAction(int32_t offset);
    ActionResult handleNoteRowEditorButtonAction(deluge::hid::Button b, bool on, bool inCardRoutine);
 
    // adjust note row parameters
    int32_t setNoteRowProbabilityWithOffset(int32_t offset);
    int32_t setNoteRowIteranceWithOffset(int32_t offset, bool allowTogglingBetweenPresetsAndCustom = true);
    int32_t setNoteRowIteranceWithFinalValue(Iterance finalValue);
    int32_t setNoteRowFillWithOffset(int32_t offset);
    int32_t setNoteRowParameterValue(int32_t withOffset, int32_t withFinalValue, int32_t changeType,
                                     int32_t parameterMinValue, int32_t parameterMaxValue,
                                     bool allowTogglingBetweenPresetsAndCustom = true);
    // other note row functions
    ModelStackWithNoteRow* createNoteRowForYDisplay(ModelStackWithTimelineCounter* modelStack, int32_t yDisplay);
    ModelStackWithNoteRow* getOrCreateNoteRowForYDisplay(ModelStackWithTimelineCounter* modelStack, int32_t yDisplay);
    void commandEuclidean(int32_t offset);
    void editNumEuclideanEvents(ModelStackWithNoteRow* modelStack, int32_t offset, int32_t yDisplay);
    void editNoteRowLength(int32_t offset);
    void rotateNoteRowHorizontally(int32_t offset);
    void editNoteRowLength(ModelStackWithNoteRow* modelStack, int32_t offset, int32_t yDisplay);
    void noteRowChanged(InstrumentClip* clip, NoteRow* noteRow) override;
 
    // blink selected note row
    void blinkSelectedNoteRow(int32_t whichMainRows = 0);
    void resetSelectedNoteRowBlinking();
    bool noteRowFlashOn;
    bool noteRowBlinking;
 
    const char* getFillString(uint8_t fill);
 
    // public for velocity keyboard view to access
    void enterDrumCreator(ModelStackWithNoteRow* modelStack, bool doRecording = false);
 
    ModControllableAudio* getModControllableAudioOrNone() override;
 
private:
    bool doneAnyNudgingSinceFirstEditPadPress{};
    bool offsettingNudgeNumberDisplay{};
 
    uint8_t flashScaleModeLedErrorCount{};
 
    Drum* selectedDrum{};
 
    Drum* drumForNewNoteRow{};
    uint8_t yDisplayOfNewNoteRow{};
 
    int32_t quantizeAmount{};
    uint32_t timeSongButtonPressed{};
    // Set once a held Session button passes the long-press threshold, so short presses never flash macro colours into
    // the sidebar on their way to Session view.
    bool sessionMacroSidebarActive{};
 
    std::array<RGB, kDisplayHeight> rowColour;
    std::array<RGB, kDisplayHeight> rowTailColour;
    std::array<RGB, kDisplayHeight> rowBlurColour;
 
    // note functions
    void nudgeNotes(int32_t offset);
    void displayProbability(uint8_t probability, bool prevBase);
    void displayIterance(Iterance iterance);
    void displayFill(uint8_t mode);
 
    // note editor functions
    // note editor selected / remembered note targets
    Note* get_remembered_note(int32_t selection_index = -1);
    ModelStackWithNoteRow* get_note_edit_row(ModelStackWithTimelineCounter* model_stack, const EditPadPress& target);
    EditPadPress remembered_notes[kEditPadPressBufferSize]{};
    int32_t remembered_note_row_ids[kEditPadPressBufferSize]{};
    int32_t remembered_note_count = 0;
 
    // note editor selected note pulsing
    void render_selected_note_pulse(uint32_t which_rows, RGB image[][kDisplayWidth + kSideBarWidth]);
    void render_selected_square_pulse(int32_t selection_index, uint32_t which_rows,
                                      RGB image[][kDisplayWidth + kSideBarWidth], uint32_t* pulsed_columns);
    void stopSelectedNotePulsing();
    int32_t note_pulse_progress = 1;
    bool note_pulse_increasing = true;
    RGB note_pulse_base_colours[kDisplayHeight][kDisplayWidth]{};
    bool updating_note_pulse_directly = false;
 
    // note row functions
    void copyNotes(Serializer* writer, bool selectedDrumOnly = false);
    void pasteNotes(bool overwriteExisting = true, bool pasteFromFile = false, bool noScaling = false,
                    bool previewOnly = false, bool selectedDrumOnly = false);
    void deleteCopiedNoteRows();
    CopiedNoteRow* firstCopiedNoteRow;
    int32_t copiedScreenWidth{};
    ScaleType copiedScaleType{};
    int16_t copiedYNoteOfBottomRow{};
 
    void rotateNoteRowHorizontally(ModelStackWithNoteRow* modelStack, int32_t offset, int32_t yDisplay,
                                   bool shouldDisplayDirectionEvenIfNoNoteRow = false);
 
    Drum* getNextDrum(Drum* oldDrum, bool mayBeNone = false);
    Drum* flipThroughAvailableDrums(int32_t newOffset, Drum* drum, bool mayBeNone = false);
    NoteRow* getOrCreateEmptyNoteRowForKit(ModelStackWithTimelineCounter* modelStack, int32_t yDisplay,
                                           int32_t* getIndex = nullptr);
    void createDrumForAuditionedNoteRow(DrumType drumType);
    bool isRowAuditionedByInstrument(int32_t yDisplay);
 
    // TEMPO encoder commands
    void commandQuantizeNotes(int8_t offset, NudgeMode nudgeMode);
    void commandStartQuantize(int8_t offset, NudgeMode nudgeMode);
    void silenceAllAuditions();
 
    // auditionPadAction functions
    Drum* getAuditionedDrum(int32_t velocity, int32_t yDisplay, bool shiftButtonDown, Instrument* instrument,
                            ModelStackWithTimelineCounter* modelStackWithTimelineCounter,
                            ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip);
    void recordNoteOff(int32_t yDisplay, ModelStackWithNoteRow* modelStackWithNoteRowOnCurrentClip);
    int32_t getVelocityToSound(int32_t velocity);
};
 
extern InstrumentClipView instrumentClipView;