Bresenham.littlefoot

/*
<metadata description="Euclidean Rhythm Generator"
    details="Four tracks of Euclidean rhythms with length up to 99."
    target="Lightpad"
    tags="MIDI;Generator;">
    <groups>
        <group name="note"   displayName="Notes" />
        <group name="colour" displayName="Colors" />
    </groups>
    <variables>
        <variable name="channel" displayName="MIDI Channel" type="int" min="1" max="16" value="1" />

        <variable group="note" name="note0" displayName="Note 1" type="midiNote" value="A2" />
        <variable group="note" name="note1" displayName="Note 2" type="midiNote" value="C3" />
        <variable group="note" name="note2" displayName="Note 3" type="midiNote" value="E3" />
        <variable group="note" name="note3" displayName="Note 4" type="midiNote" value="G3" />

        <variable group="colour" name="colour0" displayName="Color 1" type="colour" value="0x800000" />
        <variable group="colour" name="colour1" displayName="Color 2" type="colour" value="0x000080" />
        <variable group="colour" name="colour2" displayName="Color 3" type="colour" value="0x008000" />
        <variable group="colour" name="colour3" displayName="Color 4" type="colour" value="0x808000" />
    </variables>
</metadata>
*/

//-Declare Variables------------------------------------------------------------

// Lookup Tables
int colour[4], note[4], msInterval[15];

// Clock
int loggedTime;

// Tracks
bool track0[99], track1[99], track2[99], track3[99], playing[4];
int  length[4], pulses[4], position[4];

// UI
bool sliderActive;
int  activeTrack, sliderX;

//-Initialise-------------------------------------------------------------------

void sendAllNotesOff()
{
    for (int i = 0; i<128; ++i)
    {
        sendNoteOff(0, i, 0);
    }
}

void initialise()
{
    clearDisplay();
    sendAllNotesOff();

    for (int i = 0; i < 15; ++i)
    {
        msInterval[i] = 45 * (14-i);
    }

    for (int i = 0; i < 4; ++i)
    {
        length[i] = 16;
    }

    sliderX = 7;

    note[0] = note0;
    note[1] = note1;
    note[2] = note2;
    note[3] = note3;

    colour[0] = colour0;
    colour[1] = colour1;
    colour[2] = colour2;
    colour[3] = colour3;
}

//-Repaint----------------------------------------------------------------------

bool waitedLongEnough()
{
    int t = getMillisecondCounter();
    if (t - loggedTime >= msInterval[sliderX])
    {
        loggedTime = t;
        return true
    }
    return false
}

void drawDigit(int digit, int colour, int x, int y)
{
    if (digit == 1)                                  // one rectangle sufficient
    {
        fillRect(colour, x + 2, y, 1, 5);
    }
    else                                              // >1 rectangles necessary
    {
        // draw first rectangle
        fillRect(colour, x, y, 3, 5);
        if (digit % 7 == 0)                         // two rectangles sufficient
        {
            // draw second rectangle
            if (digit == 0)
            {
                fillRect(0x000000, x + 1, y + 1, 1, 3);
            }
            else if (digit == 7)
            {
                fillRect(0x000000, x, y+1, 2, 4);
            }
        }
        else                                      // three rectangles sufficient
        {
            // draw second rectangle
            if (digit == 2 || digit == 3)
            {
                fillRect(0x000000, x, y + 1, 2, 1);
            }
            else if (digit == 5 || digit == 6)
            {
                fillRect(0x000000, x + 1, y + 1, 2, 1);
            }
            else if (digit == 8 || digit == 9)
            {
                fillRect(0x000000, x + 1, y + 1, 1, 1);
            }
            else if (digit == 4)
            {
              fillRect(0x000000, x + 1, y, 1, 2);
            }

            // draw third rectangle
            if (digit % 2 == 1)
            {
                fillRect(0x000000, x, y + 3, 2, 1);
            }
            else if (digit > 5)
            {
                fillRect(0x000000, x + 1, y + 3, 1, 1);
            }
            else if (digit == 2)
            {
                fillRect(0x000000, x + 1, y + 3, 2, 1);
            }
            else if (digit == 4)
            {
                fillRect(0x000000, x, y + 3, 2, 2);
            }
        }
    }
}

void repaint()
{
    clearDisplay();

    drawDigit(pulses[activeTrack] / 10, 0x808080,             0, 0);
    drawDigit(pulses[activeTrack] % 10, 0x808080,             4, 0);
    drawDigit(length[activeTrack] / 10, colour[activeTrack],  8, 0);
    drawDigit(length[activeTrack] % 10, colour[activeTrack], 12, 0);

    // draw slider
    fillRect(0x080808, 0, 7, 15, 1);
    fillRect(0x808080, sliderX, 6, 1, 3);

    // draw play/pause
    for (int i = 0; i < 4; ++i)
    {
        if (playing[i])
        {
            fillRect(colour[i],  4*i,     10, 1, 5);
            fillRect(colour[i],  4*i + 1, 11, 1, 3);
            fillRect(colour[i],  4*i + 2, 12, 1, 1);
        }
        else
        {
            fillRect(colour[i],  4*i,     11, 3, 3);
        }
    }

    if (playing[0] || playing[1] || playing[2] || playing[3])
    {
        if (waitedLongEnough())
        {
            if (playing[0])
            {
                if (track0[position[0]])
                {
                    sendNoteOn (channel - 1, note[0], 127);
                    blendRect(0x30ffffff,  0, 10, 1, 5);
                    blendRect(0x30ffffff,  1, 11, 1, 3);
                    blendRect(0x30ffffff,  2, 12, 1, 1);
                    sendNoteOff(channel - 1, note[0],   0);
                }
                position[0] = (position[0]+1) % length[0];
            }
            if (playing[1])
            {
                if (track1[position[1]])
                {
                    sendNoteOn (channel - 1, note[1], 127);
                    blendRect(0x30ffffff,  4, 10, 1, 5);
                    blendRect(0x30ffffff,  5, 11, 1, 3);
                    blendRect(0x30ffffff,  6, 12, 1, 1);
                    sendNoteOff(channel - 1, note[1],   0);
                }
                position[1] = (position[1]+1) % length[1];
            }
            if (playing[2])
            {
                if (track2[position[2]])
                {
                    sendNoteOn (channel - 1, note[2], 127);
                    blendRect(0x30ffffff,  8, 10, 1, 5);
                    blendRect(0x30ffffff,  9, 11, 1, 3);
                    blendRect(0x30ffffff,  10, 12, 1, 1);
                    sendNoteOff(channel - 1, note[2],   0);
                }
                position[2] = (position[2]+1) % length[2];
            }
            if (playing[3])
            {
                if (track3[position[3]])
                {
                    sendNoteOn (channel - 1, note[3], 127);
                    blendRect(0x30ffffff,  12, 10, 1, 5);
                    blendRect(0x30ffffff,  13, 11, 1, 3);
                    blendRect(0x30ffffff,  14, 12, 1, 1);
                    sendNoteOff(channel - 1, note[3],   0);
                }
                position[3] = (position[3]+1) % length[3];
            }
        }
    }
}

//-Handle Button----------------------------------------------------------------

void handleButtonDown(int index)
{
    activeTrack = (activeTrack + 1) % 4;
}

//-Handle Touch-----------------------------------------------------------------

int convertPositionToPixel (float pos)                   // copied from pselodux
{
    return int ((map(pos, 0.0, 1.9, 0.15, 4.7)) * 3);
}

void updateTrack0()                                     // Bresenham's algorithm
{
    int remainder = -pulses[0];

    for (int i = 0; i < length[0]; ++i)
    {
        if (remainder < 0)
        {
            track0[i] = true;
            remainder += length[0];
        }
        else
        {
            track0[i] = false;
        }
        remainder -= pulses[0];
    }
}

void updateTrack1()
{
    int remainder = -pulses[1];

    for (int i = 0; i < length[1]; ++i)
    {
        if (remainder < 0)
        {
            track1[i] = true;
            remainder += length[1];
        }
        else
        {
            track1[i] = false;
        }
        remainder -= pulses[1];
    }
}

void updateTrack2()
{
    int remainder = -pulses[2];

    for (int i = 0; i < length[2]; ++i)
    {
        if (remainder < 0)
        {
            track2[i] = true;
            remainder += length[2];
        }
        else
        {
            track2[i] = false;
        }
        remainder -= pulses[2];
    }
}

void updateTrack3()
{
    int remainder = -pulses[3];

    for (int i = 0; i < length[3]; ++i)
    {
        if (remainder < 0)
        {
            track3[i] = true;
            remainder += length[3];
        }
        else
        {
            track3[i] = false;
        }
        remainder -= pulses[3];
    }
}

void updateTrack()
{
    if (activeTrack == 0)
    {
        updateTrack0();
    }
    else if (activeTrack == 1)
    {
        updateTrack1();
    }
    else if (activeTrack == 2)
    {
        updateTrack2();
    }
    else if (activeTrack == 3)
    {
        updateTrack3();
    }
}

void touchStart (int index, float x, float y, float z, float vz)
{
    int xPixel = convertPositionToPixel(x);
    int yPixel = convertPositionToPixel(y);
    
    if (index == 1)
    {
        if (yPixel < 3 && xPixel % 4 != 3)                           // digit up
        {
            bool returnToPlaying = playing[activeTrack];
            playing[activeTrack] = false;

            if (xPixel < 7)                                       // more pulses
            {
                pulses[activeTrack] += (xPixel < 4 ? 10 : 1);
                pulses[activeTrack] = min(99, pulses[activeTrack]);
                length[activeTrack] = max(pulses[activeTrack],
                                          length[activeTrack]);
            }
            else if (xPixel > 7)                                 // longer track
            {
                length[activeTrack] += (xPixel < 11 ? 10 : 1);
                length[activeTrack] = min(99, length[activeTrack]);
            }
            updateTrack();
            playing[activeTrack] = returnToPlaying;
        }
        else if (3 < yPixel && yPixel < 6 && xPixel % 4 != 3)      // digit down
        {
            bool returnToPlaying = playing[activeTrack];
            playing[activeTrack] = false;

            if (xPixel < 7)                                      // fewer pulses
            {
                pulses[activeTrack] -= (xPixel < 4 ? 10 : 1);
                pulses[activeTrack] = max(0, pulses[activeTrack]);
            }
            else if (xPixel > 7)                                // shorter track
            {
                length[activeTrack] -= (xPixel < 11 ? 10 : 1);
                length[activeTrack] = max(1, length[activeTrack]);
                pulses[activeTrack] = min(pulses[activeTrack],
                                          length[activeTrack]);
            }
            updateTrack();
            playing[activeTrack] = returnToPlaying;
        }
        else if (5 < yPixel && yPixel < 9)                        // move slider
        {
            sliderX = xPixel;
            sliderActive = true;
        }
    }

    if (9 < yPixel && xPixel % 4 != 3)                             // play/pause
    {
        int button = xPixel / 4;
        playing[button] = ! playing[button];
        if (! playing[button])
        {
            position[button] = 0;
        }
    }
}

void touchMove (int index, float x, float y, float z, float vz)
{
    if (index == 1 && sliderActive)
    {
        int xPixel = convertPositionToPixel(x);
        sliderX = xPixel;
    }
}

void touchEnd (int index, float x, float y, float z, float vz)
{
    if (index == 1 && sliderActive)
    {
        sliderActive = false;
    }
}