quantum/visualizer/led_test.c

   1 /*
   2 The MIT License (MIT)
   3
   4 Copyright (c) 2016 Fred Sundvik
   5
   6 Permission is hereby granted, free of charge, to any person obtaining a copy
   7 of this software and associated documentation files (the "Software"), to deal
   8 in the Software without restriction, including without limitation the rights
   9 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 copies of the Software, and to permit persons to whom the Software is
  11 furnished to do so, subject to the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included in all
  14 copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22 SOFTWARE.
  23 */
  24 #include "led_test.h"
  25 #include "gfx.h"
  26 #include "math.h"
  27
  28 #define CROSSFADE_TIME 1000
  29 #define GRADIENT_TIME 3000
  30
  31 keyframe_animation_t led_test_animation = {
  32     .num_frames = 14,
  33     .loop = true,
  34     .frame_lengths = {
  35         gfxMillisecondsToTicks(1000), // fade in
  36         gfxMillisecondsToTicks(1000), // no op (leds on)
  37         gfxMillisecondsToTicks(1000), // fade out
  38         gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
  39         gfxMillisecondsToTicks(GRADIENT_TIME), // left to rigt (outside in)
  40         gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
  41         gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
  42         0,           // mirror leds
  43         gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
  44         gfxMillisecondsToTicks(GRADIENT_TIME), // left_to_right (mirrored, so inside out)
  45         gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
  46         gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
  47         0,           // normal leds
  48         gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
  49
  50     },
  51     .frame_functions = {
  52         keyframe_fade_in_all_leds,
  53         keyframe_no_operation,
  54         keyframe_fade_out_all_leds,
  55         keyframe_led_crossfade,
  56         keyframe_led_left_to_right_gradient,
  57         keyframe_led_crossfade,
  58         keyframe_led_top_to_bottom_gradient,
  59         keyframe_mirror_led_orientation,
  60         keyframe_led_crossfade,
  61         keyframe_led_left_to_right_gradient,
  62         keyframe_led_crossfade,
  63         keyframe_led_top_to_bottom_gradient,
  64         keyframe_normal_led_orientation,
  65         keyframe_led_crossfade,
  66     },
  67 };
  68
  69 static uint8_t fade_led_color(keyframe_animation_t* animation, int from, int to) {
  70     int frame_length = animation->frame_lengths[animation->current_frame];
  71     int current_pos = frame_length - animation->time_left_in_frame;
  72     int delta = to - from;
  73     int luma = (delta * current_pos) / frame_length;
  74     luma += from;
  75     return luma;
  76 }
  77
  78 static void keyframe_fade_all_leds_from_to(keyframe_animation_t* animation, uint8_t from, uint8_t to) {
  79     uint8_t luma = fade_led_color(animation, from, to);
  80     color_t color = LUMA2COLOR(luma);
  81     gdispGClear(LED_DISPLAY, color);
  82 }
  83
  84 // TODO: Should be customizable per keyboard
  85 #define NUM_ROWS 7
  86 #define NUM_COLS 7
  87
  88 static uint8_t crossfade_start_frame[NUM_ROWS][NUM_COLS];
  89 static uint8_t crossfade_end_frame[NUM_ROWS][NUM_COLS];
  90
  91 static uint8_t compute_gradient_color(float t, float index, float num) {
  92     const float two_pi = M_2_PI;
  93     float normalized_index = (1.0f - index / (num - 1.0f)) * two_pi;
  94     float x = t * two_pi + normalized_index;
  95     float v = 0.5 * (cosf(x) + 1.0f);
  96     return (uint8_t)(255.0f * v);
  97 }
  98
  99 bool keyframe_fade_in_all_leds(keyframe_animation_t* animation, visualizer_state_t* state) {
 100     (void)state;
 101     keyframe_fade_all_leds_from_to(animation, 0, 255);
 102     return true;
 103 }
 104
 105 bool keyframe_fade_out_all_leds(keyframe_animation_t* animation, visualizer_state_t* state) {
 106     (void)state;
 107     keyframe_fade_all_leds_from_to(animation, 255, 0);
 108     return true;
 109 }
 110
 111 bool keyframe_led_left_to_right_gradient(keyframe_animation_t* animation, visualizer_state_t* state) {
 112     (void)state;
 113     float frame_length = animation->frame_lengths[animation->current_frame];
 114     float current_pos = frame_length - animation->time_left_in_frame;
 115     float t = current_pos / frame_length;
 116     for (int i=0; i< NUM_COLS; i++) {
 117         uint8_t color = compute_gradient_color(t, i, NUM_COLS);
 118         gdispGDrawLine(LED_DISPLAY, i, 0, i, NUM_ROWS - 1, LUMA2COLOR(color));
 119     }
 120     return true;
 121 }
 122
 123 bool keyframe_led_top_to_bottom_gradient(keyframe_animation_t* animation, visualizer_state_t* state) {
 124     (void)state;
 125     float frame_length = animation->frame_lengths[animation->current_frame];
 126     float current_pos = frame_length - animation->time_left_in_frame;
 127     float t = current_pos / frame_length;
 128     for (int i=0; i< NUM_ROWS; i++) {
 129         uint8_t color = compute_gradient_color(t, i, NUM_ROWS);
 130         gdispGDrawLine(LED_DISPLAY, 0, i, NUM_COLS - 1, i, LUMA2COLOR(color));
 131     }
 132     return true;
 133 }
 134
 135 static void copy_current_led_state(uint8_t* dest) {
 136     for (int i=0;i<NUM_ROWS;i++) {
 137         for (int j=0;j<NUM_COLS;j++) {
 138             dest[i*NUM_COLS + j] = gdispGGetPixelColor(LED_DISPLAY, j, i);
 139         }
 140     }
 141 }
 142 bool keyframe_led_crossfade(keyframe_animation_t* animation, visualizer_state_t* state) {
 143     (void)state;
 144     if (animation->first_update_of_frame) {
 145         copy_current_led_state(&crossfade_start_frame[0][0]);
 146         run_next_keyframe(animation, state);
 147         copy_current_led_state(&crossfade_end_frame[0][0]);
 148     }
 149     for (int i=0;i<NUM_ROWS;i++) {
 150         for (int j=0;j<NUM_COLS;j++) {
 151             color_t color  = LUMA2COLOR(fade_led_color(animation, crossfade_start_frame[i][j], crossfade_end_frame[i][j]));
 152             gdispGDrawPixel(LED_DISPLAY, j, i, color);
 153         }
 154     }
 155     return true;
 156 }
 157
 158 bool keyframe_mirror_led_orientation(keyframe_animation_t* animation, visualizer_state_t* state) {
 159     (void)state;
 160     (void)animation;
 161     gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_180);
 162     return false;
 163 }
 164
 165 bool keyframe_normal_led_orientation(keyframe_animation_t* animation, visualizer_state_t* state) {
 166     (void)state;
 167     (void)animation;
 168     gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_0);
 169     return false;
 170 }