pixie_chroma_internal.cpp

Go to the documentation of this file.

 
// TODO: Make print() and write() calls allocate proper char array size
// ...for each variable type, instead of just 32 chars no matter the type.
 
#include "Pixie_Chroma.h" 
#include "utility/pixie_utility.h"
 
// ---------------------------------------------------------------------------------------------------------|
// -- PUBLIC CLASS FUNCTIONS -------------------------------------------------------------------------------|
// ---------------------------------------------------------------------------------------------------------|
 
//............................................................................
PixieChroma::PixieChroma(){}
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - SETUP %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::begin( const uint8_t data_pin, uint8_t pixies_x, uint8_t pixies_y ){
    pixie_pin = data_pin;
 
    chars_x = (pixies_x+1) * 2; // Pixies have two chars each, plus deadzone for scrolling
    chars_y = pixies_y;
 
    matrix_width  = display_width  * chars_x;
    matrix_height = display_height * chars_y;
 
    pixel_count = matrix_width * matrix_height;
 
    color_map = new CRGB[ pixel_count + 1 ]; // Hidden extra LED to write to if we call an out-of-bounds XY coordinate for color or mask
    mask      = new uint8_t[ pixel_count + 1 ];
    xy_table  = new int16_t[ pixel_count ];
 
    calc_xy(); // led_count is calculated here
 
    color_map_out = new CRGB[ led_count ];
    mask_out = new uint8_t[ led_count ];
 
    for( uint16_t i = 0; i < pixel_count; i++ ){
        color_map[i] = CRGB( 0, 255, 0 );
    }
 
    current_palette.loadDynamicGradientPalette( GREEN_SOLID );
 
    build_controller( pixie_pin ); // ----- Initialize FastLED
    set_color_animation( ANIMATION_NULL ); // --- Set animation function to an empty one
    clear(); // --------------------------- Clear anything in mask (should be empty anyways), reset cursor
    set_max_power( 5.0, 500 ); // --------- Set default power budget in volts and milliamps (5.0V, 500mA)
}
//............................................................................
void PixieChroma::begin_quad( uint8_t pixies_per_pin, uint8_t pixies_x, uint8_t pixies_y ){
    chars_x = (pixies_x+1) * 2; // Pixies have two chars each, plus deadzone for scrolling
    chars_y = pixies_y;
 
    matrix_width  = display_width  * chars_x;
    matrix_height = display_height * chars_y;
 
    pixel_count = matrix_width * matrix_height;
 
    color_map = new CRGB[ pixel_count + 1 ]; // Hidden extra LED to write to if we call an out-of-bounds XY coordinate for color or mask
    mask      = new uint8_t[ pixel_count + 1 ];
    xy_table  = new int16_t[ pixel_count ];
 
    calc_xy();
 
    color_map_out = new CRGB[ led_count ];
    mask_out = new uint8_t[ led_count ];
    
    for( uint16_t i = 0; i < led_count; i++ ){
        color_map[i] = CRGB( 0,255,0 );
    }
 
    current_palette.loadDynamicGradientPalette( GREEN_SOLID );
 
    #if defined( ARDUINO_ARCH_ESP8266 )
        // WS2811_PORTA on ESP8266 takes up GPIO 12, GPIO 13, GPIO 14 and GPIO 15 for Quad Mode
        FastLED.addLeds<WS2811_PORTA,4>( color_map_out, pixies_per_pin * leds_per_pixie ).setCorrection( TypicalLEDStrip ); // Initialize FastLED
    
    #elif defined( ARDUINO_ARCH_ESP32 )
        // Quad Mode on ESP32 takes up GPIO 12, GPIO 13, GPIO 14 and GPIO 27
        FastLED.addLeds<NEOPIXEL, 13>( // Initialize FastLED Data Out 1
            color_map_out,
            ( pixies_per_pin*leds_per_pixie ) * 0,
            ( pixies_per_pin*leds_per_pixie )
        ).setCorrection( TypicalLEDStrip ); 
        
        FastLED.addLeds<NEOPIXEL, 12>( // Initialize FastLED Data Out 2
            color_map_out,
            ( pixies_per_pin*leds_per_pixie ) * 1,
            ( pixies_per_pin*leds_per_pixie )
        ).setCorrection( TypicalLEDStrip );
        
        FastLED.addLeds<NEOPIXEL, 14>( // Initialize FastLED Data Out 3
            color_map_out,
            ( pixies_per_pin*leds_per_pixie ) * 2,
            ( pixies_per_pin*leds_per_pixie )
        ).setCorrection( TypicalLEDStrip );
        
        FastLED.addLeds<NEOPIXEL, 27>( // Initialize FastLED Data Out 4
            color_map_out,
            ( pixies_per_pin*leds_per_pixie ) * 3,
            ( pixies_per_pin*leds_per_pixie )
        ).setCorrection( TypicalLEDStrip );
        
    #elif defined( ARDUINO_ARCH_TEENSY_3_X )
        // WS2811_PORTD on TEENSY 3.X takes up GPIO 2, GPIO 14, GPIO 7 and GPIO 8 for Quad Mode
        FastLED.addLeds<WS2811_PORTD,4>( color_map_out, pixies_per_pin * leds_per_pixie ).setCorrection( TypicalLEDStrip ); // Initialize FastLED
    #endif
    
    set_color_animation( ANIMATION_NULL ); // --- Set animation function to an empty one
    clear(); // --------------------------- Clear anything in mask ( should be empty anyways ), reset cursor
    set_max_power( 5, 500 ); // ----------- Set default power budget in volts and milliamps
}
 
//............................................................................
void PixieChroma::set_color_animation( void ( *action )(PixieChroma*, float) ) {
    anim_func = action;
    if(anim_func == ANIMATION_NULL){
        custom_animation = false;
    }
    else{
        custom_animation = true;
    }
    clear();
    show();
}
 
//............................................................................
void PixieChroma::set_color_animation_speed( float speed ){
    animation_speed = speed;
}
 
//............................................................................
void PixieChroma::set_brightness( uint8_t level ){
    brightness_level = level;
}
 
//............................................................................
void PixieChroma::set_frame_rate_target( uint16_t target ){
    fps_target = target;
}
 
//............................................................................
void PixieChroma::set_gamma_correction( bool enabled ){
    correct_gamma = enabled;
}
 
//............................................................................
void PixieChroma::set_justification( t_justification justification, int16_t row ){
    if(row == -1){
        for(uint8_t i = 0; i < chars_y; i++){
            justifications[i] = justification;
        }
    }
    else{
        justifications[row] = justification;
    }
}
 
//............................................................................
void PixieChroma::set_line_wrap( bool enabled ){
    line_wrap = enabled;
}
 
//............................................................................
void PixieChroma::set_max_power( float volts, uint16_t milliamps ){
    max_V = volts;
    max_mA = milliamps;
}
 
//............................................................................
void PixieChroma::set_palette( const uint8_t* pal ){ 
    if(custom_animation == false){
        set_color_animation(ANIMATION_STATIC);
    }
    current_palette.loadDynamicGradientPalette( pal ); // GRADIENT PALETTE
    clear();
    show();
}
 
//............................................................................
void PixieChroma::set_palette( CRGBPalette16 pal ){ // STANDARD PALETTE
    if(custom_animation == false){
        set_color_animation(ANIMATION_STATIC);
    }
    current_palette = pal;
    clear();
    show();
}
 
//............................................................................
void PixieChroma::set_scroll_type(t_scroll_type type){
    scroll_type = type;
    
    if(scroll_type == INSTANT){
        scroll_frame_delay_ms = 0;
        scroll_hold_ms        = 150;
    }
    else if(scroll_type == SHIFT){
        scroll_frame_delay_ms = 10;
        scroll_hold_ms        = 80;
    }
    else if(scroll_type == SMOOTH){
        scroll_frame_delay_ms = 10;
        scroll_hold_ms        = 0;
    }
}
 
//............................................................................
void PixieChroma::set_update_mode( t_update_mode mode, uint16_t FPS ){
    if( mode == AUTOMATIC && ticker_running == false ){
        set_frame_rate_target( FPS );
        
        #if defined( ARDUINO_ARCH_ESP8266 ) || defined( ARDUINO_ARCH_ESP32 )
            animate.attach_ms<typeof this>(
                round(1000 / float(FPS)),
                [](typeof this _p){ _p->show(); },
               // This. ^ This is the magic sauce
               // right here. This is apparently how
               // you add a non-static class member to
               // Ticker from within a class and I
               // hate it. Readability sucks, oh well.
               // At least I got a Lambdaghini.
                this
            );
        #elif defined( ARDUINO_ARCH_TEENSY_3_X )
            animate.begin(
                [](typeof this _p){ _p->show(); },
                round(1000000 / float(FPS))
            );
            animate.priority(1);
        #endif
        
        ticker_running = true;
    }
    else if( mode == MANUAL && ticker_running == true ){
        #if defined( ARDUINO_ARCH_ESP8266 ) || defined( ARDUINO_ARCH_ESP32 )
            animate.detach();
        #elif defined( ARDUINO_ARCH_TEENSY_3_X )
            animate.end();
        #endif
        ticker_running = false;
    }
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - WRITE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::add_char( char chr, int16_t x_dest, int16_t y_dest ){
    color(print_col, x_dest/display_width, y_dest/display_height);
    
    if ( chr >= printable_ascii_offset ) {
        chr -= printable_ascii_offset;
    }
 
    for( uint8_t x = 0; x < font_col_width; x++ ){
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
 
        uint16_t row1_index = xy( x_dest+x, y_dest+0 );
        uint16_t row2_index = xy( x_dest+x, y_dest+1 );
        uint16_t row3_index = xy( x_dest+x, y_dest+2 );
        uint16_t row4_index = xy( x_dest+x, y_dest+3 );
        uint16_t row5_index = xy( x_dest+x, y_dest+4 );
        uint16_t row6_index = xy( x_dest+x, y_dest+5 );
        uint16_t row7_index = xy( x_dest+x, y_dest+6 );
 
        // "Subtract" from mask transparency with saturating function
        mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( column, 0 )] );
        mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( column, 1 )] );
        mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( column, 2 )] );
        mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( column, 3 )] );
        mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( column, 4 )] );
        mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( column, 5 )] );
        mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( column, 6 )] );
    }
}
 
//............................................................................
void PixieChroma::add_char( uint8_t bitmap_col_1, uint8_t bitmap_col_2, uint8_t bitmap_col_3, uint8_t bitmap_col_4, uint8_t bitmap_col_5, int16_t x_dest, int16_t y_dest ){ 
    uint16_t row1_index;
    uint16_t row2_index;
    uint16_t row3_index;
    uint16_t row4_index;
    uint16_t row5_index;
    uint16_t row6_index;
    uint16_t row7_index;
    
    // COLUMN 1 --------------------------------------------------------------------------------------------------------------
    row1_index = xy( x_dest+0, y_dest+0 ); mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( bitmap_col_1,0 )] );
    row2_index = xy( x_dest+0, y_dest+1 ); mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( bitmap_col_1,1 )] );
    row3_index = xy( x_dest+0, y_dest+2 ); mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( bitmap_col_1,2 )] );
    row4_index = xy( x_dest+0, y_dest+3 ); mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( bitmap_col_1,3 )] );
    row5_index = xy( x_dest+0, y_dest+4 ); mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( bitmap_col_1,4 )] );
    row6_index = xy( x_dest+0, y_dest+5 ); mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( bitmap_col_1,5 )] );
    row7_index = xy( x_dest+0, y_dest+6 ); mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( bitmap_col_1,6 )] );
    
    // COLUMN 2 --------------------------------------------------------------------------------------------------------------
    row1_index = xy( x_dest+1, y_dest+0 ); mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( bitmap_col_2,0 )] );
    row2_index = xy( x_dest+1, y_dest+1 ); mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( bitmap_col_2,1 )] );
    row3_index = xy( x_dest+1, y_dest+2 ); mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( bitmap_col_2,2 )] );
    row4_index = xy( x_dest+1, y_dest+3 ); mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( bitmap_col_2,3 )] );
    row5_index = xy( x_dest+1, y_dest+4 ); mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( bitmap_col_2,4 )] );
    row6_index = xy( x_dest+1, y_dest+5 ); mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( bitmap_col_2,5 )] );
    row7_index = xy( x_dest+1, y_dest+6 ); mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( bitmap_col_2,6 )] );
    
    // COLUMN 3 --------------------------------------------------------------------------------------------------------------
    row1_index = xy( x_dest+2, y_dest+0 ); mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( bitmap_col_3,0 )] );
    row2_index = xy( x_dest+2, y_dest+1 ); mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( bitmap_col_3,1 )] );
    row3_index = xy( x_dest+2, y_dest+2 ); mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( bitmap_col_3,2 )] );
    row4_index = xy( x_dest+2, y_dest+3 ); mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( bitmap_col_3,3 )] );
    row5_index = xy( x_dest+2, y_dest+4 ); mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( bitmap_col_3,4 )] );
    row6_index = xy( x_dest+2, y_dest+5 ); mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( bitmap_col_3,5 )] );
    row7_index = xy( x_dest+2, y_dest+6 ); mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( bitmap_col_3,6 )] );
    
    // COLUMN 4 --------------------------------------------------------------------------------------------------------------
    row1_index = xy( x_dest+3, y_dest+0 ); mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( bitmap_col_4,0 )] );
    row2_index = xy( x_dest+3, y_dest+1 ); mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( bitmap_col_4,1 )] );
    row3_index = xy( x_dest+3, y_dest+2 ); mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( bitmap_col_4,2 )] );
    row4_index = xy( x_dest+3, y_dest+3 ); mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( bitmap_col_4,3 )] );
    row5_index = xy( x_dest+3, y_dest+4 ); mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( bitmap_col_4,4 )] );
    row6_index = xy( x_dest+3, y_dest+5 ); mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( bitmap_col_4,5 )] );
    row7_index = xy( x_dest+3, y_dest+6 ); mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( bitmap_col_4,6 )] );
    
    // COLUMN 5 --------------------------------------------------------------------------------------------------------------
    row1_index = xy( x_dest+4, y_dest+0 ); mask[row1_index] = qadd8( mask[row1_index], bit_table[bitRead( bitmap_col_5,0 )] );
    row2_index = xy( x_dest+4, y_dest+1 ); mask[row2_index] = qadd8( mask[row2_index], bit_table[bitRead( bitmap_col_5,1 )] );
    row3_index = xy( x_dest+4, y_dest+2 ); mask[row3_index] = qadd8( mask[row3_index], bit_table[bitRead( bitmap_col_5,2 )] );
    row4_index = xy( x_dest+4, y_dest+3 ); mask[row4_index] = qadd8( mask[row4_index], bit_table[bitRead( bitmap_col_5,3 )] );
    row5_index = xy( x_dest+4, y_dest+4 ); mask[row5_index] = qadd8( mask[row5_index], bit_table[bitRead( bitmap_col_5,4 )] );
    row6_index = xy( x_dest+4, y_dest+5 ); mask[row6_index] = qadd8( mask[row6_index], bit_table[bitRead( bitmap_col_5,5 )] );
    row7_index = xy( x_dest+4, y_dest+6 ); mask[row7_index] = qadd8( mask[row7_index], bit_table[bitRead( bitmap_col_5,6 )] );
}
 
//............................................................................
void PixieChroma::write( uint8_t bitmap_col_1, uint8_t bitmap_col_2, uint8_t bitmap_col_3, uint8_t bitmap_col_4, uint8_t bitmap_col_5, uint8_t x_pos, uint8_t y_pos ){
    write_pix( bitmap_col_1, bitmap_col_2, bitmap_col_3, bitmap_col_4, bitmap_col_5, x_pos, y_pos );
}
 
//............................................................................
void PixieChroma::write( char* message, uint8_t x_pos, uint8_t y_pos ){
    write_pix(
        message,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
void PixieChroma::write( int16_t input, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    itoa( input, char_buf, 10 );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
void PixieChroma::write( uint16_t input, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    utoa( input, char_buf, 10 );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
void PixieChroma::write( int32_t input, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    ltoa( input, char_buf, 10 );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
void PixieChroma::write( uint32_t input, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    ultoa( input, char_buf, 10 );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
#ifndef ARDUINO_ARCH_TEENSY_3_X
void PixieChroma::write( long unsigned int input, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    ultoa( input, char_buf, 10 );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
#endif
 
//............................................................................
void PixieChroma::write( float input, uint8_t places, uint8_t x_pos, uint8_t y_pos ){
    write(
        double( input ),
        places,
        x_pos,
        y_pos
    );
}
 
//............................................................................
void PixieChroma::write( double input, uint8_t places, uint8_t x_pos, uint8_t y_pos ){
    char char_buf[32];
    dtoa( input, char_buf, places );
 
    write_pix(
        char_buf,
        display_padding_x + ( display_width  * x_pos ),
        display_padding_y + ( display_height * y_pos )
    );
}
 
//............................................................................
void PixieChroma::write_pix( char* message, int16_t x_dest, int16_t y_dest ){
    int16_t offset_x = 0;
    int16_t offset_y = 0;
    
    just_wrapped = false;
    
    uint8_t len = strlen( message );
    for( uint8_t i = 0; i < len; i++ ){
        if( message[i] == '\n' ){ // Newline, force line break
            if(just_wrapped == true){
                just_wrapped = false;
                // Skip newline, auto wrapping just newline'd for us.
            }
            else{
                x_dest = extra_space_left+display_padding_x;
                offset_x = 0;
                offset_y = display_height;
            }
        }
        else if( line_wrap == true && x_dest+offset_x+display_width >= (matrix_width) ){ // End of line reached, wrap to new line if line_wrap enabled      
            add_char(
                message[i],
                x_dest + offset_x,
                y_dest + offset_y
            );
            offset_x += display_width;
            
            x_dest = extra_space_left+display_padding_x;
            offset_x = 0;
            offset_y = display_height;
            
            just_wrapped = true;
        }
        else if( message[i] == 0 || message[i] == '\0' ){ // end of string
            return;
        }
        else{ // Normal char
            add_char(
                message[i],
                x_dest + offset_x,
                y_dest + offset_y
            );
            offset_x += display_width;
        }
    }
    
    cursor_x_temp = x_dest+offset_x;
    cursor_y_temp = y_dest+offset_y;
}
 
//............................................................................
void PixieChroma::write_pix( uint8_t bitmap_col_1, uint8_t bitmap_col_2, uint8_t bitmap_col_3, uint8_t bitmap_col_4, uint8_t bitmap_col_5, int16_t x_dest, int16_t y_dest ){    
    int16_t offset_x = 0;
    int16_t offset_y = 0;
        
    if( line_wrap == true && x_dest+offset_x >= ( display_width * chars_x ) ){ // End of line reached, wrap to new line if line_wrap enabled
        x_dest = display_padding_x;
        offset_x = 0;
        offset_y = display_height;  
    }
    
    add_char(
        bitmap_col_1,
        bitmap_col_2,
        bitmap_col_3,
        bitmap_col_4,
        bitmap_col_5,
        x_dest + offset_x,
        y_dest + offset_y
    );
    offset_x += display_width;
 
    
    cursor_x_temp = x_dest+offset_x;
    cursor_y_temp = y_dest+offset_y;
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - PRINT %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::print( uint8_t bitmap_col_1, uint8_t bitmap_col_2, uint8_t bitmap_col_3, uint8_t bitmap_col_4, uint8_t bitmap_col_5 ){
    cursor_x_temp = cursor_x;
    cursor_y_temp = cursor_y;
    
    write_pix( bitmap_col_1, bitmap_col_2, bitmap_col_3, bitmap_col_4, bitmap_col_5, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
void PixieChroma::print( char chr ){
    if(chr != '\n'){
        add_char(
            chr,
            cursor_x,
            cursor_y
        );
        
        cursor_x += display_width;
 
        if(line_wrap && cursor_x >= ( display_width * chars_x ) ){
            cursor_x = extra_space_left+display_padding_x;
            cursor_y += display_height;
            just_wrapped = true;
        }
    }
    else{
        if(just_wrapped == false){
            cursor_x = extra_space_left+display_padding_x;
            cursor_y += display_height;
        }
        else{
            just_wrapped = false;
        }
    }
}
 
//............................................................................
void PixieChroma::print( char* message ){
    uint16_t len = strlen(message);
    uint16_t i = 0;
    while (i < len - 1) {
        if (message[i] == '[' && message[i + 1] == ':') { // Found start of shortcode
            for (uint16_t j = i; j < len - 1; j++) {
                if (message[j] == ':' && message[j + 1] == ']') { // Found end of shortcode
                    fetch_shortcode( message, i + 2, j );
                    i = j + 2;
                    break;
                }
            }
        }
        else {
            print(message[i]);
            i += 1;
        }
    }
 
    if(message[len-1] != ']'){ // If message doesn't end with shortcode
        print( message[len-1] );
    }
}
 
//............................................................................
void PixieChroma::print( int16_t input ){
    char char_buf[32];
    itoa( input, char_buf, 10 );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
void PixieChroma::print( uint16_t input ){
    char char_buf[32];
    utoa( input, char_buf, 10 );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
void PixieChroma::print( int32_t input ){
    char char_buf[32];
    ltoa( input, char_buf, 10 );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
void PixieChroma::print( uint32_t input ){
    char char_buf[32];
    ultoa( input, char_buf, 10 );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
#ifndef ARDUINO_ARCH_TEENSY_3_X
void PixieChroma::print( long unsigned int input ){
    char char_buf[32];
    ultoa( input, char_buf, 10 );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
#endif
 
//............................................................................
void PixieChroma::print( float input, uint8_t places ){
    print( double( input ), places );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
//............................................................................
void PixieChroma::print( double input, uint8_t places ){
    char char_buf[32];
    dtoa( input, char_buf, places );
    write_pix( char_buf, cursor_x, cursor_y );
    
    // Store cursor changes
    cursor_x = cursor_x_temp;
    cursor_y = cursor_y_temp;
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - PRINTLN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::println( uint8_t bitmap_col_1, uint8_t bitmap_col_2, uint8_t bitmap_col_3, uint8_t bitmap_col_4, uint8_t bitmap_col_5 ){  
    print( bitmap_col_1, bitmap_col_2, bitmap_col_3, bitmap_col_4, bitmap_col_5 );
    print('\n');
}
 
//............................................................................
void PixieChroma::println( char* message ){
    print(message); 
    print('\n');
}
 
//............................................................................
void PixieChroma::println( int16_t input ){
    print( input );
    print('\n');
}
 
//............................................................................
void PixieChroma::println( uint16_t input ){
    print( input );
    print('\n');
}
 
//............................................................................
void PixieChroma::println( int32_t input ){
    print( input );
    print('\n');
}
 
//............................................................................
void PixieChroma::println( uint32_t input ){
    print( input );
    print('\n');
}
 
//............................................................................
#ifndef ARDUINO_ARCH_TEENSY_3_X
void PixieChroma::println( long unsigned int input ){
    print( input );
    print('\n');
}
#endif
 
//............................................................................
void PixieChroma::println( float input, uint8_t places ){
    println( double(input), places );
}
 
//............................................................................
void PixieChroma::println( double input, uint8_t places ){
    print( input, places );
    print('\n');
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - CURSOR %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
uint8_t PixieChroma::get_cursor_x(){    
    return cursor_x / display_width;
}
 
//............................................................................
int16_t PixieChroma::get_cursor_x_exact(){
    return cursor_x;
}
 
//............................................................................
uint8_t PixieChroma::get_cursor_y(){
    return cursor_y / display_height;
}
 
//............................................................................
int16_t PixieChroma::get_cursor_y_exact(){
    return cursor_y;
}
 
//............................................................................
void PixieChroma::set_cursor( uint8_t x_position, uint8_t y_position ){
    cursor_x = extra_space_left + display_padding_x + ( display_width  * x_position );
    cursor_y = display_padding_y + ( display_height * y_position );
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - UPDATING THE MASK / LEDS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
//............................................................................
void PixieChroma::clear(){
    memset( mask, 0, pixel_count );
    set_cursor( 0, 0 );
}
 
//............................................................................
void PixieChroma::free(){
    freeze = false;
}
 
//............................................................................
void PixieChroma::hold(){
    freeze = true;
}
 
//............................................................................
void PixieChroma::show(){
    uint32_t t_now = micros();
    float frame_delta_us = t_now-t_last;
    frame_rate = 1000000.0 / frame_delta_us;
    delta = fps_target / frame_rate;
    t_last = t_now;
    
    anim_func( this, delta ); // Call custom animation function
    
    noInterrupts(); 
    
    for(uint8_t i = 0; i < chars_y; i++){
        if(scrolling[i] == false){
            int16_t x_offset = calc_justification(justifications[i], i);
            shift_mask_x( x_offset, i);
            if( custom_animation == false ){
                shift_color_map_x( x_offset, i);
            }
        }
    }
    
    if( !freeze ){ // If we're not holding out for a pix.free() call, show with the current mask
        memcpy( mask_out, mask, led_count );
    }
    
    memcpy( color_map_out, color_map, sizeof( CRGB )*led_count );
 
    for( uint16_t i = 0; i < led_count; i++ ){
        // MASKING
        color_map_out[i].fadeLightBy( 255-mask_out[i] ); // Apply mask "over" LED color layer
        
        // GAMMA CORRECTION
        if( correct_gamma ){
            color_map_out[i].r = gamma8[ color_map_out[i].r ]; // Apply gamma correction LUT
            color_map_out[i].g = gamma8[ color_map_out[i].g ];
            color_map_out[i].b = gamma8[ color_map_out[i].b ];
        }
    }
        
    // Regulate brightness to keep power within budget set with pix.set_max_power( V, mA );
    FastLED.setBrightness( calculate_max_brightness_for_power_vmA( color_map_out, led_count, brightness_level, max_V, max_mA ) );
    FastLED.show();
 
    interrupts();
}
//............................................................................
void PixieChroma::delay(uint32_t milliseconds){
    FastLED.delay( milliseconds );
}
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - COLOR %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::color( CRGB col ){
    print_col = col;
    fill_solid( color_map, pixel_count, col );
}
 
//............................................................................
void PixieChroma::color( CRGB col, uint8_t x, uint8_t y ){
    int16_t x_pos = x * display_width  + display_padding_x;
    int16_t y_pos = y * display_height + display_padding_y;
    
    for( uint8_t xi = 0; xi < font_col_width; xi++ ){
        color_map[xy( x_pos+xi, y_pos+0 )] = col;
        color_map[xy( x_pos+xi, y_pos+1 )] = col;
        color_map[xy( x_pos+xi, y_pos+2 )] = col;
        color_map[xy( x_pos+xi, y_pos+3 )] = col;
        color_map[xy( x_pos+xi, y_pos+4 )] = col;
        color_map[xy( x_pos+xi, y_pos+5 )] = col;
        color_map[xy( x_pos+xi, y_pos+6 )] = col;
    }
}
 
//............................................................................
void PixieChroma::color( CRGB col, int16_t x1, int16_t y1, int16_t x2, int16_t y2 ){
    // Make rectangle selection inclusive
    x2 += 1;
    y2 += 1;
 
    if( x2 < x1 ){
        uint8_t x_temp = x2;
        x2 = x1;
        x1 = x_temp;
    }
    if( y2 < y1 ){
        uint8_t y_temp = y2;
        y2 = y1;
        y1 = y_temp;
    }
    
    uint16_t x_delta = x2 - x1;
    uint16_t y_delta = y2 - y1;
    
    for( uint16_t y = 0; y < y_delta; y++ ){
        for( uint16_t x = 0; x < x_delta; x++ ){
            int16_t x2_pos = x1 + x;
            int16_t y2_pos = y1 + y;
            color_map[xy( x2_pos, y2_pos )] = col;
        }
    }
}
 
//............................................................................
void PixieChroma::print_color( CRGB col ){
    print_col = col;
}
 
//............................................................................
CRGB PixieChroma::kelvin_to_rgb( uint16_t temperature ){
    // Tanner Helland formula
    float _temperature;
    float _red;
    float _green;
    float _blue;
 
    _temperature = constrain( temperature, 0, 65500 );
 
    _red = _green = _blue = 0;  
    float t = _temperature * 0.01;
 
    if ( t <= 66 ){
        _red = 255;
        _green = ( 99.4708025861 * log( t ) ) - 161.1195681661;
        if ( t > 19 ){
            _blue = ( 138.5177312231 * log( t - 10 ) ) - 305.0447927307;
        }
        else{
            _blue = 0;
        }
    }
    else{
        _red   = 329.698727466  * pow( t - 60, -0.1332047592 );
        _green = 288.1221695283 * pow( t - 60, -0.0755148492 );
        _blue  = 255;
    }
 
    float f = 0.01 * 100;
 
    _red   = constrain( f * _red,   0, 255 );
    _green = constrain( f * _green, 0, 255 );
    _blue  = constrain( f * _blue,  0, 255 );
 
    return CRGB( _red, _green, _blue );
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - MASK EFFECTS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::blur( fract8 blur_amount ){
    blur_x( blur_amount );
    blur_y( blur_amount );
}
 
//............................................................................
void PixieChroma::blur_x( fract8 blur_amount ){
    uint8_t keep = 255 - blur_amount;
    uint8_t seep = blur_amount >> 1;
    for(  uint8_t row = 0; row < matrix_height; row++ ) {
        uint8_t carryover = 0;
        for(  uint8_t i = 0; i < matrix_width; i++ ) {
            uint8_t cur = mask[xy( i,row )];
            uint8_t part = cur;
            part = scale8( part, seep );
            cur  = scale8( cur, keep );
            cur  = qadd8( cur,carryover );
            if( i ){
                mask[xy( i-1,row )] = qadd8( mask[xy( i-1,row )],part );
            }
            mask[xy( i,row )] = cur;
            carryover = part;
        }
    }
}
 
//............................................................................
void PixieChroma::blur_y( fract8 blur_amount ){
    // blur columns
    uint8_t keep = 255 - blur_amount;
    uint8_t seep = blur_amount >> 1;
    for(  uint8_t col = 0; col < matrix_width; ++col ) {
        uint8_t carryover = 0;
        for(  uint8_t i = 0; i < matrix_height; ++i ) {            
            uint8_t cur = mask[xy( col,i )];
            uint8_t part = cur;
            part = scale8( part, seep );
            cur  = scale8( cur, keep );
            cur  = qadd8( cur,carryover );
            if( i ){
                mask[xy( col,i-1 )] = qadd8( mask[xy( col,i-1 )],part );
            }
            mask[xy( col,i )] = cur;
            carryover = part;
        }
    }
}
 
//............................................................................
void PixieChroma::dim( uint8_t amount, bool reset_cursor ){
    if( reset_cursor == true ){
        set_cursor( 0,0 );
    }
    
    for( uint16_t i = 0; i < pixel_count; i+=11 ){
        mask[i+0]  = scale8( mask[i+0],  255-amount );
        mask[i+1]  = scale8( mask[i+1],  255-amount );
        mask[i+2]  = scale8( mask[i+2],  255-amount );
        mask[i+3]  = scale8( mask[i+3],  255-amount );
        mask[i+4]  = scale8( mask[i+4],  255-amount );
        mask[i+5]  = scale8( mask[i+5],  255-amount );
        mask[i+6]  = scale8( mask[i+6],  255-amount );
        mask[i+7]  = scale8( mask[i+7],  255-amount );
        mask[i+8]  = scale8( mask[i+8],  255-amount );
        mask[i+9]  = scale8( mask[i+9],  255-amount );
        mask[i+10] = scale8( mask[i+10], 255-amount );
    }
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - COLOR EFFECTS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::color_blur( fract8 blur_amount ){
    color_blur_x( blur_amount );
    color_blur_y( blur_amount );
}
 
//............................................................................
void PixieChroma::color_blur_x( fract8 blur_amount ){
    uint8_t keep = 255 - blur_amount;
    uint8_t seep = blur_amount >> 1;
    for(  uint8_t row = 0; row < matrix_height; row++ ) {
        uint8_t carryover = 0;
        for(  uint8_t i = 0; i < matrix_width; i++ ) {
            CRGB cur = color_map[xy( i,row )];
            CRGB part = cur;
            part.nscale8(  seep );
            cur.nscale8(  keep );
            cur += carryover;
            if(  i ) color_map[xy( i-1,row )] += part;
            color_map[xy( i,row )] = cur;
            carryover = part;
        }
    }
}
 
//............................................................................
void PixieChroma::color_blur_y( fract8 blur_amount ){
    // blur rows same as columns, for irregular matrix
    uint8_t keep = 255 - blur_amount;
    uint8_t seep = blur_amount >> 1;
    for(  uint8_t row = 0; row < matrix_width; row++ ) {
        CRGB carryover = CRGB::Black;
        for(  uint8_t i = 0; i < matrix_height; i++ ) {
            CRGB cur = color_map[xy( i,row )];
            CRGB part = cur;
            part.nscale8(  seep );
            cur.nscale8(  keep );
            cur += carryover;
            if(  i ) color_map[xy( i-1,row )] += part;
            color_map[xy( i,row )] = cur;
            carryover = part;
        }
    }
}
 
//............................................................................
void PixieChroma::color_dim( uint8_t amount ){
    CRGBSet leds_temp( color_map, pixel_count );
    leds_temp.fadeToBlackBy( amount );
}
 
 
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %% FUNCTIONS - 2D TOOLS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//............................................................................
void PixieChroma::draw_line_color( int16_t x1, int16_t y1, int16_t x2, int16_t y2, CRGB color ){
    //Bresenham's line algorithm
    uint16_t index;
    
    int16_t x,y,dx,dy,dx1,dy1,px,py,xe,ye,i;
    dx=x2-x1;
    dy=y2-y1;
    dx1=fabs( dx );
    dy1=fabs( dy );
    px=2*dy1-dx1;
    py=2*dx1-dy1;
    if( dy1<=dx1 ){
        if( dx>=0 ){
            x=x1;
            y=y1;
            xe=x2;
        }
        else{
            x=x2;
            y=y2;
            xe=x1;
        }
        set_pixel_color( x, y, color );
        for( i=0;x<xe;i++ ){
            x=x+1;
            if( px<0 ){
                px=px+2*dy1;
            }
            else{
                if( ( dx<0 && dy<0 ) || ( dx>0 && dy>0 ) ){
                    y=y+1;
                }
                else{
                    y=y-1;
                }
                px=px+2*( dy1-dx1 );
            }
            set_pixel_color( x, y, color );
        }
    }
    else{
        if( dy>=0 ){
            x=x1;
            y=y1;
            ye=y2;
        }
        else{
            x=x2;
            y=y2;
            ye=y1;
        }
        set_pixel_color( x, y, color );
        for( i=0;y<ye;i++ ){
            y=y+1;
            if( py<=0 ){
                py=py+2*dx1;
            }
            else{
                if( ( dx<0 && dy<0 ) || ( dx>0 && dy>0 ) ){
                    x=x+1;
                }
                else{
                    x=x-1;
                }
                py=py+2*( dx1-dy1 );
            }
            set_pixel_color( x, y, color );
        }
    }
}
 
//............................................................................
void PixieChroma::draw_line_mask( int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t value ){
    //Bresenham's line algorithm
    uint16_t index;
    
    int16_t x,y,dx,dy,dx1,dy1,px,py,xe,ye,i;
    dx=x2-x1;
    dy=y2-y1;
    dx1=fabs( dx );
    dy1=fabs( dy );
    px=2*dy1-dx1;
    py=2*dx1-dy1;
    if( dy1<=dx1 ){
        if( dx>=0 ){
            x=x1;
            y=y1;
            xe=x2;
        }
        else{
            x=x2;
            y=y2;
            xe=x1;
        }
        set_pixel_mask( x, y, value );
        for( i=0;x<xe;i++ ){
            x=x+1;
            if( px<0 ){
                px=px+2*dy1;
            }
            else{
                if( ( dx<0 && dy<0 ) || ( dx>0 && dy>0 ) ){
                    y=y+1;
                }
                else{
                    y=y-1;
                }
                px=px+2*( dy1-dx1 );
            }
            set_pixel_mask( x, y, value );
        }
    }
    else{
        if( dy>=0 ){
            x=x1;
            y=y1;
            ye=y2;
        }
        else{
            x=x2;
            y=y2;
            ye=y1;
        }
        set_pixel_mask( x, y, value );
        for( i=0;y<ye;i++ ){
            y=y+1;
            if( py<=0 ){
                py=py+2*dx1;
            }
            else{
                if( ( dx<0 && dy<0 ) || ( dx>0 && dy>0 ) ){
                    x=x+1;
                }
                else{
                    x=x-1;
                }
                py=py+2*( dx1-dy1 );
            }
            set_pixel_mask( x, y, value );
        }
    }
}
 
//............................................................................
float PixieChroma::get_uv_x( int32_t x_pixel ){
    return x_pixel / float( matrix_width );
}
 
//............................................................................
float PixieChroma::get_uv_y( int32_t y_pixel ){
    y_pixel = matrix_height - y_pixel;
    return y_pixel / float( matrix_height );
}
 
//............................................................................
uint8_t PixieChroma::get_pixel_mask( int32_t x, int32_t y ){
    return mask[ xy(x,y) ];
}
 
//............................................................................
CRGB PixieChroma::get_pixel_color( int32_t x, int32_t y ){
    return color_map[ xy(x,y) ];
}
 
//............................................................................
void PixieChroma::print_xy_table(){
    for( uint8_t y = 0; y < matrix_height; y++ ){
        for( uint8_t x = 0; x < matrix_width; x++ ){
            uint16_t index = ( matrix_width*y )+x;
            Serial.print( xy_table[index] );
            Serial.print( '\t' );
        }
        Serial.println();
    }
}
 
//............................................................................
void PixieChroma::scroll_message( char* message, uint8_t row ){ 
    scrolling[row] = true;
 
    uint16_t len = strlen(message);
    uint16_t i = 0;
    while (i < len - 1) {   
        if (message[i] == '[' && message[i + 1] == ':') { // Found start of shortcode
            for (uint16_t j = i; j < len - 1; j++) {
                if (message[j] == ':' && message[j + 1] == ']') { // Found end of shortcode
                    fetch_shortcode( message, i + 2, j, true );
                    scroll_char(temp_code, row);
                    i = j + 2;
                    break;
                }
            }
        }
        else {
            scroll_char(message[i], row);
            i += 1;
        }
    }
 
    if(message[len-1] != ']'){ // If message doesn't end with shortcode
        scroll_char(message[len-1], row);
    }
    
    for(uint8_t i = 0; i < chars_x; i++){
        scroll_char(' ', row);
    }
    
    scrolling[row] = false;
}
 
//............................................................................
void PixieChroma::set_pixel_mask( int32_t x, int32_t y, uint8_t value ){
    mask[ xy(x,y) ] = value;
}
 
//............................................................................
void PixieChroma::set_pixel_color( int32_t x, int32_t y, CRGB color ){
    color_map[ xy(x,y) ] = color;
}
 
//............................................................................
void PixieChroma::shift_mask_x( int16_t amount, int16_t row ){
    int16_t y_start = 0;
    int16_t y_end   = matrix_height;
    
    if(row != -1){
        y_start = display_height*row;
        y_end   = display_height*(row+1);
    }
    
    if(amount < 0){
        for( uint16_t x = 0; x < matrix_width; x++ ){
            for( uint16_t y = y_start; y < y_end; y++ ){
                int16_t x_dest = x - amount;
                int16_t y_dest = y - 0;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    mask[ xy( x,y )  ] = mask[ xy( x_dest, y_dest ) ];
                }
                else{
                    mask[ xy( x,y )  ] = 0;
                }
            }
        }
    }
    else if(amount > 0){
        for( int16_t x = matrix_width; x >= 0; x-- ){
            for( uint16_t y = y_start; y < y_end; y++ ){
                int16_t x_dest = x - amount;
                int16_t y_dest = y - 0;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    mask[ xy( x,y )  ] = mask[ xy( x_dest, y_dest ) ];
                }
                else{
                    mask[ xy( x,y )  ] = 0;
                }
            }
        }
    }
}
 
//............................................................................
void PixieChroma::shift_mask_y( int16_t amount ){
    if(amount < 0){
        for( uint16_t y = 0; y < matrix_height; y++ ){
            for( uint16_t x = 0; x < matrix_width; x++ ){
                int16_t x_dest = x - 0;
                int16_t y_dest = y - amount;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    mask[ xy( x,y )  ] = mask[ xy( x_dest, y_dest ) ];
                }
                else{
                    mask[ xy( x,y )  ] = 0;
                }
            }
        }
    }
    else if(amount > 0){
        for( int16_t y = matrix_height; y >= 0; y-- ){
            for( uint16_t x = 0; x < matrix_width; x++ ){
                int16_t x_dest = x - 0;
                int16_t y_dest = y - amount;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    mask[ xy( x,y )  ] = mask[ xy( x_dest, y_dest ) ];
                }
                else{
                    mask[ xy( x,y )  ] = 0;
                }
            }
        }
    }
}
 
//............................................................................
void PixieChroma::shift_color_map_x( int16_t amount, int16_t row ){
    int16_t y_start = 0;
    int16_t y_end   = matrix_height;
    
    if(row != -1){
        y_start = display_height*row;
        y_end   = display_height*(row+1);
    }
    
    if(amount < 0){
        for( uint16_t x = 0; x < matrix_width; x++ ){
            for( uint16_t y = y_start; y < y_end; y++ ){
                int16_t x_dest = x - amount;
                int16_t y_dest = y - 0;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    color_map[ xy( x,y )  ] = color_map[ xy( x_dest, y_dest ) ];
                }
                else{
                    color_map[ xy( x,y )  ] = 0;
                }
                
            }
        }
    }
    else if(amount > 0){
        for( int16_t x = matrix_width; x >= 0; x-- ){
            for( uint16_t y = y_start; y < y_end; y++ ){
                int16_t x_dest = x - amount;
                int16_t y_dest = y - 0;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    color_map[ xy( x,y )  ] = color_map[ xy( x_dest, y_dest ) ];
                }
                else{
                    color_map[ xy( x,y )  ] = 0;
                }
            }
        }
    }
}
 
//............................................................................
void PixieChroma::shift_color_map_y( int16_t amount ){  
    if(amount < 0){
        for( uint16_t x = 0; x < matrix_width; x++ ){
            for( uint16_t y = 0; y < matrix_height; y++ ){
                int16_t x_dest = x - 0;
                int16_t y_dest = y - amount;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    color_map[ xy( x,y )  ] = color_map[ xy( x_dest, y_dest ) ];
                }
                else{
                    color_map[ xy( x,y )  ] = 0;
                }
            }
        }
    }
    else if(amount > 0){
        for( int16_t x = matrix_width; x >= 0; x-- ){
            for( uint16_t y = 0; y < matrix_height; y++ ){
                int16_t x_dest = x - amount;
                int16_t y_dest = y - 0;
                
                if(x_dest >= 0 && y_dest >= 0 && x_dest < matrix_width && y_dest < matrix_height){
                    color_map[ xy( x,y )  ] = color_map[ xy( x_dest, y_dest ) ];
                }
                else{
                    color_map[ xy( x,y )  ] = 0;
                }               
            }
        }
    }
}
 
//............................................................................
uint16_t PixieChroma::uv( float x, float y, bool wrap ) {
    if( wrap ){
        while( x < 0.0 ){
            x += 1.0;
        }
        while( x > 1.0 ){
            x -= 1.0;
        }
        while( y < 0.0 ){
            y += 1.0;
        }
        while( y > 1.0 ){
            y -= 1.0;
        }
    }
    
    y = 1.0-y; // Invert Y axis for OpenGL coordinate style
    
    return xy(
        uint16_t( matrix_width  * x ),
        uint16_t( matrix_height * y )
    );
}
 
//............................................................................
uint16_t PixieChroma::xy( int32_t x, int32_t y, bool wrap ) {
    if( wrap ){
        while( x < 0 ){
            x += matrix_width;
        }
        while( x >= matrix_width ){
            x -= matrix_width;
        }
        while( y < 0 ){
            y += matrix_height;
        }
        while( y >= matrix_height ){
            y -= matrix_height;
        }
    }
    else{
        if( x < 0 ){
            return pixel_count; // If offscreen without wrap return last led in matrix
        }
        else if( x >= matrix_width ){
            return pixel_count; // If offscreen without wrap return last led in matrix
        }
        if( y < 0 ){
            return pixel_count; // If offscreen without wrap return last led in matrix
        }
        else if( y >= matrix_height ){
            return pixel_count; // If offscreen without wrap return last led in matrix
        }
    }
 
    // done wrapping / culling, time for transformation
    return xy_table[ ( y * matrix_width ) + x ];
}
 
 
 
// ---------------------------------------------------------------------------------------------------------|
// -- PRIVATE CLASS FUNCTIONS ------------------------------------------------------------------------------|
// ---------------------------------------------------------------------------------------------------------|
 
void PixieChroma::build_controller( const uint8_t pin ){
    // FastLED control pin has to be defined as a constant, ( not just declared const, it's weirdly different ) so
    // this is a hacky workaround. Since we have to hardwire the damn pin number variable, we also have
    // to be careful of the current architecture we're compiling to, since FastLED doesn't let you 
    // define non-existent pins either.
    
    #ifdef ARDUINO_ARCH_ESP8266
        if ( pin == 0 ){FastLED.addLeds<WS2812B, 0, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 1 ){FastLED.addLeds<WS2812B, 1, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 2 ){FastLED.addLeds<WS2812B, 2, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 3 ){FastLED.addLeds<WS2812B, 3, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 4 ){FastLED.addLeds<WS2812B, 4, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 5 ){FastLED.addLeds<WS2812B, 5, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
            // annnnd a bunch of missing pins that are tied to external flash...
        if ( pin == 12 ){FastLED.addLeds<WS2812B, 12, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 13 ){FastLED.addLeds<WS2812B, 13, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 14 ){FastLED.addLeds<WS2812B, 14, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 15 ){FastLED.addLeds<WS2812B, 15, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 16 ){FastLED.addLeds<WS2812B, 16, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
    #endif
    
    #ifdef ARDUINO_ARCH_ESP32
        if ( pin == 0 ){FastLED.addLeds<WS2812B, 0, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 1 ){FastLED.addLeds<WS2812B, 1, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 2 ){FastLED.addLeds<WS2812B, 2, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 3 ){FastLED.addLeds<WS2812B, 3, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 4 ){FastLED.addLeds<WS2812B, 4, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 5 ){FastLED.addLeds<WS2812B, 5, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 12 ){FastLED.addLeds<WS2812B, 12, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 13 ){FastLED.addLeds<WS2812B, 13, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 14 ){FastLED.addLeds<WS2812B, 14, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 15 ){FastLED.addLeds<WS2812B, 15, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 16 ){FastLED.addLeds<WS2812B, 16, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 17 ){FastLED.addLeds<WS2812B, 17, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 18 ){FastLED.addLeds<WS2812B, 18, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 19 ){FastLED.addLeds<WS2812B, 19, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 21 ){FastLED.addLeds<WS2812B, 21, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 22 ){FastLED.addLeds<WS2812B, 22, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 23 ){FastLED.addLeds<WS2812B, 23, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 25 ){FastLED.addLeds<WS2812B, 25, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 26 ){FastLED.addLeds<WS2812B, 26, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 27 ){FastLED.addLeds<WS2812B, 27, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 32 ){FastLED.addLeds<WS2812B, 32, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 33 ){FastLED.addLeds<WS2812B, 33, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
    #endif
    
    #ifdef ARDUINO_ARCH_TEENSY_3_X
        if ( pin == 0 ){FastLED.addLeds<WS2812B, 0, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 1 ){FastLED.addLeds<WS2812B, 1, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 2 ){FastLED.addLeds<WS2812B, 2, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 3 ){FastLED.addLeds<WS2812B, 3, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 4 ){FastLED.addLeds<WS2812B, 4, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 5 ){FastLED.addLeds<WS2812B, 5, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 6 ){FastLED.addLeds<WS2812B, 6, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 7 ){FastLED.addLeds<WS2812B, 7, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 8 ){FastLED.addLeds<WS2812B, 8, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 9 ){FastLED.addLeds<WS2812B, 9, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 10 ){FastLED.addLeds<WS2812B, 10, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 11 ){FastLED.addLeds<WS2812B, 11, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 12 ){FastLED.addLeds<WS2812B, 12, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 13 ){FastLED.addLeds<WS2812B, 13, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 14 ){FastLED.addLeds<WS2812B, 14, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 15 ){FastLED.addLeds<WS2812B, 15, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 16 ){FastLED.addLeds<WS2812B, 16, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 17 ){FastLED.addLeds<WS2812B, 17, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 18 ){FastLED.addLeds<WS2812B, 18, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 19 ){FastLED.addLeds<WS2812B, 19, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 20 ){FastLED.addLeds<WS2812B, 20, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 21 ){FastLED.addLeds<WS2812B, 21, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 22 ){FastLED.addLeds<WS2812B, 22, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
        if ( pin == 23 ){FastLED.addLeds<WS2812B, 23, GRB>( color_map_out, led_count ).setCorrection( TypicalLEDStrip );}
    #endif
}
 
 
void PixieChroma::calc_xy(){    
  // Initialize XY table
    for( uint16_t yi = 0; yi < chars_y; yi++ ){
        for( uint16_t y = 0; y < 11; y++ ){
            for( uint16_t xi = 0; xi < chars_x; xi++ ){
                for( uint16_t x = 0; x < 7; x++ ){
                    int16_t x_pos = ( xi*display_width )+x;
                    int16_t y_pos = ( yi*display_height )+y;
 
                    int16_t x_pos_mod = x_pos % display_width;
                    int16_t y_pos_mod = y_pos % display_height;
 
                    uint16_t i_table = ( y_pos * matrix_width ) + x_pos;
                    uint16_t i_template = ( y_pos_mod * display_width ) + x_pos_mod;
 
                    if(xi != 0 && xi != chars_x-1){
                        xy_table[i_table] = int8_t( pgm_read_byte( xy_template + i_template ) );
                    }
                    else{
                        xy_table[i_table] = -2;
                    }
                }
            }
        }
    }
 
    //Serial.println( "SOLVING VISIBLE" );
 
    // Initialize first row of displays
    uint8_t visible_rows = 0;
    for( uint16_t row = 0; row < display_height; row++ ){
        uint16_t index = ( 5*visible_rows );
        bool found_visible = false;
        int16_t last_data = 0;
        for( uint16_t col = 0; col < matrix_width; col++ ){
            uint16_t i = ( row*matrix_width )+col;
            int16_t map_data = xy_table[i];
 
            if( map_data == -1 ){
                xy_table[i] = index;
                index++;
                found_visible = true;
            }
 
            else if( map_data == -2 ){
                if( last_data == -1 ){
                    index+=30;
                }
            }
 
            last_data = map_data;
        }
 
        if( found_visible ){
            visible_rows++;
        }
    }
 
    led_count = 35*(chars_x-2); // account for first row
 
    // Solve additional rows
    if( chars_y > 1 ){
        uint8_t rows_left = chars_y-1;
        uint16_t row_length = ( display_width*display_height )*chars_x;
        for( uint8_t ii = 0; ii < rows_left; ii++ ){
            for( uint16_t r = 0; r < row_length; r++ ){
                uint16_t final_src_index = ( ii*row_length )+r;
                int16_t src_data = xy_table[final_src_index];
                if( src_data >= 0 ){
                    src_data += ( 35*(chars_x-2) );
 
                    if( src_data > led_count ){
                        led_count = src_data+1;
                    }
                    xy_table[final_src_index+row_length] = src_data;
                }
            }
        }
    }
 
    uint16_t index = led_count;
 
    //Serial.println( "SOLVING INVISIBLE" );
    for( uint16_t y = 0; y < matrix_height; y++ ){
        for( uint16_t x = 0; x < matrix_width; x++ ){
            uint16_t i = ( y * matrix_width ) + x;
            uint16_t j = xy_table[i];
 
            if( xy_table[i] == -2 ){
                xy_table[i] = index;
                index++;
            }
        }
    }
    //Serial.println( "DONE" );
}
 
 
void PixieChroma::fetch_shortcode( char* message, uint16_t code_start, uint16_t code_end, bool return_code ){
    if( message[code_start] == '#' ){ // custom data, no lookup needed
        parse_custom_shortcode( message, code_start+1, code_end, return_code );
        return;
    }
    char bitmap_name[32];
    memset(bitmap_name, 0, 32);
    char bitmap_temp[32];
    memset(bitmap_temp, 0, 32);
    uint8_t bitmap_temp_index = 0;
 
    uint16_t code_length = code_end - code_start;
    for (uint16_t i = 0; i < code_length; i++) {
        bitmap_name[i] = message[code_start + i];
    }
 
    // Allow for lowercase shortcodes as well
    for (uint16_t i = 0; i < code_length; i++) {
        if( uint8_t(bitmap_name[i]) >= 97 && uint8_t(bitmap_name[i]) <= 122 ){ // if in lowercase a-z range
            bitmap_name[i] -= 32; // shift to uppercase A-Z range
        }
    }
 
    uint32_t index = 0;
    while (index < sizeof(PIXIE_SHORTCODE_LIBRARY)) {
        if (PIXIE_SHORTCODE_LIBRARY[index] >= 200) {
            uint8_t skips = PIXIE_SHORTCODE_LIBRARY[index]-200;
            index += 1; // Skip the mark byte
            skips -= 1;
            
            char first_name_char = PIXIE_SHORTCODE_LIBRARY[index];
            if(bitmap_name[0] == first_name_char){
                memset(bitmap_temp, 0, 32);
                bitmap_temp_index = 0;
                uint32_t bitmap_data_index = index - 6;
 
                bool end_found = false;
                while (end_found == false) {
                    uint8_t val = PIXIE_SHORTCODE_LIBRARY[index];
 
                    bitmap_temp[bitmap_temp_index] = char(val); // Gather chars, even null terminator
                    if (val == 0) { // Found end of name
                        end_found = true;
                    }
 
                    bitmap_temp_index += 1;
                    index += 1;
                    skips -= 1;
                }
                if (strcmp(bitmap_temp, bitmap_name) == 0) { // If a string match is found:
                
                    if(return_code == false){
                        color(print_col, cursor_x/display_width, cursor_y/display_height);
 
                        print( // Print column data
                            PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 0],
                            PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 1],
                            PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 2],
                            PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 3],
                            PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 4]
                        );
                    }
                    else{
                        temp_code[0] = PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 0];
                        temp_code[1] = PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 1];
                        temp_code[2] = PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 2];
                        temp_code[3] = PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 3];
                        temp_code[4] = PIXIE_SHORTCODE_LIBRARY[bitmap_data_index + 4];
                    }
                    
                    return;
                }
            }
            else{
                index += skips;
                skips = 0;
            }
        }
        else {
            index += 1;
        }
    }
}
 
 
void PixieChroma::parse_custom_shortcode( char* message, uint16_t code_start, uint16_t code_end, bool return_code ){
    uint8_t input[10];
    
    for(uint8_t i = 0; i < (code_end-code_start); i++){
        char chr = message[code_start+i];
        
        if     (chr == '0'){ input[i] = 0;  }
        else if(chr == '1'){ input[i] = 1;  }
        else if(chr == '2'){ input[i] = 2;  }
        else if(chr == '3'){ input[i] = 3;  }
        else if(chr == '4'){ input[i] = 4;  }
        else if(chr == '5'){ input[i] = 5;  }
        else if(chr == '6'){ input[i] = 6;  }
        else if(chr == '7'){ input[i] = 7;  }
        else if(chr == '8'){ input[i] = 8;  }
        else if(chr == '9'){ input[i] = 9;  }
        else if(chr == 'A'){ input[i] = 10; }
        else if(chr == 'B'){ input[i] = 11; }
        else if(chr == 'C'){ input[i] = 12; }
        else if(chr == 'D'){ input[i] = 13; }
        else if(chr == 'E'){ input[i] = 14; }
        else if(chr == 'F'){ input[i] = 15; }
    }
    
    uint8_t column_1 = input[1] + (input[0]<<4);
    uint8_t column_2 = input[3] + (input[2]<<4);
    uint8_t column_3 = input[5] + (input[4]<<4);
    uint8_t column_4 = input[7] + (input[6]<<4);
    uint8_t column_5 = input[9] + (input[8]<<4);
    
    if(return_code == false){
        color(print_col, cursor_x/display_width, cursor_y/display_height);
 
        print( // Print column data
            column_1,
            column_2,
            column_3,
            column_4,
            column_5
        );
    }
    else{
        temp_code[0] = column_1;
        temp_code[1] = column_2;
        temp_code[2] = column_3;
        temp_code[3] = column_4;
        temp_code[4] = column_5;
    }
}
 
 
void PixieChroma::scroll_char(char c, uint8_t row){
    add_char(c, (chars_x * display_width)-6, 2+(row*display_height));
    for (uint8_t i = 0; i < 7; i++) {
        shift_mask_x(-1, row);
        if(scroll_type != INSTANT){
            show();
            delay(scroll_frame_delay_ms);
        }
    }
    show();
    delay(scroll_hold_ms);
}
 
 
void PixieChroma::scroll_char(uint8_t* bitmap, uint8_t row){
    add_char(bitmap[0], bitmap[1], bitmap[2], bitmap[3], bitmap[4], (chars_x * display_width)-6, 2+(row*display_height));
    for (uint8_t i = 0; i < 7; i++) {
        shift_mask_x(-1, row);
        if(scroll_type != INSTANT){
            show();
            delay(scroll_frame_delay_ms);
        }
    }
    show();
    delay(scroll_hold_ms);  
}
 
 
int16_t PixieChroma::calc_justification( t_justification justification, uint8_t row ){
    if(justification == LEFT){
        return 0;
    }
    
    uint8_t x_disp_start = 0;
    uint8_t x_disp_end = 0;
 
    uint16_t x_led = 0;
    uint16_t x_pos = 0;
 
    for(int16_t x = 0; x < matrix_width; x++){
        for(int16_t y = (display_height*row); y < (display_height*(row+1)); y++){
            if(mask[ xy(x,y) ] != 0){
                x = matrix_width;
                y = matrix_height;
                break;
            }
            else{
                x_led += 1;
                if(x_led >= (display_width*display_height)){
                    x_led = 0;
                    x_pos += 1;
                }
            }
        }
    }
    
    x_disp_start = x_pos;
    x_led = 0;
    x_pos = chars_x;
    
    for(int16_t x = matrix_width-1; x > 0; x--){
        for(int16_t y = (display_height*row); y < (display_height*(row+1)); y++){
            if(mask[ xy(x,y) ] != 0){
                x = 0;
                y = matrix_height;
                break;
            }
            else{
                x_led += 1;
                if(x_led >= (display_width*display_height)){
                    x_led = 0;
                    x_pos -= 1;
                }
            }
        }
    }
    
    x_disp_end = x_pos;
    
    uint8_t length = x_disp_end - x_disp_start;
    int16_t x_offset_chars;
    
    if(length > (chars_x-2)){
        return 0;
    }
    
    if(justification == CENTER){
        x_offset_chars = floor(((chars_x-2) - length) / 2.0);
        
        if((x_offset_chars*2) + length > (chars_x-2)){
            x_offset_chars -= 1;
        }
    }
    else if(justification == RIGHT){
        x_offset_chars = (chars_x-2)-length;
    }
    
    return x_offset_chars * display_width;
}
 
// (End of user code)
 
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
// ##########################################################################################################
 
// ---------------------------------------------------------------------------------------------------------|
// -- DEVELOPER FUNCTIONS ----------------------------------------------------------------------------------|
// ---------------------------------------------------------------------------------------------------------|
//............................................................................
bool PixieChroma::unit_tests(){
    //randomSeed( 
    //  analogRead( ANALOG_PIN )
    //);
    
    char* border  = "+---------------------------------------------+";
 
    char* testing = "Testing: ";
    char* PASS    = "PASS";
    char* FAIL    = "FAIL\n--------------------------------------------------------- #####";
    bool  success = true;
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ begin ---------------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("begin() ......................... "));
    uint8_t fail_step = 0;
    
    begin_quad( // 12 Pixies, (6x2) in quad mode
        UNIT_TEST_PIXIES_PER_PIN,
        UNIT_TEST_PIXIES_X,
        UNIT_TEST_PIXIES_Y
    );
    
    if( chars_x               != 12   ){ fail_step = 1;  }
    if( chars_y               != 2    ){ fail_step = 2;  }
    if( matrix_width          != 84   ){ fail_step = 3;  }
    if( matrix_height         != 22   ){ fail_step = 4;  }
    if( pixel_count            != 1848 ){ fail_step = 5;  }
    if( led_count              != 840  ){ fail_step = 6;  }
    if( xy_table[0]           != 840  ){ fail_step = 7;  }
    if( xy_table[500]         != 402  ){ fail_step = 8;  }
    if( color_map[0].g        != 255  ){ fail_step = 9;  }
    
    if(fail_step == 0){
        Serial.println(PASS);
        
        clear();
        print("------------------------");
    }
    else{
        Serial.println(FAIL);
        Serial.print("FAIL_STEP: ");
        Serial.println(fail_step);
        
        success = false;
    }
        
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ xy ------------------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("xy() ............................ "));
    fail_step = 0;
        
    if( xy(0, 0 ) != 840  ){ fail_step = 1; } // top left
    if( xy(83,0 ) != 923  ){ fail_step = 2; } // top right
    if( xy(0, 21) != 1764 ){ fail_step = 3; } // bottom left
    if( xy(83,21) != 1847 ){ fail_step = 4; } // bottom_right
    if( xy(41,10) != 1301 ){ fail_step = 5; } // center
    
    if(fail_step == 0){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print("FAIL_STEP: ");
        Serial.println(fail_step);
        
        success = false;
    }
        
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ set_brightness ------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("set_brightness() ................ "));
    
    bool success_temp = true;
    for(uint8_t i = 0; i < 100; i++){
        uint8_t rand_brightness = random( 0, 255 );
        set_brightness( rand_brightness );
        show();
        
        if( brightness_level != rand_brightness ){
            success_temp = false;
        }
    }
    
    if(success_temp == true){
        set_brightness( 8 );
        show();
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ set_palette ---------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    set_color_animation(ANIMATION_STATIC);
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("set_palette() ................... "));
    
    print("------------------------");
    
    success_temp = true;
    for(uint8_t i = 0; i < 100; i++){       
        CRGB rands[8] = {
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255)),
            CRGB(random(0,255), random(0,255), random(0,255))
        };
        
        CRGBPalette16 test_palette = CRGBPalette16(
                                        rands[0],  rands[1],  rands[2],  rands[3], 
                                        rands[4],  rands[5],  rands[6],  rands[7],
                                        rands[0],  rands[1],  rands[2],  rands[3], 
                                        rands[4],  rands[5],  rands[6],  rands[7]
                                    );
        
        set_palette( test_palette );
        show();
        
        bool success_temp_b = true;
        for(uint8_t i = 0; i < 8; i++){
            if(test_palette.entries[i] != rands[i] || test_palette.entries[i+8] != rands[i]){
                success_temp_b = false;
            }
        }
        
        if(!success_temp_b){
            success_temp = false;
        }
    }
 
    if(success_temp){
        Serial.println(PASS);
        set_palette(GREEN_SOLID);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ set_update_mode ------------------------------------------------------------------------ @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("set_update_mode() ............... "));
    fail_step = 0;
    
    set_update_mode(AUTOMATIC); 
    if(!ticker_running){
        fail_step = 1;
    }
    
    set_update_mode(MANUAL);    
    if(ticker_running){
        fail_step = 2;
    }   
 
    if(fail_step == 0){
        set_update_mode( MANUAL );
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.println(fail_step);
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ write(bitmap) ---------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    /*
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("write(bitmap) ..................... "));
 
    clear();
    write(bitmap_HEART,0,0);
    show();
 
    success_temp = true;
    for(uint8_t x = 0; x < 5; x++){
        uint8_t column = pgm_read_byte_far( bitmap_HEART+x );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t bitmap_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x, y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(bitmap_val != mask_val){
                success_temp = false;
            }
        }
    }
    
    if(success_temp){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    */
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ write(int16_t) ------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("write(int16_t) .................. "));
 
    clear();
    write(int16_t(-2),0,0);
    show();
 
    success_temp = true;
    for(uint8_t x = 0; x < 5; x++){
        char chr = '-';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x, y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    for(uint8_t x = 0; x < 5; x++){
        char chr = '2';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x+(display_width*1), y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    for(uint8_t x = 0; x < 5; x++){
        char chr = ' ';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x+(display_width*2), y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    
    if(success_temp){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ print(bitmap) ---------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    /*
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("print(bitmap) ..................... "));
 
    clear();
    print(bitmap_HEART);
    show();
 
    success_temp = true;
    for(uint8_t x = 0; x < 5; x++){
        uint8_t column = pgm_read_byte_far( bitmap_HEART+x );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t bitmap_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x, y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(bitmap_val != mask_val){
                success_temp = false;
            }
        }
    }
    
    if(success_temp){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    */
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ print(int16_t) ------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("print(int16_t) .................. "));
 
    clear();
    print(int16_t(-2));
    show();
 
    success_temp = true;
    for(uint8_t x = 0; x < 5; x++){
        char chr = '-';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x, y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    for(uint8_t x = 0; x < 5; x++){
        char chr = '2';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x+(display_width*1), y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    for(uint8_t x = 0; x < 5; x++){
        char chr = ' ';
        chr -= printable_ascii_offset;
        uint8_t column = pgm_read_byte( font + ( chr * font_col_width + x ) );
        
        for(uint8_t y = 0; y < 7; y++){
            uint8_t char_val = bit_table[ bitRead( column, y ) ];
            
            uint16_t index = xy(x+display_padding_x+(display_width*2), y+display_padding_y);
            uint8_t mask_val = mask[index];
            
            if(char_val != mask_val){
                success_temp = false;
            }
        }
    }
    
    if(success_temp){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ set_cursor(2,3) ------------------------------------------------------------------------ @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("set_cursor(2,3) ................. "));
 
    set_cursor(2,3); // whole displays
 
    if(cursor_x != 15 || cursor_y != 35){ // pixel positions calculated
        success = false;
    }
    
    if(success){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print("cursor: (");
        Serial.print(cursor_x);
        Serial.print(',');
        Serial.println(") != (15,35)");
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ get_cursor_x --------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("get_cursor_x() .................. "));
 
    if(get_cursor_x() == 2){ // whole displays
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print(get_cursor_x());
        Serial.println(" != 2");
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ get_cursor_y --------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("get_cursor_y() .................. "));
 
    if(get_cursor_y() == 3){ // whole displays
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print(get_cursor_y());
        Serial.println(" != 2");
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ get_cursor_x_exact --------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("get_cursor_x_exact() ............ "));
 
    if(get_cursor_x_exact() == 15){ // whole displays
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print(get_cursor_x_exact());
        Serial.println(" != 15");
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ get_cursor_y_exact --------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("get_cursor_y_exact() ............ "));
 
    if(get_cursor_y_exact() == 35){ // whole displays
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.print(get_cursor_y_exact());
        Serial.println(" != 35");
        success = false;
    }
    
    Serial.println(border);
    
    
    // ----------------------------------------------------------------------------------------------------
    // @@@@@ clear ---------------------------------------------------------------------------------- @@@@@
    // ----------------------------------------------------------------------------------------------------
    
    Serial.println( border );
    Serial.print  ( testing );
    Serial.print(F("clear() ......................... "));
    
    clear();
    fail_step = 0;
 
    for(uint16_t i = 0; i < pixel_count; i++){
        if(mask[i] != 0){
            fail_step = 1;
        }
    }
    
    if(success_temp){
        if(cursor_x != display_padding_x || cursor_y != display_padding_y){ // Default position after clear()
            fail_step = 2;
        }
    }
 
    if(fail_step == 0){
        Serial.println(PASS);
    }
    else{
        Serial.println(FAIL);
        Serial.println(fail_step);
        success = false;
    }
    
    Serial.println(border);
    
    
    Serial.println("\nXY MAP:");
    print_xy_table();
 
    return success; 
}