users/xtonhasvim/fancylighting.c

   1  /* Copyright 2015-2017 Christon DeWan
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #ifdef RGBLIGHT_ENABLE
  18
  19 #include <math.h>
  20
  21 #include "rgblight.h"
  22 #include "color.h"
  23 #include "fancylighting.h"
  24
  25
  26 __attribute__ ((weak))
  27 void matrix_scan_keymap(void) {
  28   // override me, if you want.
  29   return;
  30 }
  31
  32 #define ABSDIFF(a,b) ((a)>(b)?(a)-(b):(b)-(a))
  33
  34 #define FADE_BACK_TIME 500
  35 #define BREATH_FIRE_TIME 1000
  36 #define ANIMATION_STEP_INTERVAL 20
  37
  38 #if RGBLED_NUM >= 2
  39 #define POWER_KEY_OFFSET (RGBLED_NUM / 2)
  40 #define SPACE_OFFSET_MAX (RGBLED_NUM / 2)
  41 #else
  42 #define POWER_KEY_OFFSET 1
  43 #define SPACE_OFFSET_MAX 1
  44 #endif
  45
  46 uint16_t effect_start_timer = 0;
  47 uint8_t user_rgb_mode = 0;
  48 LED_TYPE shadowed_led[RGBLED_NUM] = {{0}};
  49
  50 void start_firey_return(void) {
  51   user_rgb_mode = BREATH_FIRE;
  52   effect_start_timer = timer_read();
  53   for(uint8_t i = 0; i < RGBLED_NUM; i++) {
  54     shadowed_led[i] = led[i];
  55   }
  56 }
  57
  58 /** 0---max
  59  *  [___]
  60  *  [__/]
  61  *  [_/\]
  62  *  [/\_]
  63  *  [\__]
  64  *  [___]
  65  **/
  66
  67 void set_color_for_offsets(uint16_t time_offset, uint16_t space_offset, uint8_t idx) {
  68   float time_progress = (float)time_offset / BREATH_FIRE_TIME;
  69   float space_progress = (float)space_offset / SPACE_OFFSET_MAX;
  70   float progress = time_progress * 5.0 - space_progress;
  71   if(progress > 1.0) {
  72     progress -= 1.0;
  73     progress /= 4.0;
  74     progress = 1.0 - progress;
  75   }
  76   progress = fmax(0.0,progress);
  77   progress *= progress; // squared!
  78
  79   float alpha = (time_progress + 0.1) * 7.0 - space_progress;
  80   alpha = fmin(1.0, alpha*alpha);
  81
  82   LED_TYPE px[1] = {{0}};
  83   sethsv((uint16_t)(fmod(time_progress * 1.5 + space_progress,1.0)*360), 255, (uint8_t)(progress*255),&px[0]);
  84   led[idx].r = alpha * px[0].r + ( 1.0 - alpha) * shadowed_led[idx].r;
  85   led[idx].g = alpha * px[0].g + ( 1.0 - alpha) * shadowed_led[idx].g;
  86   led[idx].b = alpha * px[0].b + ( 1.0 - alpha) * shadowed_led[idx].b;
  87 }
  88
  89 /**
  90  * It's actually a rainbow: a fire curve didn't really look right.
  91  * it's still cool, though!
  92  */
  93 void rgb_mode_breath_fire(void) {
  94   static uint16_t last_timer = 0;
  95   if(!last_timer) last_timer = timer_read();
  96   uint16_t this_timer = timer_read();
  97
  98   // too soon. don't spam updates
  99   if(this_timer - last_timer < ANIMATION_STEP_INTERVAL) return;
 100
 101   uint16_t elapsed = this_timer - effect_start_timer;
 102
 103   last_timer = this_timer;
 104   if(elapsed >= BREATH_FIRE_TIME) {
 105     // complete
 106     user_rgb_mode = FADE_BACK;
 107     effect_start_timer = this_timer;
 108   } else {
 109     // linear fade
 110     for(uint16_t i = 0; i < RGBLED_NUM; i++) {
 111       uint16_t space_offset = ABSDIFF(i,POWER_KEY_OFFSET);
 112       if(space_offset > SPACE_OFFSET_MAX) space_offset = RGBLED_NUM - space_offset;
 113
 114       set_color_for_offsets(elapsed, space_offset, i);
 115     }
 116     rgblight_set();
 117   }
 118 }
 119
 120 void rgb_mode_fade_back(void) {
 121   static uint16_t last_timer = 0;
 122   if(!last_timer) last_timer = timer_read();
 123   uint16_t this_timer = timer_read();
 124
 125   // too soon. don't spam updates
 126   if(this_timer - last_timer < ANIMATION_STEP_INTERVAL) return;
 127
 128   uint16_t elapsed = this_timer - effect_start_timer;
 129
 130   last_timer = this_timer;
 131   float progress = (float)elapsed / FADE_BACK_TIME;
 132   progress = fmin(1.0,progress);
 133
 134   for(uint8_t i = 0; i < RGBLED_NUM; i++) {
 135     led[i].r = shadowed_led[i].r * progress;
 136     led[i].g = shadowed_led[i].g * progress;
 137     led[i].b = shadowed_led[i].b * progress;
 138   }
 139   rgblight_set();
 140
 141   if(elapsed >= FADE_BACK_TIME) user_rgb_mode = 0;
 142 }
 143
 144 /** called when layer state or vstate has changed */
 145 __attribute__ ((weak))
 146 void set_state_leds(void) {
 147   return;
 148 }
 149
 150 void matrix_scan_user(void) {
 151   static uint32_t last_layer = 0;
 152   static uint32_t last_vstate = 0;
 153   if(last_layer != layer_state || last_vstate != vstate) set_state_leds();
 154   last_layer = layer_state;
 155   last_vstate = vstate;
 156
 157   switch (user_rgb_mode) {
 158     case BREATH_FIRE:
 159       rgb_mode_breath_fire();
 160       break;
 161     case FADE_BACK:
 162       rgb_mode_fade_back();
 163       break;
 164   }
 165   matrix_scan_keymap();
 166 }
 167
 168 #else
 169
 170 void start_firey_return(void) {}
 171
 172 #endif