|
|
|
@ -1,138 +1,77 @@ |
|
|
|
#include "curry.h" |
|
|
|
#include "rgb_stuff.h" |
|
|
|
#include "eeprom.h" |
|
|
|
#include "rgb_lighting_user.h" |
|
|
|
|
|
|
|
#if defined(RGBLIGHT_ENABLE) |
|
|
|
extern rgblight_config_t rgblight_config; |
|
|
|
bool has_initialized; |
|
|
|
|
|
|
|
void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); } |
|
|
|
#endif // RGBLIGHT_ENABLE |
|
|
|
|
|
|
|
#if defined(RGB_MATRIX_ENABLE) |
|
|
|
static uint32_t hypno_timer; |
|
|
|
# if defined(SPLIT_KEYBOARD) || defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_crkbd) |
|
|
|
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL |
|
|
|
# else |
|
|
|
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN |
|
|
|
# endif |
|
|
|
|
|
|
|
void suspend_power_down_keymap(void) { rgb_matrix_set_suspend_state(true); } |
|
|
|
|
|
|
|
void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); } |
|
|
|
|
|
|
|
void check_default_layer(uint8_t mode, uint8_t type) { |
|
|
|
switch (get_highest_layer(default_layer_state)) { |
|
|
|
case _QWERTY: |
|
|
|
rgb_matrix_layer_helper(HSV_CYAN, mode, rgb_matrix_config.speed, type); |
|
|
|
break; |
|
|
|
case _COLEMAK: |
|
|
|
rgb_matrix_layer_helper(HSV_MAGENTA, mode, rgb_matrix_config.speed, type); |
|
|
|
break; |
|
|
|
case _DVORAK: |
|
|
|
rgb_matrix_layer_helper(HSV_SPRINGGREEN, mode, rgb_matrix_config.speed, type); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
void rgb_matrix_indicators_user(void) { |
|
|
|
if (userspace_config.rgb_layer_change && |
|
|
|
# ifdef RGB_DISABLE_WHEN_USB_SUSPENDED |
|
|
|
!g_suspend_state && |
|
|
|
# endif |
|
|
|
# if defined(RGBLIGHT_ENABLE) |
|
|
|
(!rgblight_config.enable && rgb_matrix_config.enable) |
|
|
|
# else |
|
|
|
rgb_matrix_config.enable |
|
|
|
# endif |
|
|
|
) { |
|
|
|
switch (get_highest_layer(layer_state)) { |
|
|
|
case _RAISE: |
|
|
|
rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); |
|
|
|
break; |
|
|
|
case _LOWER: |
|
|
|
rgb_matrix_layer_helper(HSV_GREEN, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); |
|
|
|
break; |
|
|
|
case _ADJUST: |
|
|
|
rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); |
|
|
|
break; |
|
|
|
default: { |
|
|
|
check_default_layer(IS_LAYER_ON(_MODS), LED_FLAG_UNDERGLOW); |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
check_default_layer(0, LED_FLAG_MODIFIER); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
/* Custom indicators for modifiers. |
|
|
|
* This allows for certain lights to be lit up, based on what mods are active, giving some visual feedback. |
|
|
|
* This is especially useful for One Shot Mods, since it's not always obvious if they're still lit up. |
|
|
|
*/ |
|
|
|
#ifdef RGBLIGHT_ENABLE |
|
|
|
# ifdef INDICATOR_LIGHTS |
|
|
|
#if defined(INDICATOR_LIGHTS) |
|
|
|
void set_rgb_indicators(uint8_t this_mod, uint8_t this_led, uint8_t this_osm) { |
|
|
|
if (userspace_config.rgb_layer_change && get_highest_layer(layer_state) == 0) { |
|
|
|
if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) { |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
rgblight_sethsv_at(120, 255, 255, SHFT_LED1); |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
rgblight_sethsv_at(120, 255, 255, SHFT_LED2); |
|
|
|
# endif // SHFT_LED2 |
|
|
|
# endif // SHFT_LED2 |
|
|
|
} else { |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
rgblight_sethsv_default_helper(SHFT_LED1); |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
rgblight_sethsv_default_helper(SHFT_LED2); |
|
|
|
# endif // SHFT_LED2 |
|
|
|
# endif // SHFT_LED2 |
|
|
|
} |
|
|
|
if ((this_mod | this_osm) & MOD_MASK_CTRL) { |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
rgblight_sethsv_at(0, 255, 255, CTRL_LED1); |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
rgblight_sethsv_at(0, 255, 255, CTRL_LED2); |
|
|
|
# endif // CTRL_LED2 |
|
|
|
# endif // CTRL_LED2 |
|
|
|
} else { |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
rgblight_sethsv_default_helper(CTRL_LED1); |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
rgblight_sethsv_default_helper(CTRL_LED2); |
|
|
|
# endif // CTRL_LED2 |
|
|
|
# endif // CTRL_LED2 |
|
|
|
} |
|
|
|
if ((this_mod | this_osm) & MOD_MASK_GUI) { |
|
|
|
# ifdef GUI_LED1 |
|
|
|
# ifdef GUI_LED1 |
|
|
|
rgblight_sethsv_at(51, 255, 255, GUI_LED1); |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
rgblight_sethsv_at(51, 255, 255, GUI_LED2); |
|
|
|
# endif // GUI_LED2 |
|
|
|
# endif // GUI_LED2 |
|
|
|
} else { |
|
|
|
# ifdef GUI_LED1 |
|
|
|
# ifdef GUI_LED1 |
|
|
|
rgblight_sethsv_default_helper(GUI_LED1); |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
rgblight_sethsv_default_helper(GUI_LED2); |
|
|
|
# endif // GUI_LED2 |
|
|
|
# endif // GUI_LED2 |
|
|
|
} |
|
|
|
if ((this_mod | this_osm) & MOD_MASK_ALT) { |
|
|
|
# ifdef ALT_LED1 |
|
|
|
# ifdef ALT_LED1 |
|
|
|
rgblight_sethsv_at(240, 255, 255, ALT_LED1); |
|
|
|
# endif // ALT_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
# endif // ALT_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
rgblight_sethsv_at(240, 255, 255, ALT_LED2); |
|
|
|
# endif // GUI_LED2 |
|
|
|
# endif // GUI_LED2 |
|
|
|
} else { |
|
|
|
# ifdef GUI_LED1 |
|
|
|
# ifdef GUI_LED1 |
|
|
|
rgblight_sethsv_default_helper(ALT_LED1); |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
rgblight_sethsv_default_helper(ALT_LED2); |
|
|
|
# endif // GUI_LED2 |
|
|
|
# endif // GUI_LED2 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
@ -143,9 +82,9 @@ void matrix_scan_indicator(void) { |
|
|
|
set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods()); |
|
|
|
} |
|
|
|
} |
|
|
|
# endif // INDICATOR_LIGHTS |
|
|
|
#endif // INDICATOR_LIGHTS |
|
|
|
|
|
|
|
# ifdef RGBLIGHT_TWINKLE |
|
|
|
#if defined(RGBLIGHT_TWINKLE) |
|
|
|
static rgblight_fadeout lights[RGBLED_NUM]; |
|
|
|
|
|
|
|
__attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; } |
|
|
|
@ -153,40 +92,40 @@ __attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { |
|
|
|
/* This function checks for used LEDs. This way, collisions don't occur and cause weird rendering */ |
|
|
|
bool rgblight_twinkle_is_led_used(uint8_t index) { |
|
|
|
switch (index) { |
|
|
|
# ifdef INDICATOR_LIGHTS |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
# ifdef INDICATOR_LIGHTS |
|
|
|
# ifdef SHFT_LED1 |
|
|
|
case SHFT_LED1: |
|
|
|
return true; |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
# endif // SHFT_LED1 |
|
|
|
# ifdef SHFT_LED2 |
|
|
|
case SHFT_LED2: |
|
|
|
return true; |
|
|
|
# endif // SHFT_LED2 |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
# endif // SHFT_LED2 |
|
|
|
# ifdef CTRL_LED1 |
|
|
|
case CTRL_LED1: |
|
|
|
return true; |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
# endif // CTRL_LED1 |
|
|
|
# ifdef CTRL_LED2 |
|
|
|
case CTRL_LED2: |
|
|
|
return true; |
|
|
|
# endif // CTRL_LED2 |
|
|
|
# ifdef GUI_LED1 |
|
|
|
# endif // CTRL_LED2 |
|
|
|
# ifdef GUI_LED1 |
|
|
|
case GUI_LED1: |
|
|
|
return true; |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
# endif // GUI_LED1 |
|
|
|
# ifdef GUI_LED2 |
|
|
|
case GUI_LED2: |
|
|
|
return true; |
|
|
|
# endif // GUI_LED2 |
|
|
|
# ifdef ALT_LED1 |
|
|
|
# endif // GUI_LED2 |
|
|
|
# ifdef ALT_LED1 |
|
|
|
case ALT_LED1: |
|
|
|
return true; |
|
|
|
# endif // ALT_LED1 |
|
|
|
# ifdef ALT_LED2 |
|
|
|
# endif // ALT_LED1 |
|
|
|
# ifdef ALT_LED2 |
|
|
|
case ALT_LED2: |
|
|
|
return true; |
|
|
|
# endif // ALT_LED2 |
|
|
|
# endif // INDICATOR_LIGHTS |
|
|
|
# endif // ALT_LED2 |
|
|
|
# endif // INDICATOR_LIGHTS |
|
|
|
default: |
|
|
|
return rgblight_twinkle_is_led_used_keymap(index); |
|
|
|
} |
|
|
|
@ -259,8 +198,7 @@ void start_rgb_light(void) { |
|
|
|
|
|
|
|
rgblight_sethsv_at(light->hue, 255, light->life, light_index); |
|
|
|
} |
|
|
|
# endif |
|
|
|
#endif // RGBLIGHT_ENABLE |
|
|
|
#endif |
|
|
|
|
|
|
|
bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { |
|
|
|
uint16_t temp_keycode = keycode; |
|
|
|
@ -269,15 +207,8 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { |
|
|
|
temp_keycode &= 0xFF; |
|
|
|
} |
|
|
|
|
|
|
|
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) |
|
|
|
hypno_timer = timer_read32(); |
|
|
|
if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_REST_MODE) { |
|
|
|
rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
switch (temp_keycode) { |
|
|
|
#ifdef RGBLIGHT_TWINKLE |
|
|
|
#if defined(RGBLIGHT_TWINKLE) |
|
|
|
case KC_A ... KC_SLASH: |
|
|
|
case KC_F1 ... KC_F12: |
|
|
|
case KC_INSERT ... KC_UP: |
|
|
|
@ -290,7 +221,6 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { |
|
|
|
break; |
|
|
|
#endif // RGBLIGHT_TWINKLE |
|
|
|
case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal |
|
|
|
#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) |
|
|
|
if (record->event.pressed) { |
|
|
|
userspace_config.rgb_layer_change ^= 1; |
|
|
|
dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); |
|
|
|
@ -299,38 +229,16 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { |
|
|
|
layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better) |
|
|
|
} |
|
|
|
} |
|
|
|
#endif // RGBLIGHT_ENABLE |
|
|
|
break; |
|
|
|
case RGB_IDL: // This allows me to use underglow as layer indication, or as normal |
|
|
|
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) |
|
|
|
if (record->event.pressed) { |
|
|
|
userspace_config.rgb_matrix_idle_anim ^= 1; |
|
|
|
dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim); |
|
|
|
eeconfig_update_user(userspace_config.raw); |
|
|
|
if (userspace_config.rgb_matrix_idle_anim) { |
|
|
|
rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
break; |
|
|
|
case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions |
|
|
|
if (record->event.pressed) { |
|
|
|
bool is_eeprom_updated = false; |
|
|
|
#ifdef RGBLIGHT_ENABLE |
|
|
|
// This disables layer indication, as it's assumed that if you're changing this ... you want that disabled |
|
|
|
if (userspace_config.rgb_layer_change) { |
|
|
|
userspace_config.rgb_layer_change = false; |
|
|
|
dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change); |
|
|
|
is_eeprom_updated = true; |
|
|
|
} |
|
|
|
#endif |
|
|
|
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) |
|
|
|
if (userspace_config.rgb_matrix_idle_anim) { |
|
|
|
userspace_config.rgb_matrix_idle_anim = false; |
|
|
|
dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim); |
|
|
|
is_eeprom_updated = true; |
|
|
|
} |
|
|
|
#endif |
|
|
|
if (is_eeprom_updated) { |
|
|
|
eeconfig_update_user(userspace_config.raw); |
|
|
|
} |
|
|
|
@ -341,8 +249,7 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { |
|
|
|
} |
|
|
|
|
|
|
|
void keyboard_post_init_rgb(void) { |
|
|
|
#if defined(RGBLIGHT_ENABLE) |
|
|
|
# if defined(RGBLIGHT_STARTUP_ANIMATION) |
|
|
|
#if defined(RGBLIGHT_STARTUP_ANIMATION) |
|
|
|
bool is_enabled = rgblight_config.enable; |
|
|
|
if (userspace_config.rgb_layer_change) { |
|
|
|
rgblight_enable_noeeprom(); |
|
|
|
@ -361,44 +268,27 @@ void keyboard_post_init_rgb(void) { |
|
|
|
rgblight_disable_noeeprom(); |
|
|
|
} |
|
|
|
|
|
|
|
# endif |
|
|
|
layer_state_set_user(layer_state); |
|
|
|
#endif |
|
|
|
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) |
|
|
|
if (userspace_config.rgb_matrix_idle_anim) { |
|
|
|
rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE); |
|
|
|
} |
|
|
|
#endif |
|
|
|
layer_state_set_user(layer_state); |
|
|
|
} |
|
|
|
|
|
|
|
void matrix_scan_rgb(void) { |
|
|
|
#ifdef RGBLIGHT_ENABLE |
|
|
|
# ifdef RGBLIGHT_TWINKLE |
|
|
|
#if defined(RGBLIGHT_TWINKLE) |
|
|
|
scan_rgblight_fadeout(); |
|
|
|
# endif // RGBLIGHT_ENABLE |
|
|
|
#endif // RGBLIGHT_ENABLE |
|
|
|
|
|
|
|
# ifdef INDICATOR_LIGHTS |
|
|
|
#if defined(INDICATOR_LIGHTS) |
|
|
|
matrix_scan_indicator(); |
|
|
|
# endif |
|
|
|
#endif |
|
|
|
|
|
|
|
#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) |
|
|
|
if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_TYPING_HEATMAP && timer_elapsed32(hypno_timer) > 15000) { |
|
|
|
rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE); |
|
|
|
} |
|
|
|
#endif |
|
|
|
} |
|
|
|
|
|
|
|
#ifdef RGBLIGHT_ENABLE |
|
|
|
void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) { |
|
|
|
rgblight_sethsv_noeeprom(hue, sat, val); |
|
|
|
wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly |
|
|
|
rgblight_mode_noeeprom(mode); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
layer_state_t layer_state_set_rgb(layer_state_t state) { |
|
|
|
#ifdef RGBLIGHT_ENABLE |
|
|
|
if (userspace_config.rgb_layer_change) { |
|
|
|
switch (get_highest_layer(state)) { |
|
|
|
case _RAISE: |
|
|
|
@ -420,6 +310,9 @@ layer_state_t layer_state_set_rgb(layer_state_t state) { |
|
|
|
case _DVORAK: |
|
|
|
rgblight_set_hsv_and_mode(HSV_SPRINGGREEN, mode); |
|
|
|
break; |
|
|
|
case _WORKMAN: |
|
|
|
rgblight_set_hsv_and_mode(HSV_GOLDENROD, mode); |
|
|
|
break; |
|
|
|
default: |
|
|
|
rgblight_set_hsv_and_mode(HSV_CYAN, mode); |
|
|
|
break; |
|
|
|
@ -428,44 +321,5 @@ layer_state_t layer_state_set_rgb(layer_state_t state) { |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
#endif // RGBLIGHT_ENABLE |
|
|
|
|
|
|
|
return state; |
|
|
|
} |
|
|
|
|
|
|
|
#ifdef RGB_MATRIX_ENABLE |
|
|
|
# include "lib/lib8tion/lib8tion.h" |
|
|
|
extern led_config_t g_led_config; |
|
|
|
|
|
|
|
void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) { |
|
|
|
HSV hsv = {hue, sat, val}; |
|
|
|
if (hsv.v > rgb_matrix_config.hsv.v) { |
|
|
|
hsv.v = rgb_matrix_config.hsv.v; |
|
|
|
} |
|
|
|
|
|
|
|
switch (mode) { |
|
|
|
case 1: // breathing |
|
|
|
{ |
|
|
|
uint16_t time = scale16by8(g_rgb_counters.tick, speed / 8); |
|
|
|
hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); |
|
|
|
RGB rgb = hsv_to_rgb(hsv); |
|
|
|
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { |
|
|
|
if (HAS_FLAGS(g_led_config.flags[i], led_type)) { |
|
|
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); |
|
|
|
} |
|
|
|
} |
|
|
|
break; |
|
|
|
} |
|
|
|
default: // Solid Color |
|
|
|
{ |
|
|
|
RGB rgb = hsv_to_rgb(hsv); |
|
|
|
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { |
|
|
|
if (HAS_FLAGS(g_led_config.flags[i], led_type)) { |
|
|
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); |
|
|
|
} |
|
|
|
} |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
Akaash Suresh
4 years ago
Drashna Jaelre