Momentum-Apps/view/instrument_editor.c

#include "instrument_editor.h"
#include "pattern_editor.h"

#include "../macros.h"
#include "opcode_description.h"

#include <flizzer_tracker_icons.h>

void draw_inst_flag(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint16_t flags, uint16_t mask)
{
    canvas_draw_icon(canvas, x, y - 5, ((flags & mask) ? &I_checkbox_checked : &I_checkbox_empty));
    canvas_draw_str(canvas, x + 6, y, text);

    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
    {
        if (text[strlen(text) - 1] == ':')
        {
            canvas_draw_box(canvas, x + 5, y - 6, strlen(text) * 4 - 1, 7);
        }

        else
        {
            canvas_draw_box(canvas, x + 5, y - 6, strlen(text) * 4 + 1, 7);
        }
    }
}

void draw_inst_text_one_digit(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t value) // text MUST end with semicolon
{
    canvas_draw_str(canvas, x, y, text);
    char buffer[4];
    snprintf(buffer, sizeof(buffer), "%01X", (value & 0xF));
    canvas_draw_str(canvas, x + strlen(text) * 4 - 2, y, buffer);

    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
    {
        canvas_draw_box(canvas, x + strlen(text) * 4 - 3, y - 6, 5, 7);
    }
}

void draw_inst_text_two_digits(FlizzerTrackerApp *tracker, Canvas *canvas, uint8_t focus, uint8_t param, const char *text, uint8_t x, uint8_t y, uint8_t value) // text MUST end with semicolon
{
    canvas_draw_str(canvas, x, y, text);
    char buffer[4];
    snprintf(buffer, sizeof(buffer), "%02X", value);
    canvas_draw_str(canvas, x + strlen(text) * 4 - 2, y, buffer);

    if (tracker->focus == focus && tracker->selected_param == param && tracker->editing)
    {
        canvas_draw_box(canvas, x + strlen(text) * 4 + 4 * tracker->current_digit - 3, y - 6, 5, 7);
    }
}

static const char *filter_types[] =
    {
        "NONE",
        "LOW",
        "HIGH",
        "BAND",
        "LOHI",
        "HIBD",
        "LOBD",
        "ALL",
};

static const char *instrument_editor_params_description[] =
    {
        "CURRENT INSTRUMENT",
        "CURRENT INSTRUMENT NAME",
        "INSTRUMENT BASE NOTE",
        "INSTRUMENT FINETUNE",
        "SLIDE SPEED",
        "SET PULSE WIDTH ON KEYDOWN",
        "PULSE WIDTH",
        "SET FILTER PARAMETERS ON KEYDOWN",
        "NOISE WAVEFORM",
        "PULSE WAVEFORM",
        "TRIANGLE WAVEFORM",
        "SAWTOOTH WAVEFORM",
        "METALLIC NOISE WAVEFORM",
        "SINE WAVEFORM",
        "ENVELOPE ATTACK",
        "ENVELOPE DECAY",
        "ENVELOPE SUSTAIN",
        "ENVELOPE RELEASE",
        "ENVELOPE VOLUME",
        "ENABLE FILTER",
        "FILTER CUTOFF FREQUENCY",
        "FILTER RESONANCE",
        "FILTER TYPE (NONE=OFF)",
        "ENABLE RING MODULATION",
        "RINGMOD SOURCE CHANNEL (F=SELF)",
        "ENABLE HARD SYNC",
        "HARDSYNC SOURCE CHANNEL (F=SELF)",
        "RETRIGGER INSTRUMENT ON SLIDE",
        "SYNC OSCILLATORS ON KEYDOWN",
        "ENABLE VIBRATO",
        "VIBRATO SPEED",
        "VIBRATO DEPTH",
        "VIBRATO DELAY (IN TICKS)",
        "ENABLE PWM",
        "PWM SPEED",
        "PWM DEPTH",
        "PWM DELAY (IN TICKS)",
        "DON'T RESTART PROGRAM ON KEYDOWN",
        "PROG.PERIOD (00 = PROGRAM OFF)",
};

void draw_instrument_view(Canvas *canvas, FlizzerTrackerApp *tracker)
{
    SoundEngineChannel *se_channel = &tracker->sound_engine.channel[0];
    if (!(se_channel->flags & SE_ENABLE_GATE) && tracker->tracker_engine.song == NULL)
    {
        stop();
        tracker->tracker_engine.playing = false;
        tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
    }

    char buffer[30];
    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
    uint8_t shift = tracker->inst_editor_shift;

    if (shift < 6)
    {
        snprintf(buffer, sizeof(buffer), "INST:%c", to_char(tracker->current_instrument));
        draw_generic_n_digit_field(tracker, canvas, EDIT_INSTRUMENT, INST_CURRENTINSTRUMENT, buffer, 0, 5 - shift, 1);
        snprintf(buffer, sizeof(buffer), "%s", tracker->song.instrument[tracker->current_instrument]->name);
        draw_generic_n_digit_field(tracker, canvas, EDIT_INSTRUMENT, INST_INSTRUMENTNAME, buffer, 4 * 7 - 1, 5 - shift, 1);
    }

    if (shift < 12)
    {
        snprintf(buffer, sizeof(buffer), "NOTE:%s", notename(inst->base_note));
        canvas_draw_str(canvas, 0, 11 - shift, buffer);

        if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_CURRENT_NOTE)
        {
            if (tracker->current_digit)
            {
                canvas_draw_box(canvas, 19 + 2 * 4, 5 - shift, 5, 7);
            }

            else
            {
                canvas_draw_box(canvas, 19, 5 - shift, 5 + 4, 7);
            }
        }

        snprintf(buffer, sizeof(buffer), "FINE:%+02d", inst->finetune);
        canvas_draw_str(canvas, 37, 11 - shift, buffer);

        if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_FINETUNE)
        {
            if (tracker->current_digit)
            {
                canvas_draw_box(canvas, 60 + 4, 5 - shift, 5, 7);
            }

            else
            {
                canvas_draw_box(canvas, 60, 5 - shift, 5, 7);
            }
        }
    }

    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_SLIDESPEED, "SL.SPD:", 0, 17 - shift, inst->slide_speed);

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_SETPW, "PW:", 36, 17 - shift, inst->flags, TE_SET_PW);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PW, "", 54, 17 - shift, inst->pw);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_SETCUTOFF, "CUT", 61, 17 - shift, inst->flags, TE_SET_CUTOFF);

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_NOISE, "N", 0, 23 - shift, inst->waveform, SE_WAVEFORM_NOISE);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_PULSE, "P", 10, 23 - shift, inst->waveform, SE_WAVEFORM_PULSE);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_TRIANGLE, "T", 20, 23 - shift, inst->waveform, SE_WAVEFORM_TRIANGLE);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_SAWTOOTH, "S", 30, 23 - shift, inst->waveform, SE_WAVEFORM_SAW);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_NOISE_METAL, "M", 40, 23 - shift, inst->waveform, SE_WAVEFORM_NOISE_METAL);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_WAVE_SINE, "SINE", 50, 23 - shift, inst->waveform, SE_WAVEFORM_SINE);

    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_ATTACK, "A:", 0, 29 - shift, inst->adsr.a);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_DECAY, "D:", 16, 29 - shift, inst->adsr.d);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_SUSTAIN, "S:", 32, 29 - shift, inst->adsr.s);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_RELEASE, "R:", 48, 29 - shift, inst->adsr.r);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VOLUME, "V:", 64, 29 - shift, inst->adsr.volume);

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEFILTER, "FIL", 0, 35 - shift, inst->sound_engine_flags, SE_ENABLE_FILTER);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_FILTERCUTOFF, "CUT:", 20, 35 - shift, inst->filter_cutoff);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_FILTERRESONANCE, "RES:", 44, 35 - shift, inst->filter_resonance);

    snprintf(buffer, sizeof(buffer), "TYPE:%s", filter_types[inst->filter_type]);
    canvas_draw_str(canvas, 0, 41 - shift, buffer);

    if (tracker->editing && tracker->focus == EDIT_INSTRUMENT && tracker->selected_param == INST_FILTERTYPE)
    {
        canvas_draw_box(canvas, 19, 35 - shift, strlen(filter_types[inst->filter_type]) * 4 + 1, 7);
    }

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLERINGMOD, "R:", 38, 41 - shift, inst->sound_engine_flags, SE_ENABLE_RING_MOD);
    draw_inst_text_one_digit(tracker, canvas, EDIT_INSTRUMENT, INST_RINGMODSRC, "", 52, 41 - shift, inst->ring_mod);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEHARDSYNC, "H:", 56, 41 - shift, inst->sound_engine_flags, SE_ENABLE_HARD_SYNC);
    draw_inst_text_one_digit(tracker, canvas, EDIT_INSTRUMENT, INST_HARDSYNCSRC, "", 70, 41 - shift, inst->hard_sync);

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_RETRIGGERONSLIDE, "SL.RETRIG", 0, 47 - shift, inst->flags, TE_RETRIGGER_ON_SLIDE);
    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEKEYSYNC, "KSYNC", 44, 47 - shift, inst->sound_engine_flags, SE_ENABLE_KEYDOWN_SYNC);

    draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEVIBRATO, "VIB", 0, 53 - shift, inst->flags, TE_ENABLE_VIBRATO);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATOSPEED, "S:", 20, 53 - shift, inst->vibrato_speed);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATODEPTH, "D:", 36, 53 - shift, inst->vibrato_depth);
    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_VIBRATODELAY, "DEL:", 52, 53 - shift, inst->vibrato_delay);

    if (shift >= 6)
    {
        draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_ENABLEPWM, "PWM", 0, 59 - shift, inst->flags, TE_ENABLE_PWM);
        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMSPEED, "S:", 20, 59 - shift, inst->pwm_speed);
        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMDEPTH, "D:", 36, 59 - shift, inst->pwm_depth);
        draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PWMDELAY, "DEL:", 52, 59 - shift, inst->pwm_delay);
    }

    if (shift >= 12)
    {
        draw_inst_flag(tracker, canvas, EDIT_INSTRUMENT, INST_PROGRESTART, "NO PROG.RESTART", 0, 65 - shift, inst->flags, TE_PROG_NO_RESTART);
    }

    draw_inst_text_two_digits(tracker, canvas, EDIT_INSTRUMENT, INST_PROGRAMEPERIOD, "P.PERIOD:", 81, 56, inst->program_period);

    canvas_draw_line(canvas, 0, 57, 127, 57);
    canvas_draw_line(canvas, 79, 0, 79, 56);
    canvas_draw_line(canvas, 80, 49, 127, 49);

    if (tracker->focus == EDIT_INSTRUMENT)
    {
        canvas_draw_str(canvas, 0, 64, instrument_editor_params_description[tracker->selected_param]);
    }
}

char command_get_char(uint16_t command)
{
    if ((command >> 8) < 36)
    {
        return to_char_array[(command >> 8)];
    }

    if (command == TE_PROGRAM_END)
    {
        return ':';
    }

    if ((command & 0xff00) == TE_PROGRAM_JUMP)
    {
        return '^';
    }

    if ((command & 0xff00) == TE_PROGRAM_LOOP_END)
    {
        return '>';
    }

    if ((command & 0xff00) == TE_PROGRAM_LOOP_BEGIN)
    {
        return '<';
    }

    return '?';
}

void draw_program_step(Canvas *canvas, uint8_t y, FlizzerTrackerApp *tracker, uint8_t index)
{
    char buffer[15];

    Instrument *inst = tracker->song.instrument[tracker->current_instrument];
    uint16_t opcode = inst->program[index];

    if (opcode != TE_PROGRAM_NOP)
    {
        if ((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO)
        {
            if ((opcode & 0xff) != 0xf0 && (opcode & 0xff) != 0xf1)
            {
                snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename(my_min(12 * 7 + 11, (opcode & 0xff) + tracker->song.instrument[tracker->current_instrument]->base_note)));
            }

            else
            {
                snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename((opcode & 0xff)));
            }
        }

        else if ((opcode & 0x7f00) == TE_EFFECT_ARPEGGIO_ABS)
        {
            snprintf(buffer, sizeof(buffer), "%01X %c%02X F.%s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), notename(opcode & 0xff));
        }

        else
        {
            snprintf(buffer, sizeof(buffer), "%01X %c%02X %s", index, command_get_char(opcode & 0x7fff), (opcode & 0xff), get_opcode_description(opcode, true) ? get_opcode_description(opcode, true) : "");
        }

        if (opcode & 0x8000)
        {
            if (index == 0)
            {
                canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 3);
                canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 4);
            }

            if (index > 0 && !(inst->program[index - 1] & 0x8000))
            {
                canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 3);
                canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 4);
            }

            if (index > 0 && (inst->program[index - 1] & 0x8000))
            {
                canvas_draw_line(canvas, 84 + 4 * 4 + 2, y, 84 + 4 * 4 + 2, y - 5);
            }
        }

        else
        {
            if (index > 0 && (inst->program[index - 1] & 0x8000))
            {
                canvas_draw_line(canvas, 84 + 4 * 4 + 2, y - 3, 84 + 4 * 4 + 2, y - 5);
                canvas_draw_dot(canvas, 84 + 4 * 4 + 1, y - 2);
            }
        }
    }

    else
    {
        snprintf(buffer, sizeof(buffer), "%01X ---", index);
    }

    canvas_draw_str(canvas, 81, y, buffer);
}

void draw_instrument_program_view(Canvas *canvas, FlizzerTrackerApp *tracker)
{
    Instrument *inst = tracker->song.instrument[tracker->current_instrument];

    for (uint8_t i = tracker->program_position; i < my_min(INST_PROG_LEN, tracker->program_position + 8); i++)
    {
        draw_program_step(canvas, 6 + 6 * i - tracker->program_position * 6, tracker, i);

        if (i == tracker->current_program_step && tracker->focus == EDIT_PROGRAM)
        {
            if (tracker->editing)
            {
                canvas_draw_box(canvas, 80 + 8 + tracker->current_digit * 4, 6 * i - tracker->program_position * 6, 5, 7);
            }

            else
            {
                canvas_draw_box(canvas, 80, 6 * i - tracker->program_position * 6, 5, 7);
            }
        }
    }

    // draw arrow pointing at current program step

    for (uint8_t i = 0; i < SONG_MAX_CHANNELS; i++)
    {
        if (tracker->tracker_engine.channel[i].instrument == inst && (tracker->tracker_engine.channel[i].channel_flags & TEC_PROGRAM_RUNNING) && (tracker->tracker_engine.sound_engine->channel[i].flags & SE_ENABLE_GATE))
        {
            if (tracker->tracker_engine.channel[i].program_tick >= tracker->program_position && tracker->tracker_engine.channel[i].program_tick < tracker->program_position + 8)
            {
                canvas_draw_str(canvas, 85, 6 * tracker->tracker_engine.channel[i].program_tick - tracker->program_position * 6 + 6, ">");
                break;
            }
        }
    }

    if (tracker->focus == EDIT_PROGRAM)
    {
        uint16_t opcode = (inst->program[tracker->current_program_step] & 0x7fff);
        canvas_draw_str(canvas, 0, 64, get_opcode_description(opcode, false) ? get_opcode_description(opcode, false) : "");
    }
}