Momentum-Apps/input/pattern.c

#include "pattern.h"

uint8_t get_field(uint8_t patternx)
{
    uint8_t field = 0;

    if (patternx <= 1)
        field = 0;
    if (patternx == 2)
        field = 1;
    if (patternx == 3)
        field = 2;
    if (patternx > 3)
        field = 3;

    return field;
}

void edit_note(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta) // here we need data about last note if we place a new note
{
    int16_t note = tracker_engine_get_note(step);

    if (note == MUS_NOTE_RELEASE)
    {
        if (delta < 0)
        {
            set_note(step, MUS_NOTE_CUT);
        }

        return;
    }

    if (note == MUS_NOTE_CUT)
    {
        if (delta > 0)
        {
            set_note(step, MUS_NOTE_RELEASE);
        }

        return;
    }

    if (note == MUS_NOTE_NONE)
    {
        note = tracker->current_note; // remember which note we entered earlier and use it as reference
    }

    clamp(note, delta, 0, MAX_NOTE);

    set_note(step, (uint8_t)note);
    set_instrument(step, tracker->current_instrument);

    tracker->current_note = (uint8_t)note;
}

void edit_instrument(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta)
{
    int16_t inst = tracker_engine_get_instrument(step);

    if (inst == MUS_NOTE_INSTRUMENT_NONE)
    {
        if (delta > 0)
        {
            inst = 0;
        }

        else
        {
            inst = MUS_NOTE_INSTRUMENT_NONE - 1;
        }
    }

    clamp(inst, delta, 0, tracker->song.num_instruments - 1);
    tracker->current_instrument = inst; // remember last instrument
    set_instrument(step, (uint8_t)inst);
}

void edit_volume(TrackerSongPatternStep *step, int8_t delta)
{
    int16_t vol = tracker_engine_get_volume(step);

    if (vol == MUS_NOTE_VOLUME_NONE)
    {
        if (delta > 0)
        {
            vol = 0;
        }

        else
        {
            vol = MUS_NOTE_VOLUME_NONE - 1;
        }
    }

    clamp(vol, delta, 0, MUS_NOTE_VOLUME_NONE - 1);

    set_volume(step, (uint8_t)vol);
}

void edit_command(TrackerSongPatternStep *step, uint8_t digit, int8_t delta)
{
    int32_t command = tracker_engine_get_command(step);

    switch (digit)
    {
        case 0: // upper 7 bits
        {
            int16_t fx_name = ((command & 0x7f00) >> 8);

            if (fx_name + delta > 35) // loop
            {                         // 0-9 and then A-Z
                fx_name = 0;
            }

            else if (fx_name + delta < 0)
            {
                fx_name = 35;
            }

            else
            {
                fx_name += delta;
            }

            command &= 0x00ff;

            command |= (fx_name << 8);

            set_command(step, (uint16_t)command);

            break;
        }

        case 1: // upper digit of command param
        {
            int8_t upper_digit = ((command & 0x00f0) >> 4);

            if (upper_digit + delta > 0xf) // loop
            {
                upper_digit = 0;
            }

            else if (upper_digit + delta < 0)
            {
                upper_digit = 0xf;
            }

            else
            {
                upper_digit += delta;
            }

            command &= 0xff0f;

            command |= (upper_digit << 4);

            set_command(step, (uint16_t)command);

            break;
        }

        case 2: // lower digit of command param
        {
            int8_t lower_digit = (command & 0x000f);

            if (lower_digit + delta > 0xf) // loop
            {
                lower_digit = 0;
            }

            else if (lower_digit + delta < 0)
            {
                lower_digit = 0xf;
            }

            else
            {
                lower_digit += delta;
            }

            command &= 0xfff0;

            command |= lower_digit;

            set_command(step, (uint16_t)command);

            break;
        }

        default:
            break;
    }
}

void delete_field(TrackerSongPatternStep *step, uint8_t field)
{
    switch (field)
    {
        case 0: // note
        {
            set_note(step, MUS_NOTE_NONE);
            set_instrument(step, MUS_NOTE_INSTRUMENT_NONE); // also delete instrument
            break;
        }

        case 1: // instrument
        {
            set_instrument(step, MUS_NOTE_INSTRUMENT_NONE);
            break;
        }

        case 2: // volume
        {
            set_volume(step, MUS_NOTE_VOLUME_NONE);
            break;
        }

        case 3: // command
        {
            set_command(step, 0);
            break;
        }

        default:
            break;
    }
}

void edit_pattern_step(FlizzerTrackerApp *tracker, TrackerSongPatternStep *step, int8_t delta)
{
    switch (get_field(tracker->patternx))
    {
        case 0: // note
        {
            if (tracker->patternx) // editing octave
            {
                edit_note(tracker, step, 12 * delta);
            }

            else // editing note
            {
                edit_note(tracker, step, delta);
            }

            break;
        }

        case 1: // instrument
        {
            edit_instrument(tracker, step, delta);
            break;
        }

        case 2: // volume
        {
            edit_volume(step, delta);
            break;
        }

        case 3: // command
        {
            uint8_t digit = 0;
            if (tracker->patternx == 4)
                digit = 0;
            if (tracker->patternx == 5)
                digit = 1;
            if (tracker->patternx == 6)
                digit = 2;
            edit_command(step, digit, delta);
            break;
        }

        default:
            break;
    }
}

void pattern_edit_event(FlizzerTrackerApp *tracker, FlizzerTrackerEvent *event)
{
    if (event->input.key == InputKeyDown && event->input.type == InputTypeLong && !(tracker->editing))
    {
        flipbit(tracker->tracker_engine.channel[tracker->current_channel].channel_flags, TEC_DISABLED);
        return;
    }

    if (event->input.key == InputKeyUp && event->input.type == InputTypeLong && !(tracker->editing))
    {
        tracker->tracker_engine.pattern_position = 0; // return to pattern 1st row
        return;
    }

    uint8_t sequence_position = tracker->tracker_engine.sequence_position;
    uint8_t current_pattern = tracker->tracker_engine.song->sequence.sequence_step[sequence_position].pattern_indices[tracker->current_channel];
    uint16_t pattern_step = tracker->tracker_engine.pattern_position;

    uint16_t pattern_length = tracker->tracker_engine.song->pattern_length;

    TrackerSongPattern *pattern = &tracker->tracker_engine.song->pattern[current_pattern];

    TrackerSongPatternStep *step = NULL;

    if (pattern_step < pattern_length)
    {
        step = &pattern->step[pattern_step];
    }

    if (!(step))
        return;

    if (event->input.key == InputKeyOk && event->input.type == InputTypeShort && !tracker->tracker_engine.playing)
    {
        tracker->editing = !tracker->editing;
    }

    if (event->input.key == InputKeyOk && event->input.type == InputTypeLong)
    {
        if (!(tracker->editing))
        {
            if (tracker->tracker_engine.playing)
            {
                stop_song(tracker);
            }

            else
            {
                play_song(tracker, true);
            }
        }

        else
        {
            if (get_field(tracker->patternx) == 0)
            {
                set_note(step, MUS_NOTE_RELEASE);
            }
        }
    }

    if (event->input.key == InputKeyRight && event->input.type == InputTypeShort && tracker->editing)
    {
        tracker->patternx++;

        if (tracker->patternx > MAX_PATTERNX - 1)
        {
            tracker->current_channel++;

            tracker->patternx = 0;

            if (tracker->current_channel > SONG_MAX_CHANNELS - 1)
            {
                tracker->current_channel = 0;
            }
        }
    }

    if (event->input.key == InputKeyLeft && event->input.type == InputTypeShort && tracker->editing)
    {
        tracker->patternx--;

        if (tracker->patternx > MAX_PATTERNX - 1) // unsigned int overflow
        {
            tracker->current_channel--;

            tracker->patternx = MAX_PATTERNX - 1;

            if (tracker->current_channel > SONG_MAX_CHANNELS - 1) // unsigned int overflow
            {
                tracker->current_channel = SONG_MAX_CHANNELS - 1;
            }
        }
    }

    if (event->input.key == InputKeyDown && event->input.type == InputTypeShort)
    {
        if (!(tracker->editing))
        {
            tracker->tracker_engine.pattern_position++;

            if (tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1 && tracker->tracker_engine.sequence_position < tracker->tracker_engine.song->num_sequence_steps - 1)
            {
                tracker->tracker_engine.pattern_position = 0;
                tracker->tracker_engine.sequence_position++;
            }

            else if (tracker->tracker_engine.pattern_position > tracker->tracker_engine.song->pattern_length - 1)
            {
                tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
            }
        }

        if (tracker->editing)
        {
            edit_pattern_step(tracker, step, -1);
        }
    }

    if (event->input.key == InputKeyUp && event->input.type == InputTypeShort)
    {
        if (!(tracker->editing))
        {
            int16_t temp_pattern_position = tracker->tracker_engine.pattern_position - 1;

            if (temp_pattern_position < 0)
            {
                if (tracker->tracker_engine.sequence_position > 0)
                {
                    tracker->tracker_engine.sequence_position--;
                    tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1;
                }
            }

            else
            {
                tracker->tracker_engine.pattern_position--;
            }
        }

        if (tracker->editing)
        {
            edit_pattern_step(tracker, step, 1);
        }
    }

    if (event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->editing)
    {
        uint8_t field = get_field(tracker->patternx);

        delete_field(step, field);
    }
}