diff options
Diffstat (limited to 'quantum')
70 files changed, 1176 insertions, 1514 deletions
diff --git a/quantum/audio/song_list.h b/quantum/audio/song_list.h index 1d4eec7116..33dbcfcb1d 100644 --- a/quantum/audio/song_list.h +++ b/quantum/audio/song_list.h @@ -1,4 +1,7 @@ -/* Copyright 2016 Jack Humbert +/* Any song or sound without a license explicitly stated is: + * + * Copyright 2016 Jack Humbert + * Copyright 2017 Zach White * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -13,57 +16,32 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#include "musical_notes.h" +#pragma once -#ifndef SONG_LIST_H -#define SONG_LIST_H +#include "musical_notes.h" #define NO_SOUND -#define LP_NUMB \ - H__NOTE(_CS5), H__NOTE(_E5), H__NOTE(_CS5), WD_NOTE(_FS5), \ - WD_NOTE(_A5), WD_NOTE(_GS5), WD_NOTE(_REST), H__NOTE(_CS5), H__NOTE(_E5), \ - H__NOTE(_CS5), WD_NOTE(_A5), WD_NOTE(_GS5), WD_NOTE(_E5), - - +/* Ode to Joy + * Author: Friedrich Schiller + + License: Public Domain + */ #define ODE_TO_JOY \ Q__NOTE(_E4), Q__NOTE(_E4), Q__NOTE(_F4), Q__NOTE(_G4), \ Q__NOTE(_G4), Q__NOTE(_F4), Q__NOTE(_E4), Q__NOTE(_D4), \ Q__NOTE(_C4), Q__NOTE(_C4), Q__NOTE(_D4), Q__NOTE(_E4), \ QD_NOTE(_E4), E__NOTE(_D4), H__NOTE(_D4), +/* Rock-a-bye Baby + * Author: Unknown + + License: Public Domain + */ #define ROCK_A_BYE_BABY \ QD_NOTE(_B4), E__NOTE(_D4), Q__NOTE(_B5), \ H__NOTE(_A5), Q__NOTE(_G5), \ QD_NOTE(_B4), E__NOTE(_D5), Q__NOTE(_G5), \ H__NOTE(_FS5), -#define CLOSE_ENCOUNTERS_5_NOTE \ - Q__NOTE(_D5), \ - Q__NOTE(_E5), \ - Q__NOTE(_C5), \ - Q__NOTE(_C4), \ - Q__NOTE(_G4), - -#define DOE_A_DEER \ - QD_NOTE(_C4), E__NOTE(_D4), \ - QD_NOTE(_E4), E__NOTE(_C4), \ - Q__NOTE(_E4), Q__NOTE(_C4), \ - Q__NOTE(_E4), - -/* Requires: PLAY_NOTE_ARRAY(..., ..., STACCATO); */ -#define IN_LIKE_FLINT \ - E__NOTE(_AS4), E__NOTE(_AS4), QD_NOTE(_B4), \ - E__NOTE(_AS4), E__NOTE(_B4), QD_NOTE(_CS4), \ - E__NOTE(_B4), E__NOTE(_CS4), QD_NOTE(_DS4), \ - E__NOTE(_CS4), E__NOTE(_B4), QD_NOTE(_AS4), \ - E__NOTE(_AS4), E__NOTE(_AS4), QD_NOTE(_B4), - -#define IMPERIAL_MARCH \ - HD_NOTE(_A4), HD_NOTE(_A4), HD_NOTE(_A4), QD_NOTE(_F4), QD_NOTE(_C5), \ - HD_NOTE(_A4), QD_NOTE(_F4), QD_NOTE(_C5), WD_NOTE(_A4), \ - HD_NOTE(_E5), HD_NOTE(_E5), HD_NOTE(_E5), QD_NOTE(_F5), QD_NOTE(_C5), \ - HD_NOTE(_A4), QD_NOTE(_F4), QD_NOTE(_C5), WD_NOTE(_A4) #define CLUEBOARD_SOUND \ HD_NOTE(_C3), HD_NOTE(_D3), HD_NOTE(_E3), HD_NOTE(_F3), HD_NOTE(_G3), HD_NOTE(_A4), HD_NOTE(_B4), HD_NOTE(_C4) @@ -78,11 +56,6 @@ Q__NOTE(_F3) */ -#define BASKET_CASE \ - QD_NOTE(_G3), E__NOTE(_F3), E__NOTE(_E3), Q__NOTE(_F3), M__NOTE(_G3, 8+32), Q__NOTE(_REST), \ - Q__NOTE(_B4), Q__NOTE(_C4), Q__NOTE(_B4), E__NOTE(_A4), Q__NOTE(_G3), M__NOTE(_G3, 8+32), Q__NOTE(_REST), \ - Q__NOTE(_B4), Q__NOTE(_C4), Q__NOTE(_B4), E__NOTE(_A4), Q__NOTE(_G3), Q__NOTE(_G3), Q__NOTE(_G3), Q__NOTE(_G3), E__NOTE(_A4), E__NOTE(_C4), QD_NOTE(_B4), HD_NOTE(_B4) - #define STARTUP_SOUND \ E__NOTE(_E6), \ E__NOTE(_A6), \ @@ -130,6 +103,17 @@ S__NOTE(_REST), \ E__NOTE(_E7 ), +#define WORKMAN_SOUND \ + E__NOTE(_GS6 ), \ + E__NOTE(_A6 ), \ + S__NOTE(_REST), \ + E__NOTE(_GS6 ), \ + E__NOTE(_A6 ), \ + S__NOTE(_REST), \ + ED_NOTE(_FS7 ), \ + S__NOTE(_REST), \ + ED_NOTE(_A7 ), + #define PLOVER_SOUND \ E__NOTE(_GS6 ), \ E__NOTE(_A6 ), \ @@ -257,299 +241,15 @@ E__NOTE(_E6), \ S__NOTE(_B5), -#define COIN_SOUND \ - E__NOTE(_A5 ), \ - HD_NOTE(_E6 ), - -#define ONE_UP_SOUND \ - Q__NOTE(_E6 ), \ - Q__NOTE(_G6 ), \ - Q__NOTE(_E7 ), \ - Q__NOTE(_C7 ), \ - Q__NOTE(_D7 ), \ - Q__NOTE(_G7 ), - -#define SONIC_RING \ - E__NOTE(_E6), \ - E__NOTE(_G6), \ - HD_NOTE(_C7), - -#define ZELDA_PUZZLE \ - Q__NOTE(_G5), \ - Q__NOTE(_FS5), \ - Q__NOTE(_DS5), \ - Q__NOTE(_A4), \ - Q__NOTE(_GS4), \ - Q__NOTE(_E5), \ - Q__NOTE(_GS5), \ - HD_NOTE(_C6), - -#define ZELDA_TREASURE \ - Q__NOTE(_A4 ), \ - Q__NOTE(_AS4), \ - Q__NOTE(_B4 ), \ - HD_NOTE(_C5 ), \ #define TERMINAL_SOUND \ E__NOTE(_C5 ) -#define OVERWATCH_THEME \ - HD_NOTE(_A4 ), \ - Q__NOTE(_E4 ), \ - Q__NOTE(_A4 ), \ - HD_NOTE(_B4 ), \ - Q__NOTE(_E4 ), \ - Q__NOTE(_B4 ), \ - W__NOTE(_CS5), - -#define MARIO_THEME \ - Q__NOTE(_E5), \ - H__NOTE(_E5), \ - H__NOTE(_E5), \ - Q__NOTE(_C5), \ - H__NOTE(_E5), \ - W__NOTE(_G5), \ - Q__NOTE(_G4), - -#define MARIO_GAMEOVER \ - HD_NOTE(_C5 ), \ - HD_NOTE(_G4 ), \ - H__NOTE(_E4 ), \ - H__NOTE(_A4 ), \ - H__NOTE(_B4 ), \ - H__NOTE(_A4 ), \ - H__NOTE(_AF4), \ - H__NOTE(_BF4), \ - H__NOTE(_AF4), \ - WD_NOTE(_G4 ), - -#define MARIO_MUSHROOM \ - S__NOTE(_C5 ), \ - S__NOTE(_G4 ), \ - S__NOTE(_C5 ), \ - S__NOTE(_E5 ), \ - S__NOTE(_G5 ), \ - S__NOTE(_C6 ), \ - S__NOTE(_G5 ), \ - S__NOTE(_GS4), \ - S__NOTE(_C5 ), \ - S__NOTE(_DS5), \ - S__NOTE(_GS5), \ - S__NOTE(_DS5), \ - S__NOTE(_GS5), \ - S__NOTE(_C6 ), \ - S__NOTE(_DS6), \ - S__NOTE(_GS6), \ - S__NOTE(_DS6), \ - S__NOTE(_AS4), \ - S__NOTE(_D5 ), \ - S__NOTE(_F5 ), \ - S__NOTE(_AS5), \ - S__NOTE(_D6 ), \ - S__NOTE(_F6 ), \ - S__NOTE(_AS6), \ - S__NOTE(_F6 ) - -#define E1M1_DOOM \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_D4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_C4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_BF3), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_B3 ), \ - Q__NOTE(_C4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_D4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_C4 ), \ - Q__NOTE(_E3 ), \ - Q__NOTE(_E3 ), \ - H__NOTE(_BF3), - -#define DISNEY_SONG \ - H__NOTE(_G3 ), \ - H__NOTE(_G4 ), \ - H__NOTE(_F4 ), \ - H__NOTE(_E4 ), \ - H__NOTE(_CS4), \ - H__NOTE(_D4 ), \ - W__NOTE(_A4 ), \ - H__NOTE(_B3 ), \ - H__NOTE(_B4 ), \ - H__NOTE(_A4 ), \ - H__NOTE(_G4 ), \ - H__NOTE(_FS4), \ - H__NOTE(_G4 ), \ - W__NOTE(_C5 ), \ - H__NOTE(_D5 ), \ - H__NOTE(_C5 ), \ - H__NOTE(_B4 ), \ - H__NOTE(_A4 ), \ - H__NOTE(_G4 ), \ - H__NOTE(_F4 ), \ - H__NOTE(_E4 ), \ - H__NOTE(_D4 ), \ - W__NOTE(_A4 ), \ - W__NOTE(_B3 ), \ - W__NOTE(_C4 ), - -#define NUMBER_ONE \ - HD_NOTE(_F4 ), \ - Q__NOTE(_C5 ), \ - E__NOTE(_B4 ), \ - E__NOTE(_C5 ), \ - E__NOTE(_B4 ), \ - E__NOTE(_C5 ), \ - Q__NOTE(_B4 ), \ - Q__NOTE(_C5 ), \ - H__NOTE(_AF4), \ - HD_NOTE(_F4 ), \ - Q__NOTE(_F4 ), \ - Q__NOTE(_AF4), \ - Q__NOTE(_C5 ), \ - H__NOTE(_DF5), \ - H__NOTE(_AF4), \ - H__NOTE(_DF5), \ - H__NOTE(_EF5), \ - Q__NOTE(_C5 ), \ - Q__NOTE(_DF5), \ - Q__NOTE(_C5 ), \ - Q__NOTE(_DF5), \ - H__NOTE(_C5 ), - -#define CABBAGE_SONG \ - H__NOTE(_C4), \ - H__NOTE(_A4), \ - H__NOTE(_B4), \ - H__NOTE(_B4), \ - H__NOTE(_A4), \ - H__NOTE(_G4), \ - H__NOTE(_E4), - -#define OLD_SPICE \ - Q__NOTE(_A4 ), \ - Q__NOTE(_A4 ), \ - H__NOTE(_B4 ), \ - H__NOTE(_D5 ), \ - H__NOTE(_CS5), \ - Q__NOTE(_E5 ), \ - H__NOTE(_FS5), \ - H__NOTE(_D5 ), \ - -#define VICTORY_FANFARE_SHORT \ - ED_NOTE(_C6), \ - ED_NOTE(_C6), \ - ED_NOTE(_C6), \ - ED_NOTE(_C6), \ - W__NOTE(_REST), \ - QD_NOTE(_GS5), \ - QD_NOTE(_AS5), \ - Q__NOTE(_C6), \ - Q__NOTE(_AS5), \ - Q__NOTE(_C6), \ - -#define ALL_STAR \ - H__NOTE(_AS4), W__NOTE(_FS4), Q__NOTE(_FS4), Q__NOTE(_DS4), H__NOTE(_FS4), W__NOTE(_FS4), Q__NOTE(_FS4), Q__NOTE(_DS4), \ - H__NOTE(_FS4), W__NOTE(_FS4), W__NOTE(_FS4), QD_NOTE(_AS4), \ - H__NOTE(_AS4), W__NOTE(_FS4), Q__NOTE(_FS4), Q__NOTE(_DS4), H__NOTE(_FS4), W__NOTE(_FS4), Q__NOTE(_FS4), Q__NOTE(_DS4), \ - H__NOTE(_FS4), W__NOTE(_FS4), W__NOTE(_FS4), W__NOTE(_AS4), H__NOTE(_REST),\ - W__NOTE(_AS4), W__NOTE(_CS5), H__NOTE(_B4), H__NOTE(_CS5), H__NOTE(_DS5), W__NOTE(_FS5), \ - H__NOTE(_GS5), W__NOTE(_GS5), H__NOTE(_FS4), H__NOTE(_FS4), H__NOTE(_GS4), H__NOTE(_FS4), \ - H__NOTE(_AS4), W__NOTE(_GS4), W__NOTE(_GS4), W__NOTE(_FS4), W__NOTE(_GS4), \ - H__NOTE(_AS4), WD_NOTE(_DS4) - -#define RICK_ROLL \ - Q__NOTE(_F4), \ - Q__NOTE(_G4), \ - Q__NOTE(_BF4), \ - Q__NOTE(_G4), \ - HD_NOTE(_D5), \ - HD_NOTE(_D5), \ - W__NOTE(_C5), \ - S__NOTE(_REST), \ - Q__NOTE(_F4), \ - Q__NOTE(_G4), \ - Q__NOTE(_BF4), \ - Q__NOTE(_G4), \ - HD_NOTE(_C5), \ - HD_NOTE(_C5), \ - W__NOTE(_BF4), \ - S__NOTE(_REST), \ - Q__NOTE(_F4), \ - Q__NOTE(_G4), \ - Q__NOTE(_BF4), \ - Q__NOTE(_G4), \ - W__NOTE(_BF4), \ - H__NOTE(_C5), \ - H__NOTE(_A4), \ - H__NOTE(_A4), \ - H__NOTE(_G4), \ - H__NOTE(_F4), \ - H__NOTE(_F4), \ - W__NOTE(_C5), \ - W__NOTE(_BF4), - -/* Prelude music from Final Fantasy */ -#define FF_PRELUDE \ - M__NOTE(_C3, 20), M__NOTE(_D3, 20), M__NOTE(_E3, 20), M__NOTE(_G3, 20), \ - M__NOTE(_C4, 20), M__NOTE(_D4, 20), M__NOTE(_E4, 20), M__NOTE(_G4, 20), \ - M__NOTE(_C5, 20), M__NOTE(_D5, 20), M__NOTE(_E5, 20), M__NOTE(_G5, 20), \ - M__NOTE(_C6, 20), M__NOTE(_D6, 20), M__NOTE(_E6, 20), M__NOTE(_G6, 20), \ - M__NOTE(_C7, 20), M__NOTE(_G6, 20), M__NOTE(_E6, 20), M__NOTE(_D6, 20), \ - M__NOTE(_C6, 20), M__NOTE(_G5, 20), M__NOTE(_E5, 20), M__NOTE(_D5, 20), \ - M__NOTE(_C5, 20), M__NOTE(_G4, 20), M__NOTE(_E4, 20), M__NOTE(_D4, 20), \ - M__NOTE(_C4, 20), M__NOTE(_G3, 20), M__NOTE(_E3, 20), M__NOTE(_D3, 20), \ - M__NOTE(_A2, 20), M__NOTE(_B2, 20), M__NOTE(_C3, 20), M__NOTE(_E3, 20), \ - M__NOTE(_A3, 20), M__NOTE(_B3, 20), M__NOTE(_C4, 20), M__NOTE(_E4, 20), \ - M__NOTE(_A4, 20), M__NOTE(_B4, 20), M__NOTE(_C5, 20), M__NOTE(_E5, 20), \ - M__NOTE(_A5, 20), M__NOTE(_B5, 20), M__NOTE(_C6, 20), M__NOTE(_E6, 20), \ - M__NOTE(_A6, 20), M__NOTE(_E6, 20), M__NOTE(_C6, 20), M__NOTE(_B5, 20), \ - M__NOTE(_A5, 20), M__NOTE(_E5, 20), M__NOTE(_C5, 20), M__NOTE(_B4, 20), \ - M__NOTE(_A4, 20), M__NOTE(_E4, 20), M__NOTE(_C4, 20), M__NOTE(_B3, 20), \ - M__NOTE(_A3, 20), M__NOTE(_E3, 20), M__NOTE(_C3, 20), M__NOTE(_B2, 20), - -/* Melody from the main themes of Star Trek TNG and the original series */ -#define TO_BOLDLY_GO \ - W__NOTE(_BF3 ), \ - Q__NOTE(_EF4 ), \ - WD_NOTE(_AF4 ), \ - W__NOTE(_REST), \ - H__NOTE(_G4 ), \ - Q__NOTE(_EF4 ), \ - H__NOTE(_C4 ), \ - W__NOTE(_REST), \ - QD_NOTE(_F4 ), \ - M__NOTE(_BF4, 128), - -#define KATAWARE_DOKI \ - W__NOTE(_G5), HD_NOTE(_G5), Q__NOTE(_G5), H__NOTE(_G5), H__NOTE(_E5), H__NOTE(_D5), Q__NOTE(_D5), Q__NOTE(_C5), \ - B__NOTE(_E5), H__NOTE(_C5), W__NOTE(_G5), HD_NOTE(_G5), Q__NOTE(_C5), H__NOTE(_C6), Q__NOTE(_B5), \ - Q__NOTE(_A5), H__NOTE(_G5), Q__NOTE(_G5), Q__NOTE(_A5), W__NOTE(_G5), QD_NOTE(_E5), \ - QD_NOTE(_F5), Q__NOTE(_E5), WD_NOTE(_D5), H__NOTE(_C5), W__NOTE(_G5), HD_NOTE(_G5), Q__NOTE(_G5), \ - H__NOTE(_G5), H__NOTE(_E5), H__NOTE(_D5), Q__NOTE(_D5), Q__NOTE(_C5), B__NOTE(_E5), H__NOTE(_G4), \ - Q__NOTE(_C5), Q__NOTE(_D5), Q__NOTE(_E5), H__NOTE(_D5), Q__NOTE(_C5), Q__NOTE(_C5), \ - Q__NOTE(_A4), H__NOTE(_C5), Q__NOTE(_C5), W__NOTE(_C5), Q__NOTE(_F4), Q__NOTE(_C5), \ - Q__NOTE(_D5), Q__NOTE(_E5), H__NOTE(_D5), H__NOTE(_C5), Q__NOTE(_C5), H__NOTE(_G5), \ - Q__NOTE(_C5), HD_NOTE(_D5), H__NOTE(_G4), Q__NOTE(_C5), Q__NOTE(_D5), Q__NOTE(_E5), \ - H__NOTE(_D5), Q__NOTE(_C5), Q__NOTE(_C5), Q__NOTE(_A4), H__NOTE(_C5), Q__NOTE(_C5), \ - W__NOTE(_C5), Q__NOTE(_F4), Q__NOTE(_C5), Q__NOTE(_D5), Q__NOTE(_E5), H__NOTE(_D5), \ - H__NOTE(_C5), Q__NOTE(_C5), H__NOTE(_G5), Q__NOTE(_C5), HD_NOTE(_D5), \ - HD_NOTE(_G4), Q__NOTE(_C5), Q__NOTE(_D5), BD_NOTE(_C5), - + +/* Title: La Campanella + * Author/Composer: Frank Lizst + + License: Public Domain + */ #define CAMPANELLA \ Q__NOTE(_DS4), E__NOTE(_DS4), E__NOTE(_DS5), Q__NOTE(_DS5), E__NOTE(_DS5), E__NOTE(_DS6), Q__NOTE(_DS5), E__NOTE(_DS5), \ E__NOTE(_DS6), Q__NOTE(_CS5), E__NOTE(_CS5), E__NOTE(_DS6), Q__NOTE(_B4), E__NOTE(_B4), E__NOTE(_DS6), \ @@ -566,165 +266,15 @@ E__NOTE(_B5), E__NOTE(_DS7), Q__NOTE(_B5), E__NOTE(_B5), E__NOTE(_DS7), Q__NOTE(_AS5), E__NOTE(_AS5), \ E__NOTE(_DS7), Q__NOTE(_GS5), E__NOTE(_GS5), E__NOTE(_DS7), Q__NOTE(_G5), E__NOTE(_G5), E__NOTE(_DS7), \ Q__NOTE(_GS5), E__NOTE(_GS5), E__NOTE(_DS7), Q__NOTE(_AS5), E__NOTE(_AS5), E__NOTE(_DS7), Q__NOTE(_DS5), \ - E__NOTE(_DS5), E__NOTE(_DS7), W__NOTE(_DS6), W__NOTE(_GS5), - -#define MEGALOVANIA \ - Q__NOTE(_D4), Q__NOTE(_D4), H__NOTE(_D5), HD_NOTE(_A4), H__NOTE(_AF4), H__NOTE(_G4), H__NOTE(_F4), \ - Q__NOTE(_D4), Q__NOTE(_F4), Q__NOTE(_G4), Q__NOTE(_C4), Q__NOTE(_C4), H__NOTE(_D5), HD_NOTE(_A4), \ - H__NOTE(_AF4), H__NOTE(_G4), H__NOTE(_F4), Q__NOTE(_D4), Q__NOTE(_F4), Q__NOTE(_G4), \ - Q__NOTE(_B3), Q__NOTE(_B3), H__NOTE(_D5), HD_NOTE(_A4), H__NOTE(_AF4), H__NOTE(_G4), H__NOTE(_F4), \ - Q__NOTE(_D4), Q__NOTE(_F4), Q__NOTE(_G4), Q__NOTE(_BF3), Q__NOTE(_BF3), H__NOTE(_D5), \ - HD_NOTE(_A4), H__NOTE(_AF4), H__NOTE(_G4), H__NOTE(_F4), Q__NOTE(_D4), Q__NOTE(_F4), \ - Q__NOTE(_G4), - -#define MICHISHIRUBE \ - W__NOTE(_A5), H__NOTE(_A5), H__NOTE(_A5), W__NOTE(_B5), H__NOTE(_A5), H__NOTE(_B5), BD_NOTE(_CS6), W__NOTE(_E6), \ - W__NOTE(_CS6), WD_NOTE(_B5), H__NOTE(_A5), BD_NOTE(_A5), W__NOTE(_A5), H__NOTE(_A5), H__NOTE(_A5), \ - W__NOTE(_B5), H__NOTE(_A5), H__NOTE(_B5), W__NOTE(_A5), W__NOTE(_A6), W__NOTE(_GS6), H__NOTE(_CS6), \ - Q__NOTE(_E6), Q__NOTE(_CS6), W__NOTE(_B5), H__NOTE(_B5), H__NOTE(_CS6), W__NOTE(_B5), H__NOTE(_A5), \ - Q__NOTE(_B5), BD_NOTE(_A5), \ - H__NOTE(_E6), H__NOTE(_FS6), H__NOTE(_E6), H__NOTE(_B6), \ - W__NOTE(_A6), H__NOTE(_E6), H__NOTE(_B6), W__NOTE(_A6), H__NOTE(_A6), H__NOTE(_B6), \ - B__NOTE(_CS7), H__NOTE(_E6), H__NOTE(_FS6), H__NOTE(_E6), H__NOTE(_B6), W__NOTE(_A6), H__NOTE(_E6), \ - H__NOTE(_B6), W__NOTE(_A6), H__NOTE(_A6), H__NOTE(_GS6), B__NOTE(_E6), H__NOTE(_E6), \ - H__NOTE(_FS6), H__NOTE(_E6), H__NOTE(_B6), W__NOTE(_A6), H__NOTE(_E6), H__NOTE(_B6), \ - W__NOTE(_A6), H__NOTE(_A6), H__NOTE(_B6), H__NOTE(_CS7), B__NOTE(_CS7), H__NOTE(_E6), H__NOTE(_E6), \ - H__NOTE(_E6), H__NOTE(_E6), H__NOTE(_D6), H__NOTE(_D6), H__NOTE(_CS6), H__NOTE(_CS6), Q__NOTE(_B5), \ - BD_NOTE(_B5), W__NOTE(_A5), H__NOTE(_A5), H__NOTE(_A5), W__NOTE(_B5), H__NOTE(_A5), H__NOTE(_B5), \ - BD_NOTE(_CS6), W__NOTE(_E6), W__NOTE(_CS6), WD_NOTE(_B5), H__NOTE(_A5), BD_NOTE(_A5), W__NOTE(_A5), \ - H__NOTE(_A5), H__NOTE(_A5), W__NOTE(_B5), H__NOTE(_A5), H__NOTE(_B5), W__NOTE(_A5), W__NOTE(_A6), \ - W__NOTE(_GS6), H__NOTE(_CS6), Q__NOTE(_E6), Q__NOTE(_CS6), W__NOTE(_B5), H__NOTE(_B5), H__NOTE(_CS6), \ - W__NOTE(_B5), H__NOTE(_A5), Q__NOTE(_B5), BD_NOTE(_A5), - -#define LIEBESLEID \ - Q__NOTE(_E4), Q__NOTE(_DS4), Q__NOTE(_E4), Q__NOTE(_F4), Q__NOTE(_E4), Q__NOTE(_FS4), Q__NOTE(_EF4), Q__NOTE(_G4), Q__NOTE(_D4), \ - Q__NOTE(_GS4), Q__NOTE(_CS4), W__NOTE(_A4), H__NOTE(_E5), H__NOTE(_E5), HD_NOTE(_G4), Q__NOTE(_E5), E__NOTE(_E5), \ - E__NOTE(_F5), ED_NOTE(_E5), HD_NOTE(_D5), Q__NOTE(_E5), H__NOTE(_F5), H__NOTE(_CS5), H__NOTE(_C5), W__NOTE(_G4), \ - H__NOTE(_D5), H__NOTE(_D5), HD_NOTE(_D5), Q__NOTE(_D5), E__NOTE(_D5), E__NOTE(_E5), E__NOTE(_D5), HD_NOTE(_C5), \ - Q__NOTE(_D5), H__NOTE(_E5), H__NOTE(_B4), H__NOTE(_BF4), W__NOTE(_F4), H__NOTE(_C5), H__NOTE(_C5), HD_NOTE(_EF4), \ - Q__NOTE(_C5), E__NOTE(_C5), E__NOTE(_D5), E__NOTE(_C5), HD_NOTE(_BF4), Q__NOTE(_C5), H__NOTE(_D5), H__NOTE(_FS4), \ - H__NOTE(_F4), HD_NOTE(_E4), Q__NOTE(_A4), HD_NOTE(_FS4), Q__NOTE(_A4), HD_NOTE(_GS4), Q__NOTE(_B4), Q__NOTE(_A4), \ - Q__NOTE(_E4), Q__NOTE(_DS4), Q__NOTE(_E4), Q__NOTE(_F4), Q__NOTE(_D4), Q__NOTE(_FS4), Q__NOTE(_CS4), Q__NOTE(_G4), \ - Q__NOTE(_C4), Q__NOTE(_GS4), Q__NOTE(_D4), WD_NOTE(_A4), - -#define MELODIES_OF_LIFE \ - H__NOTE(_B5), W__NOTE(_GS6), H__NOTE(_GS6), H__NOTE(_FS6), W__NOTE(_E6), H__NOTE(_E6), H__NOTE(_DS6), H__NOTE(_CS6), H__NOTE(_DS6), \ - H__NOTE(_E6), H__NOTE(_FS6), WD_NOTE(_B5), H__NOTE(_B5), H__NOTE(_CS6), H__NOTE(_DS6), H__NOTE(_E6), H__NOTE(_CS6), \ - H__NOTE(_CS6), H__NOTE(_B5), H__NOTE(_E6), H__NOTE(_GS6), H__NOTE(_A6), H__NOTE(_GS6), H__NOTE(_E6), H__NOTE(_GS6), \ - WD_NOTE(_FS6), H__NOTE(_GS6), WD_NOTE(_B6), H__NOTE(_CS7), H__NOTE(_B6), H__NOTE(_A6), H__NOTE(_A6), H__NOTE(_GS6), \ - H__NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_FS6), H__NOTE(_GS6), WD_NOTE(_A6), Q__NOTE(_GS6), Q__NOTE(_FS6), Q__NOTE(_FS6), \ - Q__NOTE(_E6), W__NOTE(_E6), Q__NOTE(_B5), Q__NOTE(_CS6), WD_NOTE(_E6), Q__NOTE(_E6), Q__NOTE(_FS6), W__NOTE(_GS6), \ - H__NOTE(_A6), B__NOTE(_FS6), - -#define EYES_ON_ME \ - Q__NOTE(_A6), Q__NOTE(_G6), Q__NOTE(_FS6), Q__NOTE(_D6), Q__NOTE(_A5), Q__NOTE(_G5), Q__NOTE(_FS5), Q__NOTE(_D5), \ - W__NOTE(_A4), W__NOTE(_D5), W__NOTE(_E5), W__NOTE(_FS5), H__NOTE(_A5), M__NOTE(_FS5, 256), H__NOTE(_E5), \ - H__NOTE(_FS5), B__NOTE(_D5), H__NOTE(_B4), H__NOTE(_D5), BD_NOTE(_E5), H__NOTE(_A4), W__NOTE(_D5), W__NOTE(_E5), \ - W__NOTE(_FS5), H__NOTE(_A5), BD_NOTE(_CS6), W__NOTE(_A5), H__NOTE(_CS6), H__NOTE(_D6), WD_NOTE(_B5), \ - H__NOTE(_A5), H__NOTE(_B5), B__NOTE(_A5), WD_NOTE(_B4), W__NOTE(_CS5), WD_NOTE(_D6), H__NOTE(_D6), \ - W__NOTE(_CS6), H__NOTE(_B5), H__NOTE(_B5), H__NOTE(_B5), B__NOTE(_A5), H__NOTE(_A5), H__NOTE(_FS5), H__NOTE(_A5), \ - WD_NOTE(_B5), H__NOTE(_B5), H__NOTE(_A5), H__NOTE(_G5), H__NOTE(_D5), W__NOTE(_FS5), WD_NOTE(_E5), \ - H__NOTE(_CS4), H__NOTE(_E4), H__NOTE(_A4), H__NOTE(_CS5), W__NOTE(_D5), W__NOTE(_E5), W__NOTE(_FS5), H__NOTE(_G5), \ - H__NOTE(_A5), B__NOTE(_A5), H__NOTE(_A5), H__NOTE(_G5), H__NOTE(_D5), BD_NOTE(_FS5), W__NOTE(_E5), B__NOTE(_D5), \ - H__NOTE(_G4), H__NOTE(_FS4), W__NOTE(_E4), BD_NOTE(_D4), - -#define SONG_OF_THE_ANCIENTS \ - H__NOTE(_D6), H__NOTE(_EF6), B__NOTE(_EF6), H__NOTE(_EF6), H__NOTE(_D6), H__NOTE(_BF5), H__NOTE(_G5), BD_NOTE(_C6), H__NOTE(_D6), \ - H__NOTE(_EF6), B__NOTE(_EF6), H__NOTE(_EF6), H__NOTE(_D6), H__NOTE(_BF5), H__NOTE(_G5), BD_NOTE(_G6), H__NOTE(_G5), \ - H__NOTE(_AF5), B__NOTE(_G6), H__NOTE(_AF6), H__NOTE(_G6), H__NOTE(_F6), H__NOTE(_D6), H__NOTE(_D6), H__NOTE(_EF6), \ - B__NOTE(_EF6), WD_NOTE(_G5), WD_NOTE(_BF5), H__NOTE(_D6), H__NOTE(_EF6), B__NOTE(_EF6), H__NOTE(_EF6), H__NOTE(_D6), \ - H__NOTE(_BF5), H__NOTE(_G5), BD_NOTE(_C6), WD_NOTE(_B5), WD_NOTE(_G5), WD_NOTE(_G6), W__NOTE(_G6), H__NOTE(_AF6), \ - W__NOTE(_G6), H__NOTE(_AF6), H__NOTE(_G6), H__NOTE(_F6), H__NOTE(_D6), H__NOTE(_D6), H__NOTE(_EF6), B__NOTE(_EF6), \ - WD_NOTE(_E6), H__NOTE(_E6), H__NOTE(_F6), H__NOTE(_G6), H__NOTE(_BF6), H__NOTE(_AF6), W__NOTE(_AF6), H__NOTE(_C6), \ - H__NOTE(_BF6), H__NOTE(_AF6), W__NOTE(_AF6), H__NOTE(_C6), H__NOTE(_AF6), BD_NOTE(_G6), WD_NOTE(_B5), WD_NOTE(_G6), \ - W__NOTE(_G6), H__NOTE(_AF6), W__NOTE(_G6), H__NOTE(_AF6), H__NOTE(_G6), H__NOTE(_F6), H__NOTE(_D6), H__NOTE(_D6), \ - H__NOTE(_EF6), B__NOTE(_EF6), WD_NOTE(_E6), H__NOTE(_E6), H__NOTE(_F6), H__NOTE(_G6), H__NOTE(_BF6), H__NOTE(_AF6), \ - W__NOTE(_AF6), H__NOTE(_C6), H__NOTE(_AF6), H__NOTE(_G6), W__NOTE(_G6), H__NOTE(_F6), H__NOTE(_D6), BD_NOTE(_EF6), \ - WD_NOTE(_F6), WD_NOTE(_G6), BD_NOTE(_C7), - -#define NIER_AMUSEMENT_PARK \ - H__NOTE(_D5), E__NOTE(_G6), E__NOTE(_GF6), Q__NOTE(_F6), Q__NOTE(_E6), Q__NOTE(_EF6), Q__NOTE(_DF6), Q__NOTE(_EF6), WD_NOTE(_D6), \ - Q__NOTE(_G5), Q__NOTE(_A5), H__NOTE(_BF5), H__NOTE(_D6), H__NOTE(_G6), H__NOTE(_A6), W__NOTE(_BF6), W__NOTE(_EF7), \ - H__NOTE(_D5), E__NOTE(_G6), E__NOTE(_GF6), Q__NOTE(_F6), Q__NOTE(_E6), Q__NOTE(_EF6), Q__NOTE(_DF6), Q__NOTE(_EF6), \ - WD_NOTE(_D6), Q__NOTE(_G5), Q__NOTE(_A5), H__NOTE(_BF5), H__NOTE(_D6), H__NOTE(_G6), H__NOTE(_A6), W__NOTE(_BF6), \ - H__NOTE(_EF7), H__NOTE(_D5), HD_NOTE(_A5), HD_NOTE(_BF5), B__NOTE(_D5), H__NOTE(_D5), HD_NOTE(_G5), HD_NOTE(_F5), \ - H__NOTE(_EF5), WD_NOTE(_D5), H__NOTE(_D5), HD_NOTE(_A5), HD_NOTE(_BF5), WD_NOTE(_D5), W__NOTE(_D5), B__NOTE(_G5), \ - H__NOTE(_D5), HD_NOTE(_A5), HD_NOTE(_BF5), B__NOTE(_D5), H__NOTE(_D5), HD_NOTE(_G5), HD_NOTE(_F5), H__NOTE(_EF5), \ - W__NOTE(_D5), W__NOTE(_C5), W__NOTE(_BF4), W__NOTE(_C5), W__NOTE(_D5), W__NOTE(_G5), B__NOTE(_D5), B__NOTE(_E5), \ - W__NOTE(_EF5), QD_NOTE(_C5), QD_NOTE(_D5), Q__NOTE(_EF5), H__NOTE(_G5), H__NOTE(_F5), H__NOTE(_EF5), H__NOTE(_F5), \ - B__NOTE(_D5), B__NOTE(_BF4), W__NOTE(_EF5), QD_NOTE(_C5), QD_NOTE(_D5), Q__NOTE(_EF5), H__NOTE(_G5), H__NOTE(_F5), \ - H__NOTE(_EF5), H__NOTE(_F5), W__NOTE(_D5), W__NOTE(_BF5), W__NOTE(_G5), W__NOTE(_D5), W__NOTE(_EF5), QD_NOTE(_C5), \ - QD_NOTE(_D5), Q__NOTE(_EF5), H__NOTE(_G5), H__NOTE(_F5), H__NOTE(_EF5), H__NOTE(_F5), B__NOTE(_D5), B__NOTE(_BF4), \ - B__NOTE(_C5), H__NOTE(_C5), H__NOTE(_D5), H__NOTE(_EF5), H__NOTE(_F5), WD_NOTE(_G5), H__NOTE(_C5), W__NOTE(_AF5), \ - WD_NOTE(_G5), - -#define COPIED_CITY \ - Q__NOTE(_F6), Q__NOTE(_BF5), Q__NOTE(_EF6), Q__NOTE(_G5), Q__NOTE(_AF5), Q__NOTE(_G6), Q__NOTE(_AF6), Q__NOTE(_EF6), Q__NOTE(_BF5), \ - Q__NOTE(_F6), Q__NOTE(_G5), Q__NOTE(_AF5), Q__NOTE(_EF6), Q__NOTE(_G5), Q__NOTE(_F5), Q__NOTE(_D6), Q__NOTE(_C6), \ - Q__NOTE(_G5), Q__NOTE(_BF5), Q__NOTE(_EF5), Q__NOTE(_AF5), Q__NOTE(_G5), Q__NOTE(_EF5), Q__NOTE(_BF4), H__NOTE(_C5), \ - Q__NOTE(_F5), Q__NOTE(_G5), Q__NOTE(_AF5), Q__NOTE(_EF6), Q__NOTE(_BF5), Q__NOTE(_G6), Q__NOTE(_EF6), Q__NOTE(_BF6), \ - Q__NOTE(_AF6), Q__NOTE(_EF6), Q__NOTE(_BF5), Q__NOTE(_F6), Q__NOTE(_G5), Q__NOTE(_F5), Q__NOTE(_EF6), Q__NOTE(_BF5), \ - Q__NOTE(_B6), Q__NOTE(_DF6), Q__NOTE(_EF6), Q__NOTE(_F6), Q__NOTE(_AF6), Q__NOTE(_EF7), Q__NOTE(_F6), Q__NOTE(_C6), \ - Q__NOTE(_G5), Q__NOTE(_AF5), Q__NOTE(_BF5), Q__NOTE(_C6), Q__NOTE(_EF6), Q__NOTE(_G5), Q__NOTE(_EF5), Q__NOTE(_F5), \ - Q__NOTE(_G5), Q__NOTE(_EF5), Q__NOTE(_F5), Q__NOTE(_C5), Q__NOTE(_EF5), Q__NOTE(_C5), Q__NOTE(_BF4), Q__NOTE(_G4), \ - Q__NOTE(_F4), Q__NOTE(_G4), H__NOTE(_AF4), Q__NOTE(_C5), Q__NOTE(_EF5), Q__NOTE(_F5), Q__NOTE(_C5), Q__NOTE(_EF5), \ - Q__NOTE(_F5), Q__NOTE(_G5), Q__NOTE(_BF5), Q__NOTE(_AF5), Q__NOTE(_G5), Q__NOTE(_EF5), Q__NOTE(_F5), Q__NOTE(_C5), \ - Q__NOTE(_AF4), Q__NOTE(_F5), Q__NOTE(_G5), Q__NOTE(_AF5), Q__NOTE(_G5), Q__NOTE(_F5), Q__NOTE(_EF5), Q__NOTE(_F5), \ - Q__NOTE(_G5), Q__NOTE(_BF5), Q__NOTE(_C6), Q__NOTE(_G6), Q__NOTE(_EF6), WD_NOTE(_F7), - -#define VAGUE_HOPE_COLD_RAIN \ - HD_NOTE(_D6), HD_NOTE(_E6), HD_NOTE(_CS6), HD_NOTE(_D6), HD_NOTE(_B5), Q__NOTE(_B5), Q__NOTE(_CS6), Q__NOTE(_D6), WD_NOTE(_A6), \ - HD_NOTE(_FS6), HD_NOTE(_G6), HD_NOTE(_D6), HD_NOTE(_E6), HD_NOTE(_FS6), Q__NOTE(_D5), Q__NOTE(_CS5), Q__NOTE(_A4), \ - W__NOTE(_FS4), H__NOTE(_D6), HD_NOTE(_E6), HD_NOTE(_FS6), HD_NOTE(_CS6), HD_NOTE(_E6), HD_NOTE(_D6), Q__NOTE(_CS6), \ - Q__NOTE(_D6), Q__NOTE(_E6), W__NOTE(_FS6), H__NOTE(_CS6), WD_NOTE(_D6), HD_NOTE(_D6), Q__NOTE(_D6), H__NOTE(_E6), \ - WD_NOTE(_CS6), HD_NOTE(_AS5), HD_NOTE(_B5), HD_NOTE(_B5), Q__NOTE(_B4), Q__NOTE(_CS5), Q__NOTE(_D5), HD_NOTE(_A5), \ - Q__NOTE(_B5), Q__NOTE(_CS6), Q__NOTE(_A6), HD_NOTE(_FS6), Q__NOTE(_D5), Q__NOTE(_CS5), Q__NOTE(_A4), H__NOTE(_FS4), \ - HD_NOTE(_FS6), HD_NOTE(_D6), HD_NOTE(_E6), HD_NOTE(_A6), HD_NOTE(_FS6), Q__NOTE(_CS5), Q__NOTE(_D5), Q__NOTE(_A5), \ - HD_NOTE(_FS5), Q__NOTE(_FS6), Q__NOTE(_FS6), Q__NOTE(_GS6), HD_NOTE(_A6), Q__NOTE(_B6), H__NOTE(_A6), H__NOTE(_GS6), \ - H__NOTE(_FS6), H__NOTE(_E6), H__NOTE(_CS6), H__NOTE(_FS6), E__NOTE(_FS5), E__NOTE(_CS5), Q__NOTE(_B4), H__NOTE(_AS4), \ - W__NOTE(_FS5), HD_NOTE(_FS6), HD_NOTE(_B5), H__NOTE(_D6), H__NOTE(_CS6), H__NOTE(_E6), HD_NOTE(_A6), HD_NOTE(_E6), \ - W__NOTE(_D6), Q__NOTE(_CS6), Q__NOTE(_D6), HD_NOTE(_E6), HD_NOTE(_FS6), WD_NOTE(_B6), HD_NOTE(_E6), HD_NOTE(_FS6), \ - HD_NOTE(_B5), Q__NOTE(_B5), Q__NOTE(_B5), Q__NOTE(_CS6), H__NOTE(_D6), H__NOTE(_E6), H__NOTE(_FS6), HD_NOTE(_E6), \ - HD_NOTE(_CS6), H__NOTE(_FS6), H__NOTE(_A6), H__NOTE(_B6), W__NOTE(_A6), H__NOTE(_FS6), BD_NOTE(_B6), - -#define KAINE_SALVATION \ - BD_NOTE(_D5), W__NOTE(_BF4), W__NOTE(_C5), W__NOTE(_F5), BD_NOTE(_D5), BD_NOTE(_BF4), BD_NOTE(_C5), W__NOTE(_BF4), W__NOTE(_C5), \ - W__NOTE(_D5), BD_NOTE(_C5), BD_NOTE(_F4), BD_NOTE(_D5), W__NOTE(_BF4), W__NOTE(_C5), W__NOTE(_F5), BD_NOTE(_D5), \ - BD_NOTE(_BF4), WD_NOTE(_EF5), WD_NOTE(_BF4), W__NOTE(_A4), W__NOTE(_BF4), W__NOTE(_C5), B__NOTE(_C5), H__NOTE(_B4), \ - H__NOTE(_C5), BD_NOTE(_D5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_FS5), H__NOTE(_G5), H__NOTE(_A5), H__NOTE(_B5), \ - H__NOTE(_A5), H__NOTE(_G5), H__NOTE(_FS5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_D6), H__NOTE(_C6), H__NOTE(_B5), \ - H__NOTE(_A5), WD_NOTE(_G5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_FS5), H__NOTE(_G5), H__NOTE(_A5), H__NOTE(_B5), \ - H__NOTE(_A5), H__NOTE(_G5), H__NOTE(_FS5), W__NOTE(_G5), H__NOTE(_B5), H__NOTE(_A5), H__NOTE(_G5), H__NOTE(_FS5), \ - BD_NOTE(_E5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_FS5), H__NOTE(_G5), H__NOTE(_A5), H__NOTE(_B5), H__NOTE(_A5), \ - H__NOTE(_G5), H__NOTE(_FS5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_D6), H__NOTE(_C6), H__NOTE(_B5), H__NOTE(_A5), \ - WD_NOTE(_G5), WD_NOTE(_G5), W__NOTE(_G5), H__NOTE(_FS5), H__NOTE(_G5), H__NOTE(_A5), H__NOTE(_B5), H__NOTE(_A5), \ - H__NOTE(_G5), H__NOTE(_FS5), W__NOTE(_G5), H__NOTE(_D6), WD_NOTE(_D6), W__NOTE(_F5), H__NOTE(_C6), H__NOTE(_C6), \ - H__NOTE(_BF5), H__NOTE(_A5), WD_NOTE(_G5), WD_NOTE(_F5), WD_NOTE(_G5), WD_NOTE(_A5), BD_NOTE(_G5), - -#define WEIGHT_OF_THE_WORLD \ - H__NOTE(_B5), Q__NOTE(_C6), Q__NOTE(_C6), Q__NOTE(_B5), H__NOTE(_C6), H__NOTE(_G6), WD_NOTE(_G6), H__NOTE(_B5), Q__NOTE(_C6), \ - Q__NOTE(_C6), Q__NOTE(_B5), H__NOTE(_C6), H__NOTE(_G6), H__NOTE(_G6), Q__NOTE(_A6), W__NOTE(_G6), Q__NOTE(_C6), \ - Q__NOTE(_D6), H__NOTE(_E6), Q__NOTE(_F6), H__NOTE(_E6), H__NOTE(_F6), HD_NOTE(_E6), H__NOTE(_D6), H__NOTE(_C6), \ - H__NOTE(_D6), WD_NOTE(_D6), Q__NOTE(_C6), Q__NOTE(_B5), WD_NOTE(_B5), H__NOTE(_B5), Q__NOTE(_C6), Q__NOTE(_C6), \ - Q__NOTE(_B5), H__NOTE(_C6), H__NOTE(_G6), WD_NOTE(_G6), H__NOTE(_B5), Q__NOTE(_C6), Q__NOTE(_C6), Q__NOTE(_B5), \ - H__NOTE(_C6), H__NOTE(_G6), H__NOTE(_G6), Q__NOTE(_A6), W__NOTE(_G6), Q__NOTE(_C6), Q__NOTE(_D6), H__NOTE(_E6), \ - Q__NOTE(_F6), H__NOTE(_E6), H__NOTE(_F6), HD_NOTE(_E6), H__NOTE(_D6), H__NOTE(_C6), H__NOTE(_D6), BD_NOTE(_D6), \ - Q__NOTE(_E6), Q__NOTE(_D6), Q__NOTE(_C6), Q__NOTE(_B5), H__NOTE(_C6), Q__NOTE(_C6), H__NOTE(_C6), HD_NOTE(_C6), \ - H__NOTE(_B5), H__NOTE(_C6), H__NOTE(_E6), H__NOTE(_G6), WD_NOTE(_G6), Q__NOTE(_C6), B__NOTE(_C6), H__NOTE(_B6), \ - Q__NOTE(_C7), BD_NOTE(_C7), - -#define ISABELLAS_LULLABY \ - W__NOTE(_BF4), B__NOTE(_D5), W__NOTE(_EF5), B__NOTE(_F5), W__NOTE(_BF5), B__NOTE(_AF5), W__NOTE(_GF5), BD_NOTE(_F5), B__NOTE(_CS5), \ - W__NOTE(_F5), B__NOTE(_C5), W__NOTE(_EF5), BD_NOTE(_BF4), W__NOTE(_AF4), W__NOTE(_BF4), W__NOTE(_F5), W__NOTE(_GF5), \ - WD_NOTE(_AF5), H__NOTE(_FS5), W__NOTE(_F5), B__NOTE(_EF5), W__NOTE(_C6), B__NOTE(_AF5), W__NOTE(_F5), WD_NOTE(_AF5), \ - H__NOTE(_BF5), W__NOTE(_F5), WD_NOTE(_AF5), H__NOTE(_BF5), W__NOTE(_F5), W__NOTE(_EF5), W__NOTE(_BF4), W__NOTE(_AF5), \ - WD_NOTE(_F5), H__NOTE(_F5), H__NOTE(_BF5), H__NOTE(_C6), WD_NOTE(_CS6), H__NOTE(_C6), W__NOTE(_BF5), W__NOTE(_AF5), \ - W__NOTE(_F5), W__NOTE(_EF5), WD_NOTE(_EF5), H__NOTE(_DF5), W__NOTE(_AF5), BD_NOTE(_F5), WD_NOTE(_BF4), H__NOTE(_C5), \ - W__NOTE(_CS5), W__NOTE(_EF5), W__NOTE(_AF4), W__NOTE(_EF5), WD_NOTE(_GF5), H__NOTE(_F5), W__NOTE(_EF5), WD_NOTE(_F5), \ - H__NOTE(_F5), H__NOTE(_BF5), H__NOTE(_C6), WD_NOTE(_CS6), H__NOTE(_C6), W__NOTE(_CS6), W__NOTE(_EF6), W__NOTE(_AF5), \ - W__NOTE(_EF6), WD_NOTE(_GF6), H__NOTE(_F6), W__NOTE(_EF6), B__NOTE(_DF6), H__NOTE(_GF6), H__NOTE(_AF6), BD_NOTE(_DF6), \ - B__NOTE(_BF5), W__NOTE(_F6), BD_NOTE(_C6), W__NOTE(_AF5), WD_NOTE(_EF6), H__NOTE(_DF6), W__NOTE(_C6), B__NOTE(_BF5), + E__NOTE(_DS5), E__NOTE(_DS7), W__NOTE(_DS6), W__NOTE(_GS5), + + + +/* Title: Fantaisie-Impromptu + * Author/Composer: Chopin + * License: Public Domain +*/ #define FANTASIE_IMPROMPTU \ E__NOTE(_GS4), E__NOTE(_A4), E__NOTE(_GS4), E__NOTE(_REST), E__NOTE(_GS4), E__NOTE(_CS5), E__NOTE(_E5), E__NOTE(_DS5), E__NOTE(_CS5), \ E__NOTE(_DS5), E__NOTE(_CS5), E__NOTE(_C5), E__NOTE(_CS5), E__NOTE(_E5), E__NOTE(_GS5), E__NOTE(_GS4), E__NOTE(_A4), \ @@ -739,47 +289,13 @@ E__NOTE(_GS4), E__NOTE(_CS5), E__NOTE(_E5), E__NOTE(_DS5), E__NOTE(_CS5), E__NOTE(_DS5), E__NOTE(_CS5), E__NOTE(_C5), \ E__NOTE(_CS5), E__NOTE(_E5), E__NOTE(_GS5), E__NOTE(_DS5), E__NOTE(_E5), E__NOTE(_DS5), E__NOTE(_REST), E__NOTE(_DS5), \ E__NOTE(_B5), E__NOTE(_AS5), E__NOTE(_GS5), E__NOTE(_REST), E__NOTE(_E6), E__NOTE(_DS6), E__NOTE(_CS6), E__NOTE(_B5), \ - E__NOTE(_AS5), E__NOTE(_GS5), E__NOTE(_REST), E__NOTE(_AS5), WD_NOTE(_GS5), - -#define TERRAS_THEME \ - Q__NOTE(_GS5), Q__NOTE(_AS5), Q__NOTE(_B5), Q__NOTE(_EF6), BD_NOTE(_B5), Q__NOTE(_AS5), Q__NOTE(_GS5), W__NOTE(_AS5), \ - BD_NOTE(_DS5), Q__NOTE(_AF5), Q__NOTE(_BF5), Q__NOTE(_B5), Q__NOTE(_DS6), BD_NOTE(_B5), \ - Q__NOTE(_BF5), Q__NOTE(_AF5), W__NOTE(_AS5), BD_NOTE(_DS6), Q__NOTE(_B5), Q__NOTE(_CS6), Q__NOTE(_DS6), \ - Q__NOTE(_FS6), BD_NOTE(_DS6), Q__NOTE(_CS6), Q__NOTE(_B5), W__NOTE(_CS6), BD_NOTE(_FS5), \ - Q__NOTE(_B5), Q__NOTE(_AS5), BD_NOTE(_GS5), Q__NOTE(_B5), Q__NOTE(_AS5), BD_NOTE(_GS5), - -#define RENAI_CIRCULATION \ - Q__NOTE(_E6), Q__NOTE(_B5), HD_NOTE(_CS6), HD_NOTE(_CS6), H__NOTE(_B5), HD_NOTE(_E6), HD_NOTE(_E6), Q__NOTE(_E6), Q__NOTE(_B5), \ - HD_NOTE(_CS6), HD_NOTE(_CS6), H__NOTE(_B5), HD_NOTE(_E6), HD_NOTE(_GS6), Q__NOTE(_E6), Q__NOTE(_B5), HD_NOTE(_CS6), \ - H__NOTE(_CS6), Q__NOTE(_CS6), H__NOTE(_B5), HD_NOTE(_E6), H__NOTE(_E6), Q__NOTE(_E6), H__NOTE(_FS6), HD_NOTE(_E6), \ - H__NOTE(_E6), Q__NOTE(_E6), H__NOTE(_CS6), WD_NOTE(_GS6), HD_NOTE(_E6), H__NOTE(_E6), Q__NOTE(_FS6), H__NOTE(_G6), \ - HD_NOTE(_GS6), HD_NOTE(_E6), Q__NOTE(_B5), Q__NOTE(_CS6), HD_NOTE(_E6), H__NOTE(_E6), Q__NOTE(_FS6), H__NOTE(_G6), \ - HD_NOTE(_GS6), HD_NOTE(_E6), H__NOTE(_CS6), H__NOTE(_E6), Q__NOTE(_CS6), HD_NOTE(_E6), H__NOTE(_CS6), H__NOTE(_E6), \ - Q__NOTE(_CS6), HD_NOTE(_E6), H__NOTE(_E6), Q__NOTE(_A6), H__NOTE(_GS6), HD_NOTE(_E6), H__NOTE(_FS6), WD_NOTE(_E6), \ - H__NOTE(_GS6), H__NOTE(_A6), H__NOTE(_GS6), H__NOTE(_A6), W__NOTE(_B6), H__NOTE(_GS6), H__NOTE(_A6), H__NOTE(_GS6), \ - H__NOTE(_A6), W__NOTE(_B6), H__NOTE(_B6), H__NOTE(_A6), H__NOTE(_GS6), H__NOTE(_A6), Q__NOTE(_GS6), H__NOTE(_E6), \ - H__NOTE(_E6), Q__NOTE(_E6), H__NOTE(_CS6), Q__NOTE(_GS6), H__NOTE(_E6), H__NOTE(_E6), Q__NOTE(_E6), H__NOTE(_CS6), \ - Q__NOTE(_E6), H__NOTE(_E6), H__NOTE(_E6), Q__NOTE(_E6), H__NOTE(_FS6), WD_NOTE(_E6), W__NOTE(_B6), W__NOTE(_GS6), \ - W__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_E6), H__NOTE(_FS6), B__NOTE(_GS6), H__NOTE(_GS6), \ - W__NOTE(_CS7), W__NOTE(_GS6), W__NOTE(_E6), H__NOTE(_GS6), H__NOTE(_GS6), HD_NOTE(_E6), H__NOTE(_E6), Q__NOTE(_E6), \ - H__NOTE(_FS6), WD_NOTE(_E6), - -#define PLATINUM_DISCO \ - H__NOTE(_DS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_DS6), H__NOTE(_FS6), W__NOTE(_GS6), H__NOTE(_DS6), H__NOTE(_FS6), \ - H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_CS6), H__NOTE(_FS6), WD_NOTE(_FS6), H__NOTE(_CS6), W__NOTE(_DS6), H__NOTE(_FS6), \ - H__NOTE(_AS6), W__NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_GS6), Q__NOTE(_AS6), Q__NOTE(_CS7), Q__NOTE(_GS6), Q__NOTE(_AS6), \ - Q__NOTE(_FS6), Q__NOTE(_GS6), Q__NOTE(_DS6), Q__NOTE(_FS6), Q__NOTE(_CS6), Q__NOTE(_DS6), Q__NOTE(_AS5), Q__NOTE(_CS6), \ - H__NOTE(_DS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_DS6), H__NOTE(_FS6), W__NOTE(_GS6), H__NOTE(_DS6), \ - H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_CS7), H__NOTE(_GS6), WD_NOTE(_FS6), H__NOTE(_CS6), W__NOTE(_DS6), \ - H__NOTE(_FS6), H__NOTE(_AS6), WD_NOTE(_GS6), H__NOTE(_FS6), Q__NOTE(_FS6), Q__NOTE(_GS5), Q__NOTE(_AS5), Q__NOTE(_CS6), \ - Q__NOTE(_FS6), Q__NOTE(_GS6), Q__NOTE(_AS6), Q__NOTE(_CS7), WD_NOTE(_FS7), H__NOTE(_CS6), WD_NOTE(_DS6), H__NOTE(_CS6), \ - WD_NOTE(_DS6), H__NOTE(_CS6), H__NOTE(_DS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_AS6), WD_NOTE(_GS6), H__NOTE(_FS6), \ - WD_NOTE(_GS6), H__NOTE(_FS6), WD_NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_DS6), H__NOTE(_FS6), \ - WD_NOTE(_FS6), H__NOTE(_CS6), WD_NOTE(_DS6), H__NOTE(_CS6), WD_NOTE(_DS6), H__NOTE(_CS6), H__NOTE(_DS6), H__NOTE(_FS6), \ - H__NOTE(_GS6), H__NOTE(_AS6), H__NOTE(_CS7), H__NOTE(_AS6), H__NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_DS6), W__NOTE(_FS6), \ - H__NOTE(_CS6), H__NOTE(_DS6), W__NOTE(_FS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_FS6), H__NOTE(_GS6), H__NOTE(_FS6), \ - B__NOTE(_FS6), + E__NOTE(_AS5), E__NOTE(_GS5), E__NOTE(_REST), E__NOTE(_AS5), WD_NOTE(_GS5), + +/* Title: Nocturne Op. 9 No. 1 in B flat minor + * Author/Composer: Chopin + License: Public Domain +*/ #define NOCTURNE_OP_9_NO_1 \ H__NOTE(_BF5), H__NOTE(_C6), H__NOTE(_DF6), H__NOTE(_A5), H__NOTE(_BF5), H__NOTE(_GF5), W__NOTE(_F5), W__NOTE(_F5), W__NOTE(_F5), \ W__NOTE(_F5), H__NOTE(_GF5), H__NOTE(_F5), H__NOTE(_EF5), H__NOTE(_C5), B__NOTE(_DF5), W__NOTE(_BF4), Q__NOTE(_BF5), \ @@ -790,6 +306,53 @@ B__NOTE(_DF5), W__NOTE(_BF4), W__NOTE(_BF5), W__NOTE(_BF5), W__NOTE(_BF5), BD_NOTE(_AF5), W__NOTE(_DF5), H__NOTE(_BF4), \ H__NOTE(_C5), H__NOTE(_DF5), H__NOTE(_GF5), H__NOTE(_GF5), BD_NOTE(_F5), W__NOTE(_EF5), H__NOTE(_F5), H__NOTE(_EF5), \ H__NOTE(_DF5), H__NOTE(_A4), B__NOTE(_AF4), W__NOTE(_DF5), W__NOTE(_EF5), H__NOTE(_F5), H__NOTE(_EF5), H__NOTE(_DF5), \ - H__NOTE(_EF5), BD_NOTE(_F5), + H__NOTE(_EF5), BD_NOTE(_F5), + + +/* Removed sounds + + This list is here solely for compatibility, so that removed songs don't just break things + * If you think that any of these songs were wrongfully removed, let us know and provide + * proof of permission to use them, or public domain status. + */ -#endif +#define CLOSE_ENCOUNTERS_5_NOTE +#define DOE_A_DEER +#define IN_LIKE_FLINT +#define IMPERIAL_MARCH +#define BASKET_CASE +#define COIN_SOUND +#define ONE_UP_SOUND +#define SONIC_RING +#define ZELDA_PUZZLE +#define ZELDA_TREASURE +#define OVERWATCH_THEME +#define MARIO_THEME +#define MARIO_GAMEOVER +#define MARIO_MUSHROOM +#define E1M1_DOOM +#define DISNEY_SONG +#define NUMBER_ONE +#define CABBAGE_SONG +#define OLD_SPICE +#define VICTORY_FANFARE_SHORT +#define ALL_STAR +#define RICK_ROLL +#define FF_PRELUDE +#define TO_BOLDLY_GO +#define KATAWARE_DOKI +#define MEGALOVANIA +#define MICHISHIRUBE +#define LIEBESLEID +#define MELODIES_OF_LIFE +#define EYES_ON_ME +#define SONG_OF_THE_ANCIENTS +#define NIER_AMUSEMENT_PARK +#define COPIED_CITY +#define VAGUE_HOPE_COLD_RAIN +#define KAINE_SALVATION +#define WEIGHT_OF_THE_WORLD +#define ISABELLAS_LULLABY +#define TERRAS_THEME +#define RENAI_CIRCULATION +#define PLATINUM_DISCO +#define LP_NUMB diff --git a/quantum/color.c b/quantum/color.c index 466e6edacb..a309da379a 100644 --- a/quantum/color.c +++ b/quantum/color.c @@ -27,9 +27,13 @@ RGB hsv_to_rgb( HSV hsv ) if ( hsv.s == 0 ) { +#ifdef USE_CIE1931_CURVE + rgb.r = rgb.g = rgb.b = pgm_read_byte( &CIE1931_CURVE[hsv.v] ); +#else rgb.r = hsv.v; rgb.g = hsv.v; rgb.b = hsv.v; +#endif return rgb; } diff --git a/quantum/color.h b/quantum/color.h index 9d51d45adb..22bb083519 100644 --- a/quantum/color.h +++ b/quantum/color.h @@ -32,12 +32,30 @@ #pragma pack( push, 1 ) #endif +#ifdef RGBW + #define LED_TYPE cRGBW +#else + #define LED_TYPE RGB +#endif + +// WS2812 specific layout typedef struct PACKED { + uint8_t g; uint8_t r; + uint8_t b; +} cRGB; + +typedef cRGB RGB; + +// WS2812 specific layout +typedef struct PACKED +{ uint8_t g; + uint8_t r; uint8_t b; -} RGB; + uint8_t w; +} cRGBW; typedef struct PACKED { @@ -50,6 +68,6 @@ typedef struct PACKED #pragma pack( pop ) #endif -RGB hsv_to_rgb( HSV hsv ); +RGB hsv_to_rgb(HSV hsv); #endif // COLOR_H diff --git a/quantum/config_common.h b/quantum/config_common.h index c489e14073..bc4d9ec1af 100644 --- a/quantum/config_common.h +++ b/quantum/config_common.h @@ -204,6 +204,8 @@ #define B13 PAL_LINE(GPIOB, 13) #define B14 PAL_LINE(GPIOB, 14) #define B15 PAL_LINE(GPIOB, 15) + #define B16 PAL_LINE(GPIOB, 16) + #define B17 PAL_LINE(GPIOB, 17) #define C0 PAL_LINE(GPIOC, 0) #define C1 PAL_LINE(GPIOC, 1) #define C2 PAL_LINE(GPIOC, 2) diff --git a/quantum/debounce/eager_pk.c b/quantum/debounce/eager_pk.c index aa0f63a9d4..c07be18f8d 100644 --- a/quantum/debounce/eager_pk.c +++ b/quantum/debounce/eager_pk.c @@ -39,6 +39,7 @@ No further inputs are accepted until DEBOUNCE milliseconds have occurred. static debounce_counter_t *debounce_counters; static bool counters_need_update; +static bool matrix_need_update; #define DEBOUNCE_ELAPSED 251 #define MAX_DEBOUNCE (DEBOUNCE_ELAPSED - 1) @@ -63,7 +64,7 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool update_debounce_counters(num_rows, current_time); } - if (changed) { + if (changed || matrix_need_update) { transfer_matrix_values(raw, cooked, num_rows, current_time); } } @@ -88,16 +89,21 @@ void update_debounce_counters(uint8_t num_rows, uint8_t current_time) { // upload from raw_matrix to final matrix; void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t current_time) { + matrix_need_update = false; debounce_counter_t *debounce_pointer = debounce_counters; for (uint8_t row = 0; row < num_rows; row++) { matrix_row_t delta = raw[row] ^ cooked[row]; matrix_row_t existing_row = cooked[row]; for (uint8_t col = 0; col < MATRIX_COLS; col++) { matrix_row_t col_mask = (ROW_SHIFTER << col); - if ((delta & col_mask) && *debounce_pointer == DEBOUNCE_ELAPSED) { - *debounce_pointer = current_time; - counters_need_update = true; - existing_row ^= col_mask; // flip the bit. + if (delta & col_mask) { + if (*debounce_pointer == DEBOUNCE_ELAPSED) { + *debounce_pointer = current_time; + counters_need_update = true; + existing_row ^= col_mask; // flip the bit. + } else { + matrix_need_update = true; + } } debounce_pointer++; } diff --git a/quantum/debounce/eager_pr.c b/quantum/debounce/eager_pr.c index 26b17ed295..8dbfa3fcfa 100644 --- a/quantum/debounce/eager_pr.c +++ b/quantum/debounce/eager_pr.c @@ -28,6 +28,7 @@ No further inputs are accepted until DEBOUNCE milliseconds have occurred. #endif #define debounce_counter_t uint8_t +static bool matrix_need_update; static debounce_counter_t *debounce_counters; static bool counters_need_update; @@ -53,7 +54,7 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool update_debounce_counters(num_rows, current_time); } - if (changed || (needed_update && !counters_need_update)) { + if (changed || (needed_update && !counters_need_update) || matrix_need_update) { transfer_matrix_values(raw, cooked, num_rows, current_time); } } @@ -76,18 +77,22 @@ void update_debounce_counters(uint8_t num_rows, uint8_t current_time) { // upload from raw_matrix to final matrix; void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t current_time) { + matrix_need_update = false; debounce_counter_t *debounce_pointer = debounce_counters; for (uint8_t row = 0; row < num_rows; row++) { matrix_row_t existing_row = cooked[row]; matrix_row_t raw_row = raw[row]; // determine new value basd on debounce pointer + raw value - if (*debounce_pointer == DEBOUNCE_ELAPSED && (existing_row != raw_row)) { - *debounce_pointer = current_time; - cooked[row] = raw_row; - counters_need_update = true; + if (existing_row != raw_row) { + if (*debounce_pointer == DEBOUNCE_ELAPSED) { + *debounce_pointer = current_time; + cooked[row] = raw_row; + counters_need_update = true; + } else { + matrix_need_update = true; + } } - debounce_pointer++; } } diff --git a/quantum/keymap_extras/sendstring_belgian.h b/quantum/keymap_extras/sendstring_belgian.h new file mode 100644 index 0000000000..77531a14ab --- /dev/null +++ b/quantum/keymap_extras/sendstring_belgian.h @@ -0,0 +1,94 @@ +/* Copyright 2019 kimat + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +/* Sendstring definitions for the belgian layout */ +#ifndef SENDSTRING_BELGIAN +#define SENDSTRING_BELGIAN + +#include "keymap_belgian.h" + +const bool ascii_to_shift_lut[0x80] PROGMEM = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 1, 1, 0, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 0, 0, 0, 1, 1, + 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 +}; +const bool ascii_to_altgr_lut[0x80] PROGMEM = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 1, 1, 1, 0 +}; + +// NOTE that you have to send the dead keys twice: tilda, circ +// SEND_STRING(" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^^``_abcdefghijklmnopqrstuvwxyz{|}~~"); +const uint8_t ascii_to_keycode_lut[0x80] PROGMEM = { + 0, 0, 0, 0, 0, 0, 0, 0, + KC_BSPC, KC_TAB, KC_ENT, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, KC_ESC, 0, 0, 0, 0, + /* SPACE ! " # $ % & ' */ + KC_SPC, BE_EXLM, BE_QUOT, BE_QUOT, BE_DLR,BE_UGRV,BE_AMP, BE_APOS , + /* ( ) * + , - . / */ + BE_LPRN, BE_RPRN, BE_DLR,BE_EQL, BE_COMM, BE_MINS, BE_SCLN, BE_COLN, + /* 0 1 2 3 4 5 6 7 */ + BE_AGRV, BE_AMP, BE_EACU, BE_QUOT, BE_APOS, BE_LPRN, BE_PARA, BE_EGRV, + /* 8 9 : ; < = > ? */ + BE_EXLM, BE_CCED, BE_COLN, BE_SCLN, BE_LESS, BE_EQL, BE_LESS, BE_COMM, + /* @ A B C D E F G */ + BE_EACU, BE_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, + /* H I J K L M N O */ + KC_H, KC_I, KC_J, KC_K, KC_L, BE_M, KC_N, KC_O, + /* P Q R S T U V W */ + KC_P, BE_Q, KC_R, KC_S, KC_T, KC_U, KC_V, BE_W, + /* X Y Z [ \ ] ^ _ */ + KC_X, KC_Y, BE_Z, BE_CIRC, BE_LESS, BE_DLR, BE_PARA, BE_MINS, + /* ` a b c d e f g */ + BE_MU, BE_A, KC_B, KC_C, KC_D, KC_E, KC_F, KC_G, + /* h i j k l m n o */ + KC_H, KC_I, KC_J, KC_K, KC_L, BE_M, KC_N, KC_O, + /* p q r s t u v w */ + KC_P, BE_Q, KC_R, KC_S, KC_T, KC_U, KC_V, BE_W, + /* x y z { | } ~ DELETE */ + KC_X, KC_Y, BE_Z, BE_CCED, BE_AMP, BE_AGRV, BE_EQL, KC_DEL +}; + +#endif diff --git a/quantum/led_matrix_drivers.c b/quantum/led_matrix_drivers.c index 4ee509ee56..cb91821a40 100644 --- a/quantum/led_matrix_drivers.c +++ b/quantum/led_matrix_drivers.c @@ -53,16 +53,16 @@ static void init(void) { #endif #else #ifdef LED_DRIVER_ADDR_1 - IS31FL3733_init(LED_DRIVER_ADDR_1); + IS31FL3733_init(LED_DRIVER_ADDR_1, 0 ); #endif #ifdef LED_DRIVER_ADDR_2 - IS31FL3733_init(LED_DRIVER_ADDR_2); + IS31FL3733_init(LED_DRIVER_ADDR_2, 0 ); #endif #ifdef LED_DRIVER_ADDR_3 - IS31FL3733_init(LED_DRIVER_ADDR_3); + IS31FL3733_init(LED_DRIVER_ADDR_3, 0 ); #endif #ifdef LED_DRIVER_ADDR_4 - IS31FL3733_init(LED_DRIVER_ADDR_4); + IS31FL3733_init(LED_DRIVER_ADDR_4, 0 ); #endif #endif diff --git a/quantum/matrix.c b/quantum/matrix.c index ca63f50f24..7ccac35331 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -183,7 +183,7 @@ static void unselect_row(uint8_t row) static void unselect_rows(void) { for(uint8_t x = 0; x < MATRIX_ROWS; x++) { - setPinInput(row_pins[x]); + setPinInputHigh(row_pins[x]); } } @@ -326,5 +326,5 @@ uint8_t matrix_scan(void) debounce(raw_matrix, matrix, MATRIX_ROWS, changed); matrix_scan_quantum(); - return 1; + return (uint8_t)changed; } diff --git a/quantum/process_keycode/process_clicky.c b/quantum/process_keycode/process_clicky.c index 12fef51f9e..43b803afe7 100644 --- a/quantum/process_keycode/process_clicky.c +++ b/quantum/process_keycode/process_clicky.c @@ -3,6 +3,9 @@ #ifdef AUDIO_CLICKY +#ifndef AUDIO_CLICKY_DELAY_DURATION +#define AUDIO_CLICKY_DELAY_DURATION 1 +#endif // !AUDIO_CLICKY_DELAY_DURATION #ifndef AUDIO_CLICKY_FREQ_DEFAULT #define AUDIO_CLICKY_FREQ_DEFAULT 440.0f #endif // !AUDIO_CLICKY_FREQ_DEFAULT @@ -21,7 +24,9 @@ float clicky_freq = AUDIO_CLICKY_FREQ_DEFAULT; float clicky_rand = AUDIO_CLICKY_FREQ_RANDOMNESS; -float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations + +// the first "note" is an intentional delay; the 2nd and 3rd notes are the "clicky" +float clicky_song[][2] = {{AUDIO_CLICKY_FREQ_MIN, AUDIO_CLICKY_DELAY_DURATION}, {AUDIO_CLICKY_FREQ_DEFAULT, 3}, {AUDIO_CLICKY_FREQ_DEFAULT, 1}}; // 3 and 1 --> durations extern audio_config_t audio_config; @@ -34,8 +39,8 @@ void clicky_play(void) { #ifndef NO_MUSIC_MODE if (music_activated || midi_activated || !audio_config.enable) return; #endif // !NO_MUSIC_MODE - clicky_song[0][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) ); - clicky_song[1][0] = clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) ); + clicky_song[1][0] = 2.0f * clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) ); + clicky_song[2][0] = clicky_freq * (1.0f + clicky_rand * ( ((float)rand()) / ((float)(RAND_MAX)) ) ); PLAY_SONG(clicky_song); } diff --git a/quantum/process_keycode/process_space_cadet.c b/quantum/process_keycode/process_space_cadet.c index ac39df8089..c8721d446c 100644 --- a/quantum/process_keycode/process_space_cadet.c +++ b/quantum/process_keycode/process_space_cadet.c @@ -60,18 +60,18 @@ // Control / paren setup #ifndef LCPO_KEYS - #define LCPO_KEYS KC_LCTL, KC_LCTL, KC_9 + #define LCPO_KEYS KC_LCTL, KC_LSFT, KC_9 #endif #ifndef RCPC_KEYS - #define RCPC_KEYS KC_RCTL, KC_RCTL, KC_0 + #define RCPC_KEYS KC_RCTL, KC_RSFT, KC_0 #endif // Alt / paren setup #ifndef LAPO_KEYS - #define LAPO_KEYS KC_LALT, KC_LALT, KC_9 + #define LAPO_KEYS KC_LALT, KC_LSFT, KC_9 #endif #ifndef RAPC_KEYS - #define RAPC_KEYS KC_RALT, KC_RALT, KC_0 + #define RAPC_KEYS KC_RALT, KC_RSFT, KC_0 #endif // Shift / Enter setup @@ -81,11 +81,17 @@ static uint8_t sc_last = 0; static uint16_t sc_timer = 0; +#ifdef SPACE_CADET_MODIFIER_CARRYOVER +static uint8_t sc_mods = 0; +#endif void perform_space_cadet(keyrecord_t *record, uint8_t holdMod, uint8_t tapMod, uint8_t keycode) { if (record->event.pressed) { sc_last = holdMod; sc_timer = timer_read (); +#ifdef SPACE_CADET_MODIFIER_CARRYOVER + sc_mods = get_mods(); +#endif if (IS_MOD(holdMod)) { register_mods(MOD_BIT(holdMod)); } @@ -100,7 +106,13 @@ void perform_space_cadet(keyrecord_t *record, uint8_t holdMod, uint8_t tapMod, u register_mods(MOD_BIT(tapMod)); } } +#ifdef SPACE_CADET_MODIFIER_CARRYOVER + set_weak_mods(sc_mods); +#endif tap_code(keycode); +#ifdef SPACE_CADET_MODIFIER_CARRYOVER + clear_weak_mods(); +#endif if (IS_MOD(tapMod)) { unregister_mods(MOD_BIT(tapMod)); } @@ -143,7 +155,9 @@ bool process_space_cadet(uint16_t keycode, keyrecord_t *record) { return false; } default: { - sc_last = 0; + if (record->event.pressed) { + sc_last = 0; + } break; } } diff --git a/quantum/quantum.c b/quantum/quantum.c index d4fa7f2efc..6530738b71 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -258,7 +258,7 @@ bool process_record_quantum(keyrecord_t *record) { #ifdef HAPTIC_ENABLE process_haptic(keycode, record) && #endif //HAPTIC_ENABLE - #if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_KEYREACTIVE_ENABLED) + #if defined(RGB_MATRIX_ENABLE) process_rgb_matrix(keycode, record) && #endif process_record_kb(keycode, record) && @@ -312,8 +312,12 @@ bool process_record_quantum(keyrecord_t *record) { return false; case DEBUG: if (record->event.pressed) { - debug_enable = true; + debug_enable ^= 1; + if (debug_enable) { print("DEBUG: enabled.\n"); + } else { + print("DEBUG: disabled.\n"); + } } return false; case EEPROM_RESET: @@ -703,8 +707,9 @@ bool process_record_quantum(keyrecord_t *record) { #if defined(BACKLIGHT_ENABLE) && defined(BACKLIGHT_BREATHING) case BL_BRTG: { - if (record->event.pressed) + if (record->event.pressed) { breathing_toggle(); + } return false; } #endif @@ -1023,35 +1028,49 @@ void matrix_scan_quantum() { # define TCCRxB TCCR1B # define COMxx1 COM1C1 # define OCRxx OCR1C +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 # define ICRx ICR1 +# define TIMSKx TIMSK1 #elif BACKLIGHT_PIN == B6 # define HARDWARE_PWM # define TCCRxA TCCR1A # define TCCRxB TCCR1B # define COMxx1 COM1B1 # define OCRxx OCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 # define ICRx ICR1 +# define TIMSKx TIMSK1 #elif BACKLIGHT_PIN == B5 # define HARDWARE_PWM # define TCCRxA TCCR1A # define TCCRxB TCCR1B # define COMxx1 COM1A1 # define OCRxx OCR1A +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 # define ICRx ICR1 +# define TIMSKx TIMSK1 #elif BACKLIGHT_PIN == C6 # define HARDWARE_PWM # define TCCRxA TCCR3A # define TCCRxB TCCR3B -# define COMxx1 COM1A1 +# define COMxx1 COM3A1 # define OCRxx OCR3A +# define TIMERx_OVF_vect TIMER3_OVF_vect +# define TOIEx TOIE3 # define ICRx ICR3 +# define TIMSKx TIMSK3 #elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4 # define TCCRxA TCCR1A # define TCCRxB TCCR1B # define COMxx1 COM1B1 # define OCRxx OCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TOIEx TOIE1 # define ICRx ICR1 -# define TIMSK1 TIMSK +# define TIMSKx TIMSK1 #else # if !defined(BACKLIGHT_CUSTOM_DRIVER) # if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) @@ -1062,15 +1081,15 @@ void matrix_scan_quantum() { # define TCCRxA TCCR1A # define TCCRxB TCCR1B # define OCRxx OCR1A -# define OCRxAH OCR1AH -# define OCRxAL OCR1AL # define TIMERx_COMPA_vect TIMER1_COMPA_vect # define TIMERx_OVF_vect TIMER1_OVF_vect # define OCIExA OCIE1A # define TOIEx TOIE1 # define ICRx ICR1 -# ifndef TIMSK -# define TIMSK TIMSK1 +# if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register +# define TIMSKx TIMSK +# else +# define TIMSKx TIMSK1 # endif # elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) #pragma message "Using hardware timer 3 with software PWM" @@ -1080,16 +1099,12 @@ void matrix_scan_quantum() { # define TCCRxA TCCR3A # define TCCRxB TCCR3B # define OCRxx OCR3A -# define OCRxAH OCR3AH -# define OCRxAL OCR3AL # define TIMERx_COMPA_vect TIMER3_COMPA_vect # define TIMERx_OVF_vect TIMER3_OVF_vect # define OCIExA OCIE3A # define TOIEx TOIE3 # define ICRx ICR1 -# ifndef TIMSK -# define TIMSK TIMSK3 -# endif +# define TIMSKx TIMSK3 # else #pragma message "Audio in use - using pure software PWM" #define NO_HARDWARE_PWM @@ -1134,13 +1149,13 @@ void backlight_off(uint8_t backlight_pin) { #define BACKLIGHT_PIN_INIT BACKLIGHT_PINS #endif -#define FOR_EACH_LED(x) \ +#define FOR_EACH_LED(x) \ for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) \ - { \ - uint8_t backlight_pin = backlight_pins[i]; \ + { \ + uint8_t backlight_pin = backlight_pins[i]; \ { \ - x \ - } \ + x \ + } \ } static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; @@ -1219,7 +1234,9 @@ ISR(TIMERx_COMPA_vect) { // this one triggers at F_CPU/65536 =~ 244 Hz ISR(TIMERx_OVF_vect) { #ifdef BACKLIGHT_BREATHING - breathing_task(); + if(is_breathing()) { + breathing_task(); + } #endif // for very small values of OCRxx (or backlight level) // we can't guarantee this whole code won't execute @@ -1270,8 +1287,8 @@ void backlight_set(uint8_t level) { if (level == 0) { #ifdef BACKLIGHT_PWM_TIMER if (OCRxx) { - TIMSK &= ~(_BV(OCIExA)); - TIMSK &= ~(_BV(TOIEx)); + TIMSKx &= ~(_BV(OCIExA)); + TIMSKx &= ~(_BV(TOIEx)); FOR_EACH_LED( backlight_off(backlight_pin); ) @@ -1283,8 +1300,8 @@ void backlight_set(uint8_t level) { } else { #ifdef BACKLIGHT_PWM_TIMER if (!OCRxx) { - TIMSK |= _BV(OCIExA); - TIMSK |= _BV(TOIEx); + TIMSKx |= _BV(OCIExA); + TIMSKx |= _BV(TOIEx); } #else // Turn on PWM control of backlight pin @@ -1321,11 +1338,11 @@ bool is_breathing(void) { #else bool is_breathing(void) { - return !!(TIMSK1 & _BV(TOIE1)); + return !!(TIMSKx & _BV(TOIEx)); } -#define breathing_interrupt_enable() do {TIMSK1 |= _BV(TOIE1);} while (0) -#define breathing_interrupt_disable() do {TIMSK1 &= ~_BV(TOIE1);} while (0) +#define breathing_interrupt_enable() do {TIMSKx |= _BV(TOIEx);} while (0) +#define breathing_interrupt_disable() do {TIMSKx &= ~_BV(TOIEx);} while (0) #endif #define breathing_min() do {breathing_counter = 0;} while (0) @@ -1407,7 +1424,7 @@ void breathing_task(void) /* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run * about 244 times per second. */ -ISR(TIMER1_OVF_vect) +ISR(TIMERx_OVF_vect) #endif { uint16_t interval = (uint16_t) breathing_period * 244 / BREATHING_STEPS; diff --git a/quantum/quantum.h b/quantum/quantum.h index 208268df65..f089c6ef64 100644 --- a/quantum/quantum.h +++ b/quantum/quantum.h @@ -13,8 +13,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#ifndef QUANTUM_H -#define QUANTUM_H +#pragma once #if defined(__AVR__) #include <avr/pgmspace.h> @@ -24,9 +23,11 @@ #if defined(PROTOCOL_CHIBIOS) #include "hal.h" #endif + #include "wait.h" #include "matrix.h" #include "keymap.h" + #ifdef BACKLIGHT_ENABLE #ifdef LED_MATRIX_ENABLE #include "ledmatrix.h" @@ -34,14 +35,13 @@ #include "backlight.h" #endif #endif -#ifdef RGBLIGHT_ENABLE - #include "rgblight.h" -#else - #ifdef RGB_MATRIX_ENABLE - /* dummy define RGBLIGHT_MODE_xxxx */ - #define RGBLIGHT_H_DUMMY_DEFINE - #include "rgblight.h" - #endif + +#if defined(RGBLIGHT_ENABLE) + #include "rgblight.h" +#elif defined(RGB_MATRIX_ENABLE) + // Dummy define RGBLIGHT_MODE_xxxx + #define RGBLIGHT_H_DUMMY_DEFINE + #include "rgblight.h" #endif #ifdef RGB_MATRIX_ENABLE @@ -50,35 +50,33 @@ #include "action_layer.h" #include "eeconfig.h" -#include <stddef.h> #include "bootloader.h" #include "timer.h" #include "config_common.h" #include "led.h" #include "action_util.h" -#include <stdlib.h> #include "print.h" #include "send_string_keycodes.h" #include "suspend.h" +#include <stddef.h> +#include <stdlib.h> -extern uint32_t default_layer_state; +extern layer_state_t default_layer_state; #ifndef NO_ACTION_LAYER - extern uint32_t layer_state; + extern layer_state_t layer_state; #endif -#ifdef MIDI_ENABLE -#ifdef MIDI_ADVANCED +#if defined(MIDI_ENABLE) && defined(MIDI_ADVANCED) #include "process_midi.h" #endif -#endif // MIDI_ENABLE #ifdef AUDIO_ENABLE #include "audio.h" #include "process_audio.h" #ifdef AUDIO_CLICKY #include "process_clicky.h" - #endif // AUDIO_CLICKY + #endif #endif #ifdef STENO_ENABLE @@ -106,7 +104,7 @@ extern uint32_t default_layer_state; #endif #ifdef TAP_DANCE_ENABLE - #include "process_tap_dance.h" + #include "process_tap_dance.h" #endif #ifdef PRINTING_ENABLE @@ -132,7 +130,7 @@ extern uint32_t default_layer_state; #endif #ifdef SPACE_CADET_ENABLE - #include "process_space_cadet.h" + #include "process_space_cadet.h" #endif #ifdef HD44780_ENABLE @@ -147,50 +145,38 @@ extern uint32_t default_layer_state; #include "oled_driver.h" #endif -//Function substitutions to ease GPIO manipulation -#ifdef __AVR__ - #define PIN_ADDRESS(p, offset) _SFR_IO8(ADDRESS_BASE + (p >> PORT_SHIFTER) + offset) - - #define pin_t uint8_t - #define setPinInput(pin) PIN_ADDRESS(pin, 1) &= ~ _BV(pin & 0xF) - #define setPinInputHigh(pin) ({\ - PIN_ADDRESS(pin, 1) &= ~ _BV(pin & 0xF);\ - PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF);\ - }) - #define setPinInputLow(pin) _Static_assert(0, "AVR Processors cannot impliment an input as pull low") - #define setPinOutput(pin) PIN_ADDRESS(pin, 1) |= _BV(pin & 0xF) - - #define writePinHigh(pin) PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF) - #define writePinLow(pin) PIN_ADDRESS(pin, 2) &= ~_BV(pin & 0xF) - static inline void writePin(pin_t pin, uint8_t level){ - if (level){ - PIN_ADDRESS(pin, 2) |= _BV(pin & 0xF); - } else { - PIN_ADDRESS(pin, 2) &= ~_BV(pin & 0xF); - } - } - - #define readPin(pin) ((bool)(PIN_ADDRESS(pin, 0) & _BV(pin & 0xF))) +// Function substitutions to ease GPIO manipulation +#if defined(__AVR__) + typedef uint8_t pin_t; + + #define PIN_ADDRESS(p, offset) (_SFR_IO8(ADDRESS_BASE + ((p) >> PORT_SHIFTER) + (offset))) + #define setPinInput(pin) (PIN_ADDRESS(pin, 1) &= ~_BV((pin) & 0xF)) + #define setPinInputHigh(pin) (PIN_ADDRESS(pin, 1) &= ~_BV((pin) & 0xF), \ + PIN_ADDRESS(pin, 2) |= _BV((pin) & 0xF)) + #define setPinInputLow(pin) _Static_assert(0, "AVR processors cannot implement an input as pull low") + #define setPinOutput(pin) (PIN_ADDRESS(pin, 1) |= _BV((pin) & 0xF)) + + #define writePinHigh(pin) (PIN_ADDRESS(pin, 2) |= _BV((pin) & 0xF)) + #define writePinLow(pin) (PIN_ADDRESS(pin, 2) &= ~_BV((pin) & 0xF)) + #define writePin(pin, level) ((level) ? writePinHigh(pin) : writePinLow(pin)) + + #define readPin(pin) ((bool)(PIN_ADDRESS(pin, 0) & _BV((pin) & 0xF))) #elif defined(PROTOCOL_CHIBIOS) - #define pin_t ioline_t - #define setPinInput(pin) palSetLineMode(pin, PAL_MODE_INPUT) - #define setPinInputHigh(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLUP) - #define setPinInputLow(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLDOWN) - #define setPinOutput(pin) palSetLineMode(pin, PAL_MODE_OUTPUT_PUSHPULL) - - #define writePinHigh(pin) palSetLine(pin) - #define writePinLow(pin) palClearLine(pin) - static inline void writePin(pin_t pin, uint8_t level){ - if (level){ - palSetLine(pin); - } else { - palClearLine(pin); - } - } - - #define readPin(pin) palReadLine(pin) + typedef ioline_t pin_t; + + #define setPinInput(pin) palSetLineMode(pin, PAL_MODE_INPUT) + #define setPinInputHigh(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLUP) + #define setPinInputLow(pin) palSetLineMode(pin, PAL_MODE_INPUT_PULLDOWN) + #define setPinOutput(pin) palSetLineMode(pin, PAL_MODE_OUTPUT_PUSHPULL) + + #define writePinHigh(pin) palSetLine(pin) + #define writePinLow(pin) palClearLine(pin) + #define writePin(pin, level) ((level) ? writePinHigh(pin) : writePinLow(pin)) + + #define readPin(pin) palReadLine(pin) #endif +// Send string macros #define STRINGIZE(z) #z #define ADD_SLASH_X(y) STRINGIZE(\x ## y) #define SYMBOL_STR(x) ADD_SLASH_X(x) @@ -203,6 +189,7 @@ extern uint32_t default_layer_state; #define SS_DOWN(keycode) "\2" SYMBOL_STR(keycode) #define SS_UP(keycode) "\3" SYMBOL_STR(keycode) +// `string` arguments must not be parenthesized #define SS_LCTRL(string) SS_DOWN(X_LCTRL) string SS_UP(X_LCTRL) #define SS_LGUI(string) SS_DOWN(X_LGUI) string SS_UP(X_LGUI) #define SS_LCMD(string) SS_LGUI(string) @@ -212,10 +199,12 @@ extern uint32_t default_layer_state; #define SS_RALT(string) SS_DOWN(X_RALT) string SS_UP(X_RALT) #define SS_ALGR(string) SS_RALT(string) -#define SEND_STRING(str) send_string_P(PSTR(str)) +#define SEND_STRING(string) send_string_P(PSTR(string)) + extern const bool ascii_to_shift_lut[0x80]; extern const bool ascii_to_altgr_lut[0x80]; extern const uint8_t ascii_to_keycode_lut[0x80]; + void send_string(const char *str); void send_string_with_delay(const char *str, uint8_t interval); void send_string_P(const char *str); @@ -244,10 +233,10 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record); bool process_record_user(uint16_t keycode, keyrecord_t *record); #ifndef BOOTMAGIC_LITE_COLUMN - #define BOOTMAGIC_LITE_COLUMN 0 + #define BOOTMAGIC_LITE_COLUMN 0 #endif #ifndef BOOTMAGIC_LITE_ROW - #define BOOTMAGIC_LITE_ROW 0 + #define BOOTMAGIC_LITE_ROW 0 #endif void bootmagic_lite(void); @@ -268,7 +257,7 @@ void backlight_task_internal(void); void backlight_on(uint8_t backlight_pin); void backlight_off(uint8_t backlight_pin); -#ifdef BACKLIGHT_BREATHING + #ifdef BACKLIGHT_BREATHING void breathing_task(void); void breathing_enable(void); void breathing_pulse(void); @@ -282,9 +271,9 @@ void breathing_period_default(void); void breathing_period_set(uint8_t value); void breathing_period_inc(void); void breathing_period_dec(void); + #endif #endif -#endif void send_dword(uint32_t number); void send_word(uint16_t number); void send_byte(uint8_t number); @@ -295,5 +284,3 @@ void led_set_user(uint8_t usb_led); void led_set_kb(uint8_t usb_led); void api_send_unicode(uint32_t unicode); - -#endif diff --git a/quantum/rgb_matrix.c b/quantum/rgb_matrix.c index 92a94df80f..d20daf5e45 100644 --- a/quantum/rgb_matrix.c +++ b/quantum/rgb_matrix.c @@ -26,42 +26,38 @@ #include "lib/lib8tion/lib8tion.h" -#include "rgb_matrix_animations/solid_color_anim.h" -#include "rgb_matrix_animations/alpha_mods_anim.h" -#include "rgb_matrix_animations/dual_beacon_anim.h" -#include "rgb_matrix_animations/gradient_up_down_anim.h" -#include "rgb_matrix_animations/raindrops_anim.h" -#include "rgb_matrix_animations/cycle_all_anim.h" -#include "rgb_matrix_animations/cycle_left_right_anim.h" -#include "rgb_matrix_animations/cycle_up_down_anim.h" -#include "rgb_matrix_animations/rainbow_beacon_anim.h" -#include "rgb_matrix_animations/rainbow_pinwheels_anim.h" -#include "rgb_matrix_animations/rainbow_moving_chevron_anim.h" -#include "rgb_matrix_animations/jellybean_raindrops_anim.h" -#include "rgb_matrix_animations/typing_heatmap_anim.h" -#include "rgb_matrix_animations/digital_rain_anim.h" -#include "rgb_matrix_animations/solid_reactive_simple_anim.h" -#include "rgb_matrix_animations/solid_reactive_anim.h" -#include "rgb_matrix_animations/solid_reactive_wide.h" -#include "rgb_matrix_animations/solid_reactive_cross.h" -#include "rgb_matrix_animations/solid_reactive_nexus.h" -#include "rgb_matrix_animations/splash_anim.h" -#include "rgb_matrix_animations/solid_splash_anim.h" -#include "rgb_matrix_animations/breathing_anim.h" +#ifndef RGB_MATRIX_CENTER + const point_t k_rgb_matrix_center = { 112, 32 }; +#else + const point_t k_rgb_matrix_center = RGB_MATRIX_CENTER; +#endif -#if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER) - #define RGB_MATRIX_CUSTOM_EFFECT_IMPLS - #define RGB_MATRIX_EFFECT(name, ...) - #ifdef RGB_MATRIX_CUSTOM_KB - #include "rgb_matrix_kb.inc" - #endif - #ifdef RGB_MATRIX_CUSTOM_USER - #include "rgb_matrix_user.inc" - #endif - #undef RGB_MATRIX_EFFECT - #undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS +// Generic effect runners +#include "rgb_matrix_runners/effect_runner_dx_dy_dist.h" +#include "rgb_matrix_runners/effect_runner_dx_dy.h" +#include "rgb_matrix_runners/effect_runner_i.h" +#include "rgb_matrix_runners/effect_runner_sin_cos_i.h" +#include "rgb_matrix_runners/effect_runner_reactive.h" +#include "rgb_matrix_runners/effect_runner_reactive_splash.h" + +// ------------------------------------------ +// -----Begin rgb effect includes macros----- +#define RGB_MATRIX_EFFECT(name) +#define RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +#include "rgb_matrix_animations/rgb_matrix_effects.inc" +#ifdef RGB_MATRIX_CUSTOM_KB + #include "rgb_matrix_kb.inc" +#endif +#ifdef RGB_MATRIX_CUSTOM_USER + #include "rgb_matrix_user.inc" #endif +#undef RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#undef RGB_MATRIX_EFFECT +// -----End rgb effect includes macros------- +// ------------------------------------------ + #ifndef RGB_DISABLE_AFTER_TIMEOUT #define RGB_DISABLE_AFTER_TIMEOUT 0 #endif @@ -106,7 +102,6 @@ bool g_suspend_state = false; -extern led_config_t g_led_config; rgb_config_t rgb_matrix_config; rgb_counters_t g_rgb_counters; @@ -133,9 +128,7 @@ void eeconfig_update_rgb_matrix_default(void) { dprintf("eeconfig_update_rgb_matrix_default\n"); rgb_matrix_config.enable = 1; rgb_matrix_config.mode = RGB_MATRIX_STARTUP_MODE; - rgb_matrix_config.hue = 0; - rgb_matrix_config.sat = UINT8_MAX; - rgb_matrix_config.val = RGB_MATRIX_MAXIMUM_BRIGHTNESS; + rgb_matrix_config.hsv = (HSV){ 0, UINT8_MAX, RGB_MATRIX_MAXIMUM_BRIGHTNESS }; rgb_matrix_config.speed = UINT8_MAX / 2; eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } @@ -144,9 +137,9 @@ void eeconfig_debug_rgb_matrix(void) { dprintf("rgb_matrix_config eprom\n"); dprintf("rgb_matrix_config.enable = %d\n", rgb_matrix_config.enable); dprintf("rgb_matrix_config.mode = %d\n", rgb_matrix_config.mode); - dprintf("rgb_matrix_config.hue = %d\n", rgb_matrix_config.hue); - dprintf("rgb_matrix_config.sat = %d\n", rgb_matrix_config.sat); - dprintf("rgb_matrix_config.val = %d\n", rgb_matrix_config.val); + dprintf("rgb_matrix_config.hsv.h = %d\n", rgb_matrix_config.hsv.h); + dprintf("rgb_matrix_config.hsv.s = %d\n", rgb_matrix_config.hsv.s); + dprintf("rgb_matrix_config.hsv.v = %d\n", rgb_matrix_config.hsv.v); dprintf("rgb_matrix_config.speed = %d\n", rgb_matrix_config.speed); } @@ -319,145 +312,14 @@ static void rgb_task_render(uint8_t effect) { rendering = rgb_matrix_none(&rgb_effect_params); break; - case RGB_MATRIX_SOLID_COLOR: - rendering = rgb_matrix_solid_color(&rgb_effect_params); // Max 1ms Avg 0ms - break; -#ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS - case RGB_MATRIX_ALPHAS_MODS: - rendering = rgb_matrix_alphas_mods(&rgb_effect_params); // Max 2ms Avg 1ms - break; -#endif // DISABLE_RGB_MATRIX_ALPHAS_MODS -#ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN - case RGB_MATRIX_GRADIENT_UP_DOWN: - rendering = rgb_matrix_gradient_up_down(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN -#ifndef DISABLE_RGB_MATRIX_BREATHING - case RGB_MATRIX_BREATHING: - rendering = rgb_matrix_breathing(&rgb_effect_params); // Max 1ms Avg 0ms - break; -#endif // DISABLE_RGB_MATRIX_BREATHING -#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL - case RGB_MATRIX_CYCLE_ALL: - rendering = rgb_matrix_cycle_all(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_CYCLE_ALL -#ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT - case RGB_MATRIX_CYCLE_LEFT_RIGHT: - rendering = rgb_matrix_cycle_left_right(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT -#ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN - case RGB_MATRIX_CYCLE_UP_DOWN: - rendering = rgb_matrix_cycle_up_down(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_CYCLE_UP_DOWN -#ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON - case RGB_MATRIX_RAINBOW_MOVING_CHEVRON: - rendering = rgb_matrix_rainbow_moving_chevron(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON -#ifndef DISABLE_RGB_MATRIX_DUAL_BEACON - case RGB_MATRIX_DUAL_BEACON: - rendering = rgb_matrix_dual_beacon(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_DUAL_BEACON -#ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON - case RGB_MATRIX_RAINBOW_BEACON: - rendering = rgb_matrix_rainbow_beacon(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_RAINBOW_BEACON -#ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS - case RGB_MATRIX_RAINBOW_PINWHEELS: - rendering = rgb_matrix_rainbow_pinwheels(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS -#ifndef DISABLE_RGB_MATRIX_RAINDROPS - case RGB_MATRIX_RAINDROPS: - rendering = rgb_matrix_raindrops(&rgb_effect_params); // Max 1ms Avg 0ms - break; -#endif // DISABLE_RGB_MATRIX_RAINDROPS -#ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS - case RGB_MATRIX_JELLYBEAN_RAINDROPS: - rendering = rgb_matrix_jellybean_raindrops(&rgb_effect_params); // Max 1ms Avg 0ms - break; -#endif // DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS - -#ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS -#ifndef DISABLE_RGB_MATRIX_TYPING_HEATMAP - case RGB_MATRIX_TYPING_HEATMAP: - rendering = rgb_matrix_typing_heatmap(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_TYPING_HEATMAP -#ifndef DISABLE_RGB_MATRIX_DIGITAL_RAIN - case RGB_MATRIX_DIGITAL_RAIN: - rendering = rgb_matrix_digital_rain(&rgb_effect_params); // Max 9ms Avg 8ms | this is expensive, fix it - break; -#endif // DISABLE_RGB_MATRIX_DIGITAL_RAIN -#endif // RGB_MATRIX_FRAMEBUFFER_EFFECTS - -#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE - case RGB_MATRIX_SOLID_REACTIVE_SIMPLE: - rendering = rgb_matrix_solid_reactive_simple(&rgb_effect_params);// Max 4ms Avg 3ms - break; -#endif -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE - case RGB_MATRIX_SOLID_REACTIVE: - rendering = rgb_matrix_solid_reactive(&rgb_effect_params); // Max 4ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE - case RGB_MATRIX_SOLID_REACTIVE_WIDE: - rendering = rgb_matrix_solid_reactive_wide(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE - case RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE: - rendering = rgb_matrix_solid_reactive_multiwide(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS - case RGB_MATRIX_SOLID_REACTIVE_CROSS: - rendering = rgb_matrix_solid_reactive_cross(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS - case RGB_MATRIX_SOLID_REACTIVE_MULTICROSS: - rendering = rgb_matrix_solid_reactive_multicross(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS - case RGB_MATRIX_SOLID_REACTIVE_NEXUS: - rendering = rgb_matrix_solid_reactive_nexus(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS - case RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS: - rendering = rgb_matrix_solid_reactive_multinexus(&rgb_effect_params); // Max ?? ms Avg ?? ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS -#ifndef DISABLE_RGB_MATRIX_SPLASH - case RGB_MATRIX_SPLASH: - rendering = rgb_matrix_splash(&rgb_effect_params); // Max 5ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_SPLASH -#ifndef DISABLE_RGB_MATRIX_MULTISPLASH - case RGB_MATRIX_MULTISPLASH: - rendering = rgb_matrix_multisplash(&rgb_effect_params); // Max 10ms Avg 5ms - break; -#endif // DISABLE_RGB_MATRIX_MULTISPLASH -#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH - case RGB_MATRIX_SOLID_SPLASH: - rendering = rgb_matrix_solid_splash(&rgb_effect_params); // Max 5ms Avg 3ms - break; -#endif // DISABLE_RGB_MATRIX_SOLID_SPLASH -#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH - case RGB_MATRIX_SOLID_MULTISPLASH: - rendering = rgb_matrix_solid_multisplash(&rgb_effect_params); // Max 10ms Avg 5ms +// --------------------------------------------- +// -----Begin rgb effect switch case macros----- +#define RGB_MATRIX_EFFECT(name, ...) \ + case RGB_MATRIX_##name: \ + rendering = name(&rgb_effect_params); \ break; -#endif // DISABLE_RGB_MATRIX_SOLID_MULTISPLASH -#endif // RGB_MATRIX_KEYREACTIVE_ENABLED +#include "rgb_matrix_animations/rgb_matrix_effects.inc" +#undef RGB_MATRIX_EFFECT #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER) #define RGB_MATRIX_EFFECT(name, ...) \ @@ -472,6 +334,8 @@ static void rgb_task_render(uint8_t effect) { #endif #undef RGB_MATRIX_EFFECT #endif +// -----End rgb effect switch case macros------- +// --------------------------------------------- // Factory default magic value case UINT8_MAX: { @@ -626,34 +490,34 @@ void rgb_matrix_step_reverse(void) { } void rgb_matrix_increase_hue(void) { - rgb_matrix_config.hue += RGB_MATRIX_HUE_STEP; + rgb_matrix_config.hsv.h += RGB_MATRIX_HUE_STEP; eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } void rgb_matrix_decrease_hue(void) { - rgb_matrix_config.hue -= RGB_MATRIX_HUE_STEP; + rgb_matrix_config.hsv.h -= RGB_MATRIX_HUE_STEP; eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } void rgb_matrix_increase_sat(void) { - rgb_matrix_config.sat = qadd8(rgb_matrix_config.sat, RGB_MATRIX_SAT_STEP); + rgb_matrix_config.hsv.s = qadd8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP); eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } void rgb_matrix_decrease_sat(void) { - rgb_matrix_config.sat = qsub8(rgb_matrix_config.sat, RGB_MATRIX_SAT_STEP); + rgb_matrix_config.hsv.s = qsub8(rgb_matrix_config.hsv.s, RGB_MATRIX_SAT_STEP); eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } void rgb_matrix_increase_val(void) { - rgb_matrix_config.val = qadd8(rgb_matrix_config.val, RGB_MATRIX_VAL_STEP); - if (rgb_matrix_config.val > RGB_MATRIX_MAXIMUM_BRIGHTNESS) - rgb_matrix_config.val = RGB_MATRIX_MAXIMUM_BRIGHTNESS; + rgb_matrix_config.hsv.v = qadd8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP); + if (rgb_matrix_config.hsv.v > RGB_MATRIX_MAXIMUM_BRIGHTNESS) + rgb_matrix_config.hsv.v = RGB_MATRIX_MAXIMUM_BRIGHTNESS; eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } void rgb_matrix_decrease_val(void) { - rgb_matrix_config.val = qsub8(rgb_matrix_config.val, RGB_MATRIX_VAL_STEP); + rgb_matrix_config.hsv.v = qsub8(rgb_matrix_config.hsv.v, RGB_MATRIX_VAL_STEP); eeconfig_update_rgb_matrix(rgb_matrix_config.raw); } @@ -695,9 +559,9 @@ void rgb_matrix_sethsv(uint16_t hue, uint8_t sat, uint8_t val) { } void rgb_matrix_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) { - rgb_matrix_config.hue = hue; - rgb_matrix_config.sat = sat; - rgb_matrix_config.val = val; - if (rgb_matrix_config.val > RGB_MATRIX_MAXIMUM_BRIGHTNESS) - rgb_matrix_config.val = RGB_MATRIX_MAXIMUM_BRIGHTNESS; + rgb_matrix_config.hsv.h = hue; + rgb_matrix_config.hsv.s = sat; + rgb_matrix_config.hsv.v = val; + if (rgb_matrix_config.hsv.v > RGB_MATRIX_MAXIMUM_BRIGHTNESS) + rgb_matrix_config.hsv.v = RGB_MATRIX_MAXIMUM_BRIGHTNESS; } diff --git a/quantum/rgb_matrix.h b/quantum/rgb_matrix.h index add0715d9f..96a8b76627 100644 --- a/quantum/rgb_matrix.h +++ b/quantum/rgb_matrix.h @@ -64,89 +64,12 @@ typedef struct enum rgb_matrix_effects { RGB_MATRIX_NONE = 0, - RGB_MATRIX_SOLID_COLOR = 1, -#ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS - RGB_MATRIX_ALPHAS_MODS, -#endif // DISABLE_RGB_MATRIX_ALPHAS_MODS -#ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN - RGB_MATRIX_GRADIENT_UP_DOWN, -#endif // DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN -#ifndef DISABLE_RGB_MATRIX_BREATHING - RGB_MATRIX_BREATHING, -#endif // DISABLE_RGB_MATRIX_BREATHING -#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL - RGB_MATRIX_CYCLE_ALL, -#endif // DISABLE_RGB_MATRIX_CYCLE_ALL -#ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT - RGB_MATRIX_CYCLE_LEFT_RIGHT, -#endif // DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT -#ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN - RGB_MATRIX_CYCLE_UP_DOWN, -#endif // DISABLE_RGB_MATRIX_CYCLE_UP_DOWN -#ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON - RGB_MATRIX_RAINBOW_MOVING_CHEVRON, -#endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON -#ifndef DISABLE_RGB_MATRIX_DUAL_BEACON - RGB_MATRIX_DUAL_BEACON, -#endif // DISABLE_RGB_MATRIX_DUAL_BEACON -#ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON - RGB_MATRIX_RAINBOW_BEACON, -#endif // DISABLE_RGB_MATRIX_RAINBOW_BEACON -#ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS - RGB_MATRIX_RAINBOW_PINWHEELS, -#endif // DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS -#ifndef DISABLE_RGB_MATRIX_RAINDROPS - RGB_MATRIX_RAINDROPS, -#endif // DISABLE_RGB_MATRIX_RAINDROPS -#ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS - RGB_MATRIX_JELLYBEAN_RAINDROPS, -#endif // DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS -#ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS -#ifndef DISABLE_RGB_MATRIX_TYPING_HEATMAP - RGB_MATRIX_TYPING_HEATMAP, -#endif // DISABLE_RGB_MATRIX_TYPING_HEATMAP -#ifndef DISABLE_RGB_MATRIX_DIGITAL_RAIN - RGB_MATRIX_DIGITAL_RAIN, -#endif // DISABLE_RGB_MATRIX_DIGITAL_RAIN -#endif // RGB_MATRIX_FRAMEBUFFER_EFFECTS -#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE - RGB_MATRIX_SOLID_REACTIVE_SIMPLE, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE - RGB_MATRIX_SOLID_REACTIVE, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE - RGB_MATRIX_SOLID_REACTIVE_WIDE, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE - RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS - RGB_MATRIX_SOLID_REACTIVE_CROSS, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS - RGB_MATRIX_SOLID_REACTIVE_MULTICROSS, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS - RGB_MATRIX_SOLID_REACTIVE_NEXUS, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS -#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS - RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS, -#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS -#ifndef DISABLE_RGB_MATRIX_SPLASH - RGB_MATRIX_SPLASH, -#endif // DISABLE_RGB_MATRIX_SPLASH -#ifndef DISABLE_RGB_MATRIX_MULTISPLASH - RGB_MATRIX_MULTISPLASH, -#endif // DISABLE_RGB_MATRIX_MULTISPLASH -#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH - RGB_MATRIX_SOLID_SPLASH, -#endif // DISABLE_RGB_MATRIX_SOLID_SPLASH -#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH - RGB_MATRIX_SOLID_MULTISPLASH, -#endif // DISABLE_RGB_MATRIX_SOLID_MULTISPLASH -#endif // RGB_MATRIX_KEYREACTIVE_ENABLED + +// -------------------------------------- +// -----Begin rgb effect enum macros----- +#define RGB_MATRIX_EFFECT(name, ...) RGB_MATRIX_##name, +#include "rgb_matrix_animations/rgb_matrix_effects.inc" +#undef RGB_MATRIX_EFFECT #if defined(RGB_MATRIX_CUSTOM_KB) || defined(RGB_MATRIX_CUSTOM_USER) #define RGB_MATRIX_EFFECT(name, ...) RGB_MATRIX_CUSTOM_##name, @@ -158,6 +81,8 @@ enum rgb_matrix_effects { #endif #undef RGB_MATRIX_EFFECT #endif +// -------------------------------------- +// -----End rgb effect enum macros------- RGB_MATRIX_EFFECT_MAX }; @@ -257,4 +182,16 @@ typedef struct { extern const rgb_matrix_driver_t rgb_matrix_driver; +extern rgb_config_t rgb_matrix_config; + +extern bool g_suspend_state; +extern rgb_counters_t g_rgb_counters; +extern led_config_t g_led_config; +#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED +extern last_hit_t g_last_hit_tracker; +#endif +#ifdef RGB_MATRIX_FRAMEBUFFER_EFFECTS +extern uint8_t rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS]; +#endif + #endif diff --git a/quantum/rgb_matrix_animations/alpha_mods_anim.h b/quantum/rgb_matrix_animations/alpha_mods_anim.h index d7f6f4655b..8df3356f61 100644 --- a/quantum/rgb_matrix_animations/alpha_mods_anim.h +++ b/quantum/rgb_matrix_animations/alpha_mods_anim.h @@ -1,14 +1,12 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS - -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; +RGB_MATRIX_EFFECT(ALPHAS_MODS) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS // alphas = color1, mods = color2 -bool rgb_matrix_alphas_mods(effect_params_t* params) { +bool ALPHAS_MODS(effect_params_t* params) { RGB_MATRIX_USE_LIMITS(led_min, led_max); - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val }; + HSV hsv = rgb_matrix_config.hsv; RGB rgb1 = hsv_to_rgb(hsv); hsv.h += rgb_matrix_config.speed; RGB rgb2 = hsv_to_rgb(hsv); @@ -24,4 +22,5 @@ bool rgb_matrix_alphas_mods(effect_params_t* params) { return led_max < DRIVER_LED_TOTAL; } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_ALPHAS_MODS diff --git a/quantum/rgb_matrix_animations/breathing_anim.h b/quantum/rgb_matrix_animations/breathing_anim.h index 54d60f927d..0af7b42cf3 100644 --- a/quantum/rgb_matrix_animations/breathing_anim.h +++ b/quantum/rgb_matrix_animations/breathing_anim.h @@ -1,15 +1,13 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_BREATHING +RGB_MATRIX_EFFECT(BREATHING) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_breathing(effect_params_t* params) { +bool BREATHING(effect_params_t* params) { RGB_MATRIX_USE_LIMITS(led_min, led_max); + HSV hsv = rgb_matrix_config.hsv; uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 8); - uint8_t val = scale8(abs8(sin8(time) - 128) * 2, rgb_matrix_config.val); - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, val }; + hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); RGB rgb = hsv_to_rgb(hsv); for (uint8_t i = led_min; i < led_max; i++) { RGB_MATRIX_TEST_LED_FLAGS(); @@ -18,4 +16,5 @@ bool rgb_matrix_breathing(effect_params_t* params) { return led_max < DRIVER_LED_TOTAL; } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_BREATHING diff --git a/quantum/rgb_matrix_animations/colorband_pinwheel_sat_anim.h b/quantum/rgb_matrix_animations/colorband_pinwheel_sat_anim.h new file mode 100644 index 0000000000..4585c52716 --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_pinwheel_sat_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT +RGB_MATRIX_EFFECT(BAND_PINWHEEL_SAT) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_PINWHEEL_SAT_math(HSV hsv, int16_t dx, int16_t dy, uint8_t time) { + hsv.s = scale8(hsv.s - time - atan2_8(dy, dx) * 3, hsv.s); + return hsv; +} + +bool BAND_PINWHEEL_SAT(effect_params_t* params) { + return effect_runner_dx_dy(params, &BAND_PINWHEEL_SAT_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT diff --git a/quantum/rgb_matrix_animations/colorband_pinwheel_val_anim.h b/quantum/rgb_matrix_animations/colorband_pinwheel_val_anim.h new file mode 100644 index 0000000000..5cdb873489 --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_pinwheel_val_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL +RGB_MATRIX_EFFECT(BAND_PINWHEEL_VAL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_PINWHEEL_VAL_math(HSV hsv, int16_t dx, int16_t dy, uint8_t time) { + hsv.v = scale8(hsv.v - time - atan2_8(dy, dx) * 3, hsv.v); + return hsv; +} + +bool BAND_PINWHEEL_VAL(effect_params_t* params) { + return effect_runner_dx_dy(params, &BAND_PINWHEEL_VAL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL diff --git a/quantum/rgb_matrix_animations/colorband_sat_anim.h b/quantum/rgb_matrix_animations/colorband_sat_anim.h new file mode 100644 index 0000000000..a5175f1cd9 --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_sat_anim.h @@ -0,0 +1,16 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_SAT +RGB_MATRIX_EFFECT(BAND_SAT) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_SAT_math(HSV hsv, uint8_t i, uint8_t time) { + int16_t s = hsv.s - abs(scale8(g_led_config.point[i].x, 228) + 28 - time) * 8; + hsv.s = scale8(s < 0 ? 0 : s, hsv.s); + return hsv; +} + +bool BAND_SAT(effect_params_t* params) { + return effect_runner_i(params, &BAND_SAT_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_SAT diff --git a/quantum/rgb_matrix_animations/colorband_spiral_sat_anim.h b/quantum/rgb_matrix_animations/colorband_spiral_sat_anim.h new file mode 100644 index 0000000000..096c675de8 --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_spiral_sat_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT +RGB_MATRIX_EFFECT(BAND_SPIRAL_SAT) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_SPIRAL_SAT_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { + hsv.s = scale8(hsv.s + dist - time - atan2_8(dy, dx), hsv.s); + return hsv; +} + +bool BAND_SPIRAL_SAT(effect_params_t* params) { + return effect_runner_dx_dy_dist(params, &BAND_SPIRAL_SAT_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT diff --git a/quantum/rgb_matrix_animations/colorband_spiral_val_anim.h b/quantum/rgb_matrix_animations/colorband_spiral_val_anim.h new file mode 100644 index 0000000000..1d4cc0c84f --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_spiral_val_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL +RGB_MATRIX_EFFECT(BAND_SPIRAL_VAL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_SPIRAL_VAL_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { + hsv.v = scale8(hsv.v + dist - time - atan2_8(dy, dx), hsv.v); + return hsv; +} + +bool BAND_SPIRAL_VAL(effect_params_t* params) { + return effect_runner_dx_dy_dist(params, &BAND_SPIRAL_VAL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL diff --git a/quantum/rgb_matrix_animations/colorband_val_anim.h b/quantum/rgb_matrix_animations/colorband_val_anim.h new file mode 100644 index 0000000000..de0bbb4715 --- /dev/null +++ b/quantum/rgb_matrix_animations/colorband_val_anim.h @@ -0,0 +1,16 @@ +#ifndef DISABLE_RGB_MATRIX_BAND_VAL +RGB_MATRIX_EFFECT(BAND_VAL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV BAND_VAL_math(HSV hsv, uint8_t i, uint8_t time) { + int16_t v = hsv.v - abs(scale8(g_led_config.point[i].x, 228) + 28 - time) * 8; + hsv.v = scale8(v < 0 ? 0 : v, hsv.v); + return hsv; +} + +bool BAND_VAL(effect_params_t* params) { + return effect_runner_i(params, &BAND_VAL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_BAND_VAL diff --git a/quantum/rgb_matrix_animations/cycle_all_anim.h b/quantum/rgb_matrix_animations/cycle_all_anim.h index e93798f900..0c45aba8b1 100644 --- a/quantum/rgb_matrix_animations/cycle_all_anim.h +++ b/quantum/rgb_matrix_animations/cycle_all_anim.h @@ -1,21 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_CYCLE_ALL +RGB_MATRIX_EFFECT(CYCLE_ALL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_cycle_all(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +static HSV CYCLE_ALL_math(HSV hsv, uint8_t i, uint8_t time){ + hsv.h = time; + return hsv; +} - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - hsv.h = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool CYCLE_ALL(effect_params_t* params) { + return effect_runner_i(params, &CYCLE_ALL_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_CYCLE_ALL diff --git a/quantum/rgb_matrix_animations/cycle_left_right_anim.h b/quantum/rgb_matrix_animations/cycle_left_right_anim.h index 4b09d5826b..d2e5b4fbdf 100644 --- a/quantum/rgb_matrix_animations/cycle_left_right_anim.h +++ b/quantum/rgb_matrix_animations/cycle_left_right_anim.h @@ -1,22 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT +RGB_MATRIX_EFFECT(CYCLE_LEFT_RIGHT) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_cycle_left_right(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); - - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); +static HSV CYCLE_LEFT_RIGHT_math(HSV hsv, uint8_t i, uint8_t time) { hsv.h = g_led_config.point[i].x - time; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + return hsv; +} + +bool CYCLE_LEFT_RIGHT(effect_params_t* params) { + return effect_runner_i(params, &CYCLE_LEFT_RIGHT_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT diff --git a/quantum/rgb_matrix_animations/cycle_out_in_anim.h b/quantum/rgb_matrix_animations/cycle_out_in_anim.h new file mode 100644 index 0000000000..fa7c3b09cf --- /dev/null +++ b/quantum/rgb_matrix_animations/cycle_out_in_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_CYCLE_OUT_IN +RGB_MATRIX_EFFECT(CYCLE_OUT_IN) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV CYCLE_OUT_IN_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { + hsv.h = 3 * dist / 2 + time; + return hsv; +} + +bool CYCLE_OUT_IN(effect_params_t* params) { + return effect_runner_dx_dy_dist(params, &CYCLE_OUT_IN_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_CYCLE_OUT_IN diff --git a/quantum/rgb_matrix_animations/cycle_out_in_dual_anim.h b/quantum/rgb_matrix_animations/cycle_out_in_dual_anim.h new file mode 100644 index 0000000000..74a2c9aa58 --- /dev/null +++ b/quantum/rgb_matrix_animations/cycle_out_in_dual_anim.h @@ -0,0 +1,17 @@ +#ifndef DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL +RGB_MATRIX_EFFECT(CYCLE_OUT_IN_DUAL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV CYCLE_OUT_IN_DUAL_math(HSV hsv, int16_t dx, int16_t dy, uint8_t time) { + dx = (k_rgb_matrix_center.x / 2) - abs8(dx); + uint8_t dist = sqrt16(dx * dx + dy * dy); + hsv.h = 3 * dist + time; + return hsv; +} + +bool CYCLE_OUT_IN_DUAL(effect_params_t* params) { + return effect_runner_dx_dy(params, &CYCLE_OUT_IN_DUAL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL diff --git a/quantum/rgb_matrix_animations/cycle_pinwheel_anim.h b/quantum/rgb_matrix_animations/cycle_pinwheel_anim.h new file mode 100644 index 0000000000..54e222dc2e --- /dev/null +++ b/quantum/rgb_matrix_animations/cycle_pinwheel_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_CYCLE_PINWHEEL +RGB_MATRIX_EFFECT(CYCLE_PINWHEEL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV CYCLE_PINWHEEL_math(HSV hsv, int16_t dx, int16_t dy, uint8_t time) { + hsv.h = atan2_8(dy, dx) + time; + return hsv; +} + +bool CYCLE_PINWHEEL(effect_params_t* params) { + return effect_runner_dx_dy(params, &CYCLE_PINWHEEL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_CYCLE_PINWHEEL diff --git a/quantum/rgb_matrix_animations/cycle_spiral_anim.h b/quantum/rgb_matrix_animations/cycle_spiral_anim.h new file mode 100644 index 0000000000..b27d7a83c7 --- /dev/null +++ b/quantum/rgb_matrix_animations/cycle_spiral_anim.h @@ -0,0 +1,15 @@ +#ifndef DISABLE_RGB_MATRIX_CYCLE_SPIRAL +RGB_MATRIX_EFFECT(CYCLE_SPIRAL) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV CYCLE_SPIRAL_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint8_t time) { + hsv.h = dist - time - atan2_8(dy, dx); + return hsv; +} + +bool CYCLE_SPIRAL(effect_params_t* params) { + return effect_runner_dx_dy_dist(params, &CYCLE_SPIRAL_math); +} + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_CYCLE_SPIRAL diff --git a/quantum/rgb_matrix_animations/cycle_up_down_anim.h b/quantum/rgb_matrix_animations/cycle_up_down_anim.h index 403214bb73..4bf8ef2ae4 100644 --- a/quantum/rgb_matrix_animations/cycle_up_down_anim.h +++ b/quantum/rgb_matrix_animations/cycle_up_down_anim.h @@ -1,22 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN +RGB_MATRIX_EFFECT(CYCLE_UP_DOWN) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_cycle_up_down(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); - - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); +static HSV CYCLE_UP_DOWN_math(HSV hsv, uint8_t i, uint8_t time) { hsv.h = g_led_config.point[i].y - time; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + return hsv; +} + +bool CYCLE_UP_DOWN(effect_params_t* params) { + return effect_runner_i(params, &CYCLE_UP_DOWN_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_CYCLE_UP_DOWN diff --git a/quantum/rgb_matrix_animations/digital_rain_anim.h b/quantum/rgb_matrix_animations/digital_rain_anim.h index 6ccba392aa..982399cbde 100644 --- a/quantum/rgb_matrix_animations/digital_rain_anim.h +++ b/quantum/rgb_matrix_animations/digital_rain_anim.h @@ -1,14 +1,13 @@ -#pragma once #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_DIGITAL_RAIN) +RGB_MATRIX_EFFECT(DIGITAL_RAIN) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS #ifndef RGB_DIGITAL_RAIN_DROPS // lower the number for denser effect/wider keyboard #define RGB_DIGITAL_RAIN_DROPS 24 #endif -extern uint8_t rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS]; - -bool rgb_matrix_digital_rain(effect_params_t* params) { +bool DIGITAL_RAIN(effect_params_t* params) { // algorithm ported from https://github.com/tremby/Kaleidoscope-LEDEffect-DigitalRain const uint8_t drop_ticks = 28; const uint8_t pure_green_intensity = 0xd0; @@ -19,7 +18,7 @@ bool rgb_matrix_digital_rain(effect_params_t* params) { if (params->init) { rgb_matrix_set_color_all(0, 0, 0); - memset(rgb_frame_buffer, 0, sizeof rgb_frame_buffer); + memset(rgb_frame_buffer, 0, sizeof(rgb_frame_buffer)); drop = 0; } @@ -28,11 +27,11 @@ bool rgb_matrix_digital_rain(effect_params_t* params) { if (row == 0 && drop == 0 && rand() < RAND_MAX / RGB_DIGITAL_RAIN_DROPS) { // top row, pixels have just fallen and we're // making a new rain drop in this column - rgb_frame_buffer[col][row] = max_intensity; + rgb_frame_buffer[row][col] = max_intensity; } - else if (rgb_frame_buffer[col][row] > 0 && rgb_frame_buffer[col][row] < max_intensity) { + else if (rgb_frame_buffer[row][col] > 0 && rgb_frame_buffer[row][col] < max_intensity) { // neither fully bright nor dark, decay it - rgb_frame_buffer[col][row]--; + rgb_frame_buffer[row][col]--; } // set the pixel colour uint8_t led[LED_HITS_TO_REMEMBER]; @@ -40,12 +39,12 @@ bool rgb_matrix_digital_rain(effect_params_t* params) { // TODO: multiple leds are supported mapped to the same row/column if (led_count > 0) { - if (rgb_frame_buffer[col][row] > pure_green_intensity) { - const uint8_t boost = (uint8_t) ((uint16_t) max_brightness_boost * (rgb_frame_buffer[col][row] - pure_green_intensity) / (max_intensity - pure_green_intensity)); + if (rgb_frame_buffer[row][col] > pure_green_intensity) { + const uint8_t boost = (uint8_t) ((uint16_t) max_brightness_boost * (rgb_frame_buffer[row][col] - pure_green_intensity) / (max_intensity - pure_green_intensity)); rgb_matrix_set_color(led[0], boost, max_intensity, boost); } else { - const uint8_t green = (uint8_t) ((uint16_t) max_intensity * rgb_frame_buffer[col][row] / pure_green_intensity); + const uint8_t green = (uint8_t) ((uint16_t) max_intensity * rgb_frame_buffer[row][col] / pure_green_intensity); rgb_matrix_set_color(led[0], 0, green, 0); } } @@ -58,15 +57,15 @@ bool rgb_matrix_digital_rain(effect_params_t* params) { for (uint8_t row = MATRIX_ROWS - 1; row > 0; row--) { for (uint8_t col = 0; col < MATRIX_COLS; col++) { // if ths is on the bottom row and bright allow decay - if (row == MATRIX_ROWS - 1 && rgb_frame_buffer[col][row] == max_intensity) { - rgb_frame_buffer[col][row]--; + if (row == MATRIX_ROWS - 1 && rgb_frame_buffer[row][col] == max_intensity) { + rgb_frame_buffer[row][col]--; } // check if the pixel above is bright - if (rgb_frame_buffer[col][row - 1] == max_intensity) { + if (rgb_frame_buffer[row - 1][col] == max_intensity) { // allow old bright pixel to decay - rgb_frame_buffer[col][row - 1]--; + rgb_frame_buffer[row - 1][col]--; // make this pixel bright - rgb_frame_buffer[col][row] = max_intensity; + rgb_frame_buffer[row][col] = max_intensity; } } } @@ -74,4 +73,5 @@ bool rgb_matrix_digital_rain(effect_params_t* params) { return false; } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_DIGITAL_RAIN) diff --git a/quantum/rgb_matrix_animations/dual_beacon_anim.h b/quantum/rgb_matrix_animations/dual_beacon_anim.h index dcb594029e..336a41b2ce 100644 --- a/quantum/rgb_matrix_animations/dual_beacon_anim.h +++ b/quantum/rgb_matrix_animations/dual_beacon_anim.h @@ -1,24 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_DUAL_BEACON +RGB_MATRIX_EFFECT(DUAL_BEACON) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_dual_beacon(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +static HSV DUAL_BEACON_math(HSV hsv, int8_t sin, int8_t cos, uint8_t i, uint8_t time) { + hsv.h += ((g_led_config.point[i].y - k_rgb_matrix_center.y) * cos + (g_led_config.point[i].x - k_rgb_matrix_center.x) * sin) / 128; + return hsv; +} - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - int8_t cos_value = cos8(time) - 128; - int8_t sin_value = sin8(time) - 128; - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.h = ((g_led_config.point[i].y - 32) * cos_value + (g_led_config.point[i].x - 112) * sin_value) / 128 + rgb_matrix_config.hue; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool DUAL_BEACON(effect_params_t* params) { + return effect_runner_sin_cos_i(params, &DUAL_BEACON_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_DUAL_BEACON diff --git a/quantum/rgb_matrix_animations/gradient_up_down_anim.h b/quantum/rgb_matrix_animations/gradient_up_down_anim.h index 7a6ed14219..12848ab4cc 100644 --- a/quantum/rgb_matrix_animations/gradient_up_down_anim.h +++ b/quantum/rgb_matrix_animations/gradient_up_down_anim.h @@ -1,22 +1,22 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN +RGB_MATRIX_EFFECT(GRADIENT_UP_DOWN) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_gradient_up_down(effect_params_t* params) { +bool GRADIENT_UP_DOWN(effect_params_t* params) { RGB_MATRIX_USE_LIMITS(led_min, led_max); - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; + HSV hsv = rgb_matrix_config.hsv; uint8_t scale = scale8(64, rgb_matrix_config.speed); for (uint8_t i = led_min; i < led_max; i++) { RGB_MATRIX_TEST_LED_FLAGS(); // The y range will be 0..64, map this to 0..4 // Relies on hue being 8-bit and wrapping - hsv.h = rgb_matrix_config.hue + scale * (g_led_config.point[i].y >> 4); + hsv.h = rgb_matrix_config.hsv.h + scale * (g_led_config.point[i].y >> 4); RGB rgb = hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } return led_max < DRIVER_LED_TOTAL; } + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN diff --git a/quantum/rgb_matrix_animations/jellybean_raindrops_anim.h b/quantum/rgb_matrix_animations/jellybean_raindrops_anim.h index 5ea971435e..bffa0a42d7 100644 --- a/quantum/rgb_matrix_animations/jellybean_raindrops_anim.h +++ b/quantum/rgb_matrix_animations/jellybean_raindrops_anim.h @@ -1,18 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS - -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; +RGB_MATRIX_EFFECT(JELLYBEAN_RAINDROPS) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS static void jellybean_raindrops_set_color(int i, effect_params_t* params) { if (!HAS_ANY_FLAGS(g_led_config.flags[i], params->flags)) return; - HSV hsv = { rand() & 0xFF , rand() & 0xFF, rgb_matrix_config.val }; + HSV hsv = { rand() & 0xFF , rand() & 0xFF, rgb_matrix_config.hsv.v }; RGB rgb = hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } -bool rgb_matrix_jellybean_raindrops(effect_params_t* params) { +bool JELLYBEAN_RAINDROPS(effect_params_t* params) { if (!params->init) { // Change one LED every tick, make sure speed is not 0 if (scale16by8(g_rgb_counters.tick, qadd8(rgb_matrix_config.speed, 16)) % 5 == 0) { @@ -28,4 +25,5 @@ bool rgb_matrix_jellybean_raindrops(effect_params_t* params) { return led_max < DRIVER_LED_TOTAL; } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS diff --git a/quantum/rgb_matrix_animations/rainbow_beacon_anim.h b/quantum/rgb_matrix_animations/rainbow_beacon_anim.h index d462880731..f53c819a9e 100644 --- a/quantum/rgb_matrix_animations/rainbow_beacon_anim.h +++ b/quantum/rgb_matrix_animations/rainbow_beacon_anim.h @@ -1,24 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON +RGB_MATRIX_EFFECT(RAINBOW_BEACON) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_rainbow_beacon(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +static HSV RAINBOW_BEACON_math(HSV hsv, int8_t sin, int8_t cos, uint8_t i, uint8_t time) { + hsv.h += ((g_led_config.point[i].y - k_rgb_matrix_center.y) * 2 * cos + (g_led_config.point[i].x - k_rgb_matrix_center.x) * 2 * sin) / 128; + return hsv; +} - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - int16_t cos_value = 2 * (cos8(time) - 128); - int16_t sin_value = 2 * (sin8(time) - 128); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.h = ((g_led_config.point[i].y - 32) * cos_value + (g_led_config.point[i].x - 112) * sin_value) / 128 + rgb_matrix_config.hue; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool RAINBOW_BEACON(effect_params_t* params) { + return effect_runner_sin_cos_i(params, &RAINBOW_BEACON_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_RAINBOW_BEACON diff --git a/quantum/rgb_matrix_animations/rainbow_moving_chevron_anim.h b/quantum/rgb_matrix_animations/rainbow_moving_chevron_anim.h index 3b7d9689f8..e78c55e8dd 100644 --- a/quantum/rgb_matrix_animations/rainbow_moving_chevron_anim.h +++ b/quantum/rgb_matrix_animations/rainbow_moving_chevron_anim.h @@ -1,22 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON +RGB_MATRIX_EFFECT(RAINBOW_MOVING_CHEVRON) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_rainbow_moving_chevron(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +static HSV RAINBOW_MOVING_CHEVRON_math(HSV hsv, uint8_t i, uint8_t time) { + hsv.h += abs8(g_led_config.point[i].y - k_rgb_matrix_center.y) + (g_led_config.point[i].x - time); + return hsv; +} - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.h = abs8(g_led_config.point[i].y - 32) + (g_led_config.point[i].x - time) + rgb_matrix_config.hue; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool RAINBOW_MOVING_CHEVRON(effect_params_t* params) { + return effect_runner_i(params, &RAINBOW_MOVING_CHEVRON_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON diff --git a/quantum/rgb_matrix_animations/rainbow_pinwheels_anim.h b/quantum/rgb_matrix_animations/rainbow_pinwheels_anim.h index e92f351765..8298fec468 100644 --- a/quantum/rgb_matrix_animations/rainbow_pinwheels_anim.h +++ b/quantum/rgb_matrix_animations/rainbow_pinwheels_anim.h @@ -1,24 +1,15 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS +RGB_MATRIX_EFFECT(PINWHEELS) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_rainbow_pinwheels(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +static HSV PINWHEELS_math(HSV hsv, int8_t sin, int8_t cos, uint8_t i, uint8_t time) { + hsv.h += ((g_led_config.point[i].y - k_rgb_matrix_center.y) * 3 * cos + (56 - abs8(g_led_config.point[i].x - k_rgb_matrix_center.x)) * 3 * sin) / 128; + return hsv; +} - HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val }; - uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); - int16_t cos_value = 3 * (cos8(time) - 128); - int16_t sin_value = 3 * (sin8(time) - 128); - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.h = ((g_led_config.point[i].y - 32) * cos_value + (56 - abs8(g_led_config.point[i].x - 112)) * sin_value) / 128 + rgb_matrix_config.hue; - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool PINWHEELS(effect_params_t* params) { + return effect_runner_sin_cos_i(params, &PINWHEELS_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS diff --git a/quantum/rgb_matrix_animations/raindrops_anim.h b/quantum/rgb_matrix_animations/raindrops_anim.h index 4ce1d65e57..a4fed51658 100644 --- a/quantum/rgb_matrix_animations/raindrops_anim.h +++ b/quantum/rgb_matrix_animations/raindrops_anim.h @@ -1,29 +1,25 @@ -#pragma once #ifndef DISABLE_RGB_MATRIX_RAINDROPS -#include "rgb_matrix_types.h" - -extern rgb_counters_t g_rgb_counters; -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; +RGB_MATRIX_EFFECT(RAINDROPS) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS static void raindrops_set_color(int i, effect_params_t* params) { if (!HAS_ANY_FLAGS(g_led_config.flags[i], params->flags)) return; - HSV hsv = { 0 , rgb_matrix_config.sat, rgb_matrix_config.val }; + HSV hsv = { 0 , rgb_matrix_config.hsv.s, rgb_matrix_config.hsv.v }; // Take the shortest path between hues - int16_t deltaH = ((rgb_matrix_config.hue + 180) % 360 - rgb_matrix_config.hue) / 4; + int16_t deltaH = ((rgb_matrix_config.hsv.h + 180) % 360 - rgb_matrix_config.hsv.h) / 4; if (deltaH > 127) { deltaH -= 256; } else if (deltaH < -127) { deltaH += 256; } - hsv.h = rgb_matrix_config.hue + (deltaH * (rand() & 0x03)); + hsv.h = rgb_matrix_config.hsv.h + (deltaH * (rand() & 0x03)); RGB rgb = hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } -bool rgb_matrix_raindrops(effect_params_t* params) { +bool RAINDROPS(effect_params_t* params) { if (!params->init) { // Change one LED every tick, make sure speed is not 0 if (scale16by8(g_rgb_counters.tick, qadd8(rgb_matrix_config.speed, 16)) % 10 == 0) { @@ -39,4 +35,5 @@ bool rgb_matrix_raindrops(effect_params_t* params) { return led_max < DRIVER_LED_TOTAL; } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_RAINDROPS diff --git a/quantum/rgb_matrix_animations/rgb_matrix_effects.inc b/quantum/rgb_matrix_animations/rgb_matrix_effects.inc new file mode 100644 index 0000000000..01332ed0dd --- /dev/null +++ b/quantum/rgb_matrix_animations/rgb_matrix_effects.inc @@ -0,0 +1,33 @@ +// Add your new core rgb matrix effect here, order determins enum order, requires "rgb_matrix_animations/ directory +#include "rgb_matrix_animations/solid_color_anim.h" +#include "rgb_matrix_animations/alpha_mods_anim.h" +#include "rgb_matrix_animations/gradient_up_down_anim.h" +#include "rgb_matrix_animations/breathing_anim.h" +#include "rgb_matrix_animations/colorband_sat_anim.h" +#include "rgb_matrix_animations/colorband_val_anim.h" +#include "rgb_matrix_animations/colorband_pinwheel_sat_anim.h" +#include "rgb_matrix_animations/colorband_pinwheel_val_anim.h" +#include "rgb_matrix_animations/colorband_spiral_sat_anim.h" +#include "rgb_matrix_animations/colorband_spiral_val_anim.h" +#include "rgb_matrix_animations/cycle_all_anim.h" +#include "rgb_matrix_animations/cycle_left_right_anim.h" +#include "rgb_matrix_animations/cycle_up_down_anim.h" +#include "rgb_matrix_animations/rainbow_moving_chevron_anim.h" +#include "rgb_matrix_animations/cycle_out_in_anim.h" +#include "rgb_matrix_animations/cycle_out_in_dual_anim.h" +#include "rgb_matrix_animations/cycle_pinwheel_anim.h" +#include "rgb_matrix_animations/cycle_spiral_anim.h" +#include "rgb_matrix_animations/dual_beacon_anim.h" +#include "rgb_matrix_animations/rainbow_beacon_anim.h" +#include "rgb_matrix_animations/rainbow_pinwheels_anim.h" +#include "rgb_matrix_animations/raindrops_anim.h" +#include "rgb_matrix_animations/jellybean_raindrops_anim.h" +#include "rgb_matrix_animations/typing_heatmap_anim.h" +#include "rgb_matrix_animations/digital_rain_anim.h" +#include "rgb_matrix_animations/solid_reactive_simple_anim.h" +#include "rgb_matrix_animations/solid_reactive_anim.h" +#include "rgb_matrix_animations/solid_reactive_wide.h" +#include "rgb_matrix_animations/solid_reactive_cross.h" +#include "rgb_matrix_animations/solid_reactive_nexus.h" +#include "rgb_matrix_animations/splash_anim.h" +#include "rgb_matrix_animations/solid_splash_anim.h" diff --git a/quantum/rgb_matrix_animations/solid_color_anim.h b/quantum/rgb_matrix_animations/solid_color_anim.h index ba2cea15e3..6e40638035 100644 --- a/quantum/rgb_matrix_animations/solid_color_anim.h +++ b/quantum/rgb_matrix_animations/solid_color_anim.h @@ -1,16 +1,15 @@ -#pragma once +RGB_MATRIX_EFFECT(SOLID_COLOR) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; - -bool rgb_matrix_solid_color(effect_params_t* params) { +bool SOLID_COLOR(effect_params_t* params) { RGB_MATRIX_USE_LIMITS(led_min, led_max); - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val }; - RGB rgb = hsv_to_rgb(hsv); + RGB rgb = hsv_to_rgb(rgb_matrix_config.hsv); for (uint8_t i = led_min; i < led_max; i++) { RGB_MATRIX_TEST_LED_FLAGS(); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } return led_max < DRIVER_LED_TOTAL; } + +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS diff --git a/quantum/rgb_matrix_animations/solid_reactive_anim.h b/quantum/rgb_matrix_animations/solid_reactive_anim.h index c3dba8a5af..dd49b6530e 100644 --- a/quantum/rgb_matrix_animations/solid_reactive_anim.h +++ b/quantum/rgb_matrix_animations/solid_reactive_anim.h @@ -1,36 +1,17 @@ -#pragma once -#if defined(RGB_MATRIX_KEYREACTIVE_ENABLED) +#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE +RGB_MATRIX_EFFECT(SOLID_REACTIVE) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; - -bool rgb_matrix_solid_reactive(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); - - HSV hsv = { rgb_matrix_config.hue, 255, rgb_matrix_config.val }; - // Max tick based on speed scale ensures results from scale16by8 with rgb_matrix_config.speed are no greater than 255 - uint16_t max_tick = 65535 / rgb_matrix_config.speed; - // Relies on hue being 8-bit and wrapping - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - uint16_t tick = max_tick; - // Reverse search to find most recent key hit - for (int8_t j = g_last_hit_tracker.count - 1; j >= 0; j--) { - if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) { - tick = g_last_hit_tracker.tick[j]; - break; - } - } +static HSV SOLID_REACTIVE_math(HSV hsv, uint16_t offset) { + hsv.h += qsub8(130, offset); + return hsv; +} - uint16_t offset = scale16by8(tick, rgb_matrix_config.speed); - hsv.h = rgb_matrix_config.hue + qsub8(130, offset); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool SOLID_REACTIVE(effect_params_t* params) { + return effect_runner_reactive(params, &SOLID_REACTIVE_math); } -#endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON -#endif // defined(RGB_MATRIX_KEYREACTIVE_ENABLED) +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS +#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE +#endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/solid_reactive_cross.h b/quantum/rgb_matrix_animations/solid_reactive_cross.h index 8858f71e60..5b9cfcbd52 100644 --- a/quantum/rgb_matrix_animations/solid_reactive_cross.h +++ b/quantum/rgb_matrix_animations/solid_reactive_cross.h @@ -1,50 +1,41 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS) -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS +RGB_MATRIX_EFFECT(SOLID_REACTIVE_CROSS) +#endif -static bool rgb_matrix_solid_reactive_multicross_range(uint8_t start, effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS +RGB_MATRIX_EFFECT(SOLID_REACTIVE_MULTICROSS) +#endif - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 }; - uint8_t count = g_last_hit_tracker.count; - for (uint8_t i = led_min; i < led_max; i++) { - hsv.v = 0; - for (uint8_t j = start; j < count; j++) { - RGB_MATRIX_TEST_LED_FLAGS(); - int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; - int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; - uint8_t dist = sqrt16(dx * dx + dy * dy); - int16_t dist2 = 16; - uint8_t dist3; - uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) + dist; - dx = dx < 0 ? dx * -1 : dx; - dy = dy < 0 ? dy * -1 : dy; - dx = dx * dist2 > 255 ? 255 : dx * dist2; - dy = dy * dist2 > 255 ? 255 : dy * dist2; - dist3 = dx > dy ? dy : dx; - effect += dist3; - if (effect > 255) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV SOLID_REACTIVE_CROSS_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) { + uint16_t effect = tick + dist; + dx = dx < 0 ? dx * -1 : dx; + dy = dy < 0 ? dy * -1 : dy; + dx = dx * 16 > 255 ? 255 : dx * 16; + dy = dy * 16 > 255 ? 255 : dy * 16; + effect += dx > dy ? dy : dx; + if (effect > 255) effect = 255; - hsv.v = qadd8(hsv.v, 255 - effect); - } - hsv.v = scale8(hsv.v, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + hsv.v = qadd8(hsv.v, 255 - effect); + return hsv; } -bool rgb_matrix_solid_reactive_multicross(effect_params_t* params) { - return rgb_matrix_solid_reactive_multicross_range(0, params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS +bool SOLID_REACTIVE_CROSS(effect_params_t* params) { + return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_CROSS_math); } +#endif -bool rgb_matrix_solid_reactive_cross(effect_params_t* params) { - return rgb_matrix_solid_reactive_multicross_range(qsub8(g_last_hit_tracker.count, 1), params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS +bool SOLID_REACTIVE_MULTICROSS(effect_params_t* params) { + return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_CROSS_math); } +#endif +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS) #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/solid_reactive_nexus.h b/quantum/rgb_matrix_animations/solid_reactive_nexus.h index c0e3c24507..e90eaf4b28 100644 --- a/quantum/rgb_matrix_animations/solid_reactive_nexus.h +++ b/quantum/rgb_matrix_animations/solid_reactive_nexus.h @@ -1,48 +1,41 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS) -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS +RGB_MATRIX_EFFECT(SOLID_REACTIVE_NEXUS) +#endif -static bool rgb_matrix_solid_reactive_multinexus_range(uint8_t start, effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS +RGB_MATRIX_EFFECT(SOLID_REACTIVE_MULTINEXUS) +#endif - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 }; - uint8_t count = g_last_hit_tracker.count; - for (uint8_t i = led_min; i < led_max; i++) { - hsv.v = 0; - for (uint8_t j = start; j < count; j++) { - RGB_MATRIX_TEST_LED_FLAGS(); - int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; - int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; - uint8_t dist = sqrt16(dx * dx + dy * dy); - int16_t dist2 = 8; - uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist; - if (effect > 255) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV SOLID_REACTIVE_NEXUS_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) { + uint16_t effect = tick - dist; + if (effect > 255) effect = 255; - if (dist > 72) + if (dist > 72) effect = 255; - if ((dx > dist2 || dx < -dist2) && (dy > dist2 || dy < -dist2)) + if ((dx > 8 || dx < -8) && (dy > 8 || dy < -8)) effect = 255; - hsv.v = qadd8(hsv.v, 255 - effect); - hsv.h = rgb_matrix_config.hue + dy / 4; - } - hsv.v = scale8(hsv.v, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + hsv.v = qadd8(hsv.v, 255 - effect); + hsv.h = rgb_matrix_config.hsv.h + dy / 4; + return hsv; } -bool rgb_matrix_solid_reactive_multinexus(effect_params_t* params) { - return rgb_matrix_solid_reactive_multinexus_range(0, params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS +bool SOLID_REACTIVE_NEXUS(effect_params_t* params) { + return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_NEXUS_math); } +#endif -bool rgb_matrix_solid_reactive_nexus(effect_params_t* params) { - return rgb_matrix_solid_reactive_multinexus_range(qsub8(g_last_hit_tracker.count, 1), params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS +bool SOLID_REACTIVE_MULTINEXUS(effect_params_t* params) { + return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_NEXUS_math); } +#endif +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS) #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/solid_reactive_simple_anim.h b/quantum/rgb_matrix_animations/solid_reactive_simple_anim.h index abc7e36a89..77c8ff6724 100644 --- a/quantum/rgb_matrix_animations/solid_reactive_simple_anim.h +++ b/quantum/rgb_matrix_animations/solid_reactive_simple_anim.h @@ -1,35 +1,17 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE +RGB_MATRIX_EFFECT(SOLID_REACTIVE_SIMPLE) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; - -bool rgb_matrix_solid_reactive_simple(effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); - - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 }; - // Max tick based on speed scale ensures results from scale16by8 with rgb_matrix_config.speed are no greater than 255 - uint16_t max_tick = 65535 / rgb_matrix_config.speed; - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - uint16_t tick = max_tick; - // Reverse search to find most recent key hit - for (int8_t j = g_last_hit_tracker.count - 1; j >= 0; j--) { - if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) { - tick = g_last_hit_tracker.tick[j]; - break; - } - } +static HSV SOLID_REACTIVE_SIMPLE_math(HSV hsv, uint16_t offset) { + hsv.v = scale8(255 - offset, hsv.v); + return hsv; +} - uint16_t offset = scale16by8(tick, rgb_matrix_config.speed); - hsv.v = scale8(255 - offset, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; +bool SOLID_REACTIVE_SIMPLE(effect_params_t* params) { + return effect_runner_reactive(params, &SOLID_REACTIVE_SIMPLE_math); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/solid_reactive_wide.h b/quantum/rgb_matrix_animations/solid_reactive_wide.h index 3d1d38e806..73779dfa74 100644 --- a/quantum/rgb_matrix_animations/solid_reactive_wide.h +++ b/quantum/rgb_matrix_animations/solid_reactive_wide.h @@ -1,42 +1,36 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #if !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE) -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE +RGB_MATRIX_EFFECT(SOLID_REACTIVE_WIDE) +#endif -static bool rgb_matrix_solid_reactive_multiwide_range(uint8_t start, effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE +RGB_MATRIX_EFFECT(SOLID_REACTIVE_MULTIWIDE) +#endif - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 }; - uint8_t count = g_last_hit_tracker.count; - for (uint8_t i = led_min; i < led_max; i++) { - hsv.v = 0; - for (uint8_t j = start; j < count; j++) { - RGB_MATRIX_TEST_LED_FLAGS(); - int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; - int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; - uint8_t dist = sqrt16(dx * dx + dy * dy); - uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) + dist * 5; - if (effect > 255) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +static HSV SOLID_REACTIVE_WIDE_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) { + uint16_t effect = tick + dist * 5; + if (effect > 255) effect = 255; - hsv.v = qadd8(hsv.v, 255 - effect); - } - hsv.v = scale8(hsv.v, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + hsv.v = qadd8(hsv.v, 255 - effect); + return hsv; } -bool rgb_matrix_solid_reactive_multiwide(effect_params_t* params) { - return rgb_matrix_solid_reactive_multiwide_range(0, params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE +bool SOLID_REACTIVE_WIDE(effect_params_t* params) { + return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_REACTIVE_WIDE_math); } +#endif -bool rgb_matrix_solid_reactive_wide(effect_params_t* params) { - return rgb_matrix_solid_reactive_multiwide_range(qsub8(g_last_hit_tracker.count, 1), params); +#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE +bool SOLID_REACTIVE_MULTIWIDE(effect_params_t* params) { + return effect_runner_reactive_splash(0, params, &SOLID_REACTIVE_WIDE_math); } +#endif +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE) || !defined(DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE) #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/solid_splash_anim.h b/quantum/rgb_matrix_animations/solid_splash_anim.h index 4e5565d0d3..441f35576b 100644 --- a/quantum/rgb_matrix_animations/solid_splash_anim.h +++ b/quantum/rgb_matrix_animations/solid_splash_anim.h @@ -1,42 +1,36 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #if !defined(DISABLE_RGB_MATRIX_SOLID_SPLASH) || !defined(DISABLE_RGB_MATRIX_SOLID_MULTISPLASH) -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; +#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH +RGB_MATRIX_EFFECT(SOLID_SPLASH) +#endif -static bool rgb_matrix_solid_multisplash_range(uint8_t start, effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH +RGB_MATRIX_EFFECT(SOLID_MULTISPLASH) +#endif - HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 }; - uint8_t count = g_last_hit_tracker.count; - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.v = 0; - for (uint8_t j = start; j < count; j++) { - int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; - int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; - uint8_t dist = sqrt16(dx * dx + dy * dy); - uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist; - if (effect > 255) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +HSV SOLID_SPLASH_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) { + uint16_t effect = tick - dist; + if (effect > 255) effect = 255; - hsv.v = qadd8(hsv.v, 255 - effect); - } - hsv.v = scale8(hsv.v, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + hsv.v = qadd8(hsv.v, 255 - effect); + return hsv; } -bool rgb_matrix_solid_multisplash(effect_params_t* params) { - return rgb_matrix_solid_multisplash_range(0, params); +#ifndef DISABLE_RGB_MATRIX_SOLID_SPLASH +bool SOLID_SPLASH(effect_params_t* params) { + return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SOLID_SPLASH_math); } +#endif -bool rgb_matrix_solid_splash(effect_params_t* params) { - return rgb_matrix_solid_multisplash_range(qsub8(g_last_hit_tracker.count, 1), params); +#ifndef DISABLE_RGB_MATRIX_SOLID_MULTISPLASH +bool SOLID_MULTISPLASH(effect_params_t* params) { + return effect_runner_reactive_splash(0, params, &SOLID_SPLASH_math); } +#endif +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // !defined(DISABLE_RGB_MATRIX_SPLASH) && !defined(DISABLE_RGB_MATRIX_MULTISPLASH) #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/splash_anim.h b/quantum/rgb_matrix_animations/splash_anim.h index fbe7761117..19ccb256e9 100644 --- a/quantum/rgb_matrix_animations/splash_anim.h +++ b/quantum/rgb_matrix_animations/splash_anim.h @@ -1,44 +1,37 @@ -#pragma once #ifdef RGB_MATRIX_KEYREACTIVE_ENABLED #if !defined(DISABLE_RGB_MATRIX_SPLASH) || !defined(DISABLE_RGB_MATRIX_MULTISPLASH) -extern led_config_t g_led_config; -extern rgb_config_t rgb_matrix_config; -extern last_hit_t g_last_hit_tracker; +#ifndef DISABLE_RGB_MATRIX_SPLASH +RGB_MATRIX_EFFECT(SPLASH) +#endif -static bool rgb_matrix_multisplash_range(uint8_t start, effect_params_t* params) { - RGB_MATRIX_USE_LIMITS(led_min, led_max); +#ifndef DISABLE_RGB_MATRIX_MULTISPLASH +RGB_MATRIX_EFFECT(MULTISPLASH) +#endif - HSV hsv = { 0, rgb_matrix_config.sat, 0 }; - uint8_t count = g_last_hit_tracker.count; - for (uint8_t i = led_min; i < led_max; i++) { - RGB_MATRIX_TEST_LED_FLAGS(); - hsv.h = rgb_matrix_config.hue; - hsv.v = 0; - for (uint8_t j = start; j < count; j++) { - int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; - int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; - uint8_t dist = sqrt16(dx * dx + dy * dy); - uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist; - if (effect > 255) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS + +HSV SPLASH_math(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick) { + uint16_t effect = tick - dist; + if (effect > 255) effect = 255; - hsv.h += effect; - hsv.v = qadd8(hsv.v, 255 - effect); - } - hsv.v = scale8(hsv.v, rgb_matrix_config.val); - RGB rgb = hsv_to_rgb(hsv); - rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); - } - return led_max < DRIVER_LED_TOTAL; + hsv.h += effect; + hsv.v = qadd8(hsv.v, 255 - effect); + return hsv; } -bool rgb_matrix_multisplash(effect_params_t* params) { - return rgb_matrix_multisplash_range(0, params); +#ifndef DISABLE_RGB_MATRIX_SPLASH +bool SPLASH(effect_params_t* params) { + return effect_runner_reactive_splash(qsub8(g_last_hit_tracker.count, 1), params, &SPLASH_math); } +#endif -bool rgb_matrix_splash(effect_params_t* params) { - return rgb_matrix_multisplash_range(qsub8(g_last_hit_tracker.count, 1), params); +#ifndef DISABLE_RGB_MATRIX_MULTISPLASH +bool MULTISPLASH(effect_params_t* params) { + return effect_runner_reactive_splash(0, params, &SPLASH_math); } +#endif +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // !defined(DISABLE_RGB_MATRIX_SPLASH) || !defined(DISABLE_RGB_MATRIX_MULTISPLASH) #endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_animations/typing_heatmap_anim.h b/quantum/rgb_matrix_animations/typing_heatmap_anim.h index aade53fccc..374b7fea0c 100644 --- a/quantum/rgb_matrix_animations/typing_heatmap_anim.h +++ b/quantum/rgb_matrix_animations/typing_heatmap_anim.h @@ -1,8 +1,6 @@ -#pragma once #if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP) - -extern rgb_config_t rgb_matrix_config; -extern uint8_t rgb_frame_buffer[MATRIX_ROWS][MATRIX_COLS]; +RGB_MATRIX_EFFECT(TYPING_HEATMAP) +#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS void process_rgb_matrix_typing_heatmap(keyrecord_t *record) { uint8_t row = record->event.key.row; @@ -35,7 +33,7 @@ void process_rgb_matrix_typing_heatmap(keyrecord_t *record) { } } -bool rgb_matrix_typing_heatmap(effect_params_t* params) { +bool TYPING_HEATMAP(effect_params_t* params) { // Modified version of RGB_MATRIX_USE_LIMITS to work off of matrix row / col size uint8_t led_min = RGB_MATRIX_LED_PROCESS_LIMIT * params->iter; uint8_t led_max = led_min + RGB_MATRIX_LED_PROCESS_LIMIT; @@ -61,7 +59,7 @@ bool rgb_matrix_typing_heatmap(effect_params_t* params) { if (!HAS_ANY_FLAGS(g_led_config.flags[led[j]], params->flags)) continue; - HSV hsv = { 170 - qsub8(val, 85), rgb_matrix_config.sat, scale8((qadd8(170, val) - 170) * 3, rgb_matrix_config.val) }; + HSV hsv = { 170 - qsub8(val, 85), rgb_matrix_config.hsv.s, scale8((qadd8(170, val) - 170) * 3, rgb_matrix_config.hsv.v) }; RGB rgb = hsv_to_rgb(hsv); rgb_matrix_set_color(led[j], rgb.r, rgb.g, rgb.b); } @@ -72,4 +70,5 @@ bool rgb_matrix_typing_heatmap(effect_params_t* params) { return led_max < sizeof(rgb_frame_buffer); } +#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS #endif // defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS) && !defined(DISABLE_RGB_MATRIX_TYPING_HEATMAP) diff --git a/quantum/rgb_matrix_drivers.c b/quantum/rgb_matrix_drivers.c index 1d64dc9093..2a3aa9a5e0 100644 --- a/quantum/rgb_matrix_drivers.c +++ b/quantum/rgb_matrix_drivers.c @@ -34,7 +34,7 @@ static void init( void ) IS31FL3731_init( DRIVER_ADDR_1 ); IS31FL3731_init( DRIVER_ADDR_2 ); #elif defined(IS31FL3733) - IS31FL3733_init( DRIVER_ADDR_1 ); + IS31FL3733_init( DRIVER_ADDR_1, 0 ); #else IS31FL3737_init( DRIVER_ADDR_1 ); #endif @@ -53,7 +53,8 @@ static void init( void ) #ifdef IS31FL3731 IS31FL3731_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 ); #elif defined(IS31FL3733) - IS31FL3733_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 ); + IS31FL3733_update_led_control_registers( DRIVER_ADDR_1, 0 ); + IS31FL3733_update_led_control_registers( DRIVER_ADDR_2, 1 ); #else IS31FL3737_update_led_control_registers( DRIVER_ADDR_1, DRIVER_ADDR_2 ); #endif @@ -74,7 +75,8 @@ const rgb_matrix_driver_t rgb_matrix_driver = { #elif defined(IS31FL3733) static void flush( void ) { - IS31FL3733_update_pwm_buffers( DRIVER_ADDR_1, DRIVER_ADDR_2 ); + IS31FL3733_update_pwm_buffers( DRIVER_ADDR_1, 0); + IS31FL3733_update_pwm_buffers( DRIVER_ADDR_2, 1); } const rgb_matrix_driver_t rgb_matrix_driver = { diff --git a/quantum/rgb_matrix_runners/effect_runner_dx_dy.h b/quantum/rgb_matrix_runners/effect_runner_dx_dy.h new file mode 100644 index 0000000000..9650c9a131 --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_dx_dy.h @@ -0,0 +1,17 @@ +#pragma once + +typedef HSV (*dx_dy_f)(HSV hsv, int16_t dx, int16_t dy, uint8_t time); + +bool effect_runner_dx_dy(effect_params_t* params, dx_dy_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 2); + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + int16_t dx = g_led_config.point[i].x - k_rgb_matrix_center.x; + int16_t dy = g_led_config.point[i].y - k_rgb_matrix_center.y; + RGB rgb = hsv_to_rgb(effect_func(rgb_matrix_config.hsv, dx, dy, time)); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} diff --git a/quantum/rgb_matrix_runners/effect_runner_dx_dy_dist.h b/quantum/rgb_matrix_runners/effect_runner_dx_dy_dist.h new file mode 100644 index 0000000000..eb0c4d8dd3 --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_dx_dy_dist.h @@ -0,0 +1,18 @@ +#pragma once + +typedef HSV (*dx_dy_dist_f)(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint8_t time); + +bool effect_runner_dx_dy_dist(effect_params_t* params, dx_dy_dist_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 2); + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + int16_t dx = g_led_config.point[i].x - k_rgb_matrix_center.x; + int16_t dy = g_led_config.point[i].y - k_rgb_matrix_center.y; + uint8_t dist = sqrt16(dx * dx + dy * dy); + RGB rgb = hsv_to_rgb(effect_func(rgb_matrix_config.hsv, dx, dy, dist, time)); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} diff --git a/quantum/rgb_matrix_runners/effect_runner_i.h b/quantum/rgb_matrix_runners/effect_runner_i.h new file mode 100644 index 0000000000..d4a7ef392a --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_i.h @@ -0,0 +1,15 @@ +#pragma once + +typedef HSV (*i_f)(HSV hsv, uint8_t i, uint8_t time); + +bool effect_runner_i(effect_params_t* params, i_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + RGB rgb = hsv_to_rgb(effect_func(rgb_matrix_config.hsv, i, time)); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} diff --git a/quantum/rgb_matrix_runners/effect_runner_reactive.h b/quantum/rgb_matrix_runners/effect_runner_reactive.h new file mode 100644 index 0000000000..9da2814ce8 --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_reactive.h @@ -0,0 +1,29 @@ +#pragma once + +#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED + +typedef HSV (*reactive_f)(HSV hsv, uint16_t offset); + +bool effect_runner_reactive(effect_params_t* params, reactive_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint16_t max_tick = 65535 / rgb_matrix_config.speed; + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + uint16_t tick = max_tick; + // Reverse search to find most recent key hit + for (int8_t j = g_last_hit_tracker.count - 1; j >= 0; j--) { + if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) { + tick = g_last_hit_tracker.tick[j]; + break; + } + } + + uint16_t offset = scale16by8(tick, rgb_matrix_config.speed); + RGB rgb = hsv_to_rgb(effect_func(rgb_matrix_config.hsv, offset)); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} + +#endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_runners/effect_runner_reactive_splash.h b/quantum/rgb_matrix_runners/effect_runner_reactive_splash.h new file mode 100644 index 0000000000..4f2059c99c --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_reactive_splash.h @@ -0,0 +1,29 @@ +#pragma once + +#ifdef RGB_MATRIX_KEYREACTIVE_ENABLED + +typedef HSV (*reactive_splash_f)(HSV hsv, int16_t dx, int16_t dy, uint8_t dist, uint16_t tick); + +bool effect_runner_reactive_splash(uint8_t start, effect_params_t* params, reactive_splash_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint8_t count = g_last_hit_tracker.count; + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + HSV hsv = rgb_matrix_config.hsv; + hsv.v = 0; + for (uint8_t j = start; j < count; j++) { + int16_t dx = g_led_config.point[i].x - g_last_hit_tracker.x[j]; + int16_t dy = g_led_config.point[i].y - g_last_hit_tracker.y[j]; + uint8_t dist = sqrt16(dx * dx + dy * dy); + uint16_t tick = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed); + hsv = effect_func(hsv, dx, dy, dist, tick); + } + hsv.v = scale8(hsv.v, rgb_matrix_config.hsv.v); + RGB rgb = hsv_to_rgb(hsv); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} + +#endif // RGB_MATRIX_KEYREACTIVE_ENABLED diff --git a/quantum/rgb_matrix_runners/effect_runner_sin_cos_i.h b/quantum/rgb_matrix_runners/effect_runner_sin_cos_i.h new file mode 100644 index 0000000000..e68a7a968c --- /dev/null +++ b/quantum/rgb_matrix_runners/effect_runner_sin_cos_i.h @@ -0,0 +1,17 @@ +#pragma once + +typedef HSV (*sin_cos_i_f)(HSV hsv, int8_t sin, int8_t cos, uint8_t i, uint8_t time); + +bool effect_runner_sin_cos_i(effect_params_t* params, sin_cos_i_f effect_func) { + RGB_MATRIX_USE_LIMITS(led_min, led_max); + + uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4); + int8_t cos_value = cos8(time) - 128; + int8_t sin_value = sin8(time) - 128; + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); + RGB rgb = hsv_to_rgb(effect_func(rgb_matrix_config.hsv, cos_value, sin_value, i, time)); + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + return led_max < DRIVER_LED_TOTAL; +} diff --git a/quantum/rgb_matrix_types.h b/quantum/rgb_matrix_types.h index f890edd94f..04a84f4ac7 100644 --- a/quantum/rgb_matrix_types.h +++ b/quantum/rgb_matrix_types.h @@ -2,6 +2,7 @@ #include <stdint.h> #include <stdbool.h> +#include "color.h" #if defined(__GNUC__) #define PACKED __attribute__ ((__packed__)) @@ -81,10 +82,8 @@ typedef union { struct PACKED { uint8_t enable :2; uint8_t mode :6; - uint8_t hue :8; - uint8_t sat :8; - uint8_t val :8; - uint8_t speed :8;//EECONFIG needs to be increased to support this + HSV hsv; + uint8_t speed; //EECONFIG needs to be increased to support this }; } rgb_config_t; diff --git a/quantum/rgblight.c b/quantum/rgblight.c index 77772e2925..75e4ef0d86 100644 --- a/quantum/rgblight.c +++ b/quantum/rgblight.c @@ -101,19 +101,35 @@ LED_TYPE led[RGBLED_NUM]; static uint8_t clipping_start_pos = 0; static uint8_t clipping_num_leds = RGBLED_NUM; +static uint8_t effect_start_pos = 0; +static uint8_t effect_end_pos = RGBLED_NUM; +static uint8_t effect_num_leds = RGBLED_NUM; void rgblight_set_clipping_range(uint8_t start_pos, uint8_t num_leds) { clipping_start_pos = start_pos; clipping_num_leds = num_leds; } +void rgblight_set_effect_range(uint8_t start_pos, uint8_t num_leds) { + if (start_pos >= RGBLED_NUM) return; + if (start_pos + num_leds > RGBLED_NUM) return; + effect_start_pos = start_pos; + effect_end_pos = start_pos + num_leds; + effect_num_leds = num_leds; +} -void sethsv(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) { - HSV hsv = { hue, sat, val > RGBLIGHT_LIMIT_VAL ? RGBLIGHT_LIMIT_VAL : val }; +void sethsv_raw(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) { + HSV hsv = { hue, sat, val }; RGB rgb = hsv_to_rgb(hsv); setrgb(rgb.r, rgb.g, rgb.b, led1); } +void sethsv(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) { + sethsv_raw( hue, sat, + val > RGBLIGHT_LIMIT_VAL ? RGBLIGHT_LIMIT_VAL : val, + led1); +} + void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1) { (*led1).r = r; (*led1).g = g; @@ -501,15 +517,15 @@ void rgblight_sethsv_eeprom_helper(uint8_t hue, uint8_t sat, uint8_t val, bool w #else uint8_t range = RGBLED_GRADIENT_RANGES[delta / 2]; #endif - for (uint8_t i = 0; i < RGBLED_NUM; i++) { - uint8_t _hue = ((uint16_t)i * (uint16_t)range) / RGBLED_NUM; + for (uint8_t i = 0; i < effect_num_leds; i++) { + uint8_t _hue = ((uint16_t)i * (uint16_t)range) / effect_num_leds; if (direction) { _hue = hue + _hue; } else { _hue = hue - _hue; } dprintf("rgblight rainbow set hsv: %d,%d,%d,%u\n", i, _hue, direction, range); - sethsv(_hue, sat, val, (LED_TYPE *)&led[i]); + sethsv(_hue, sat, val, (LED_TYPE *)&led[i + effect_start_pos]); } rgblight_set(); } @@ -557,7 +573,7 @@ uint8_t rgblight_get_val(void) { void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b) { if (!rgblight_config.enable) { return; } - for (uint8_t i = 0; i < RGBLED_NUM; i++) { + for (uint8_t i = effect_start_pos; i < effect_end_pos; i++) { led[i].r = r; led[i].g = g; led[i].b = b; @@ -615,6 +631,7 @@ void rgblight_sethsv_range(uint8_t hue, uint8_t sat, uint8_t val, uint8_t start, rgblight_setrgb_range(tmp_led.r, tmp_led.g, tmp_led.b, start, end); } +#ifndef RGBLIGHT_SPLIT void rgblight_setrgb_master(uint8_t r, uint8_t g, uint8_t b) { rgblight_setrgb_range(r, g, b, 0 , (uint8_t) RGBLED_NUM/2); } @@ -630,36 +647,34 @@ void rgblight_sethsv_master(uint8_t hue, uint8_t sat, uint8_t val) { void rgblight_sethsv_slave(uint8_t hue, uint8_t sat, uint8_t val) { rgblight_sethsv_range(hue, sat, val, (uint8_t) RGBLED_NUM/2, (uint8_t) RGBLED_NUM); } +#endif // ifndef RGBLIGHT_SPLIT #ifndef RGBLIGHT_CUSTOM_DRIVER void rgblight_set(void) { - LED_TYPE *start_led = led + clipping_start_pos; + LED_TYPE *start_led; uint16_t num_leds = clipping_num_leds; - if (rgblight_config.enable) { - #ifdef RGBLIGHT_LED_MAP - LED_TYPE led0[RGBLED_NUM]; - for(uint8_t i = 0; i < RGBLED_NUM; i++) { - led0[i] = led[pgm_read_byte(&led_map[i])]; - } - start_led = led0 + clipping_start_pos; - #endif - #ifdef RGBW - ws2812_setleds_rgbw(start_led, num_leds); - #else - ws2812_setleds(start_led, num_leds); - #endif - } else { - for (uint8_t i = 0; i < RGBLED_NUM; i++) { + + if (!rgblight_config.enable) { + for (uint8_t i = effect_start_pos; i < effect_end_pos; i++) { led[i].r = 0; led[i].g = 0; led[i].b = 0; } - #ifdef RGBW - ws2812_setleds_rgbw(start_led, num_leds); - #else - ws2812_setleds(start_led, num_leds); - #endif } +#ifdef RGBLIGHT_LED_MAP + LED_TYPE led0[RGBLED_NUM]; + for(uint8_t i = 0; i < RGBLED_NUM; i++) { + led0[i] = led[pgm_read_byte(&led_map[i])]; + } + start_led = led0 + clipping_start_pos; +#else + start_led = led + clipping_start_pos; +#endif +#ifdef RGBW + ws2812_setleds_rgbw(start_led, num_leds); +#else + ws2812_setleds(start_led, num_leds); +#endif } #endif @@ -926,9 +941,9 @@ void rgblight_effect_rainbow_swirl(animation_status_t *anim) { uint8_t hue; uint8_t i; - for (i = 0; i < RGBLED_NUM; i++) { - hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / RGBLED_NUM * i + anim->current_hue); - sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); + for (i = 0; i < effect_num_leds; i++) { + hue = (RGBLIGHT_RAINBOW_SWIRL_RANGE / effect_num_leds * i + anim->current_hue); + sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i + effect_start_pos]); } rgblight_set(); @@ -957,7 +972,7 @@ void rgblight_effect_snake(animation_status_t *anim) { #if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC) if (anim->pos == 0) { // restart signal if (increment == 1) { - pos = RGBLED_NUM - 1; + pos = effect_num_leds - 1; } else { pos = 0; } @@ -965,26 +980,27 @@ void rgblight_effect_snake(animation_status_t *anim) { } #endif - for (i = 0; i < RGBLED_NUM; i++) { - led[i].r = 0; - led[i].g = 0; - led[i].b = 0; + for (i = 0; i < effect_num_leds; i++) { + LED_TYPE *ledp = led + i + effect_start_pos; + ledp->r = 0; + ledp->g = 0; + ledp->b = 0; for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) { k = pos + j * increment; if (k < 0) { - k = k + RGBLED_NUM; + k = k + effect_num_leds; } if (i == k) { sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), - (LED_TYPE *)&led[i]); + ledp); } } } rgblight_set(); if (increment == 1) { if (pos - 1 < 0) { - pos = RGBLED_NUM - 1; + pos = effect_num_leds - 1; #if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC) anim->pos = 0; #endif @@ -995,7 +1011,7 @@ void rgblight_effect_snake(animation_status_t *anim) { #endif } } else { - pos = (pos + 1) % RGBLED_NUM; + pos = (pos + 1) % effect_num_leds; #if defined(RGBLIGHT_SPLIT) && !defined(RGBLIGHT_SPLIT_NO_ANIMATION_SYNC) anim->pos = pos; #endif @@ -1023,14 +1039,14 @@ void rgblight_effect_knight(animation_status_t *anim) { } #endif // Set all the LEDs to 0 - for (i = 0; i < RGBLED_NUM; i++) { + for (i = effect_start_pos; i < effect_end_pos; i++) { led[i].r = 0; led[i].g = 0; led[i].b = 0; } // Determine which LEDs should be lit up for (i = 0; i < RGBLIGHT_EFFECT_KNIGHT_LED_NUM; i++) { - cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % RGBLED_NUM; + cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % effect_num_leds + effect_start_pos; if (i >= low_bound && i <= high_bound) { sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[cur]); @@ -1064,9 +1080,9 @@ void rgblight_effect_christmas(animation_status_t *anim) { uint8_t i; anim->current_offset = (anim->current_offset + 1) % 2; - for (i = 0; i < RGBLED_NUM; i++) { + for (i = 0; i < effect_num_leds; i++) { hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + anim->current_offset) % 2) * 85; - sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); + sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i + effect_start_pos]); } rgblight_set(); } @@ -1099,13 +1115,14 @@ void rgblight_effect_rgbtest(animation_status_t *anim) { #ifdef RGBLIGHT_EFFECT_ALTERNATING void rgblight_effect_alternating(animation_status_t *anim) { - for(int i = 0; i<RGBLED_NUM; i++){ - if(i<RGBLED_NUM/2 && anim->pos){ - sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); - }else if (i>=RGBLED_NUM/2 && !anim->pos){ - sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]); - }else{ - sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]); + for (int i = 0; i < effect_num_leds; i++) { + LED_TYPE *ledp = led + i + effect_start_pos; + if (i<effect_num_leds/2 && anim->pos) { + sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, ledp); + } else if (i>=effect_num_leds/2 && !anim->pos) { + sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, ledp); + } else { + sethsv(rgblight_config.hue, rgblight_config.sat, 0, ledp); } } rgblight_set(); diff --git a/quantum/rgblight.h b/quantum/rgblight.h index 35d7942ca6..cba18ae729 100644 --- a/quantum/rgblight.h +++ b/quantum/rgblight.h @@ -99,7 +99,7 @@ enum RGBLIGHT_EFFECT_MODE { #endif #ifndef RGBLIGHT_EFFECT_KNIGHT_LED_NUM -#define RGBLIGHT_EFFECT_KNIGHT_LED_NUM RGBLED_NUM +#define RGBLIGHT_EFFECT_KNIGHT_LED_NUM (effect_num_leds) #endif #ifndef RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL @@ -132,7 +132,7 @@ enum RGBLIGHT_EFFECT_MODE { #ifndef RGBLIGHT_CUSTOM_DRIVER #include "ws2812.h" #endif -#include "rgblight_types.h" +#include "color.h" #include "rgblight_list.h" #if defined(__AVR__) @@ -170,61 +170,79 @@ typedef struct _rgblight_status_t { #endif } rgblight_status_t; -#ifdef RGBLIGHT_SPLIT - #define RGBLIGHT_STATUS_CHANGE_MODE (1<<0) - #define RGBLIGHT_STATUS_CHANGE_HSVS (1<<1) - #define RGBLIGHT_STATUS_CHANGE_TIMER (1<<2) - #define RGBLIGHT_STATUS_ANIMATION_TICK (1<<3) +/* === Utility Functions ===*/ +void sethsv(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1); +void sethsv_raw(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1); // without RGBLIGHT_LIMIT_VAL check +void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1); - typedef struct _rgblight_syncinfo_t { - rgblight_config_t config; - rgblight_status_t status; - } rgblight_syncinfo_t; +/* === Low level Functions === */ +void rgblight_set(void); +void rgblight_set_clipping_range(uint8_t start_pos, uint8_t num_leds); - /* for split keyboard master side */ - uint8_t rgblight_get_change_flags(void); - void rgblight_clear_change_flags(void); - void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo); - /* for split keyboard slave side */ - void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom); +/* === Effects and Animations Functions === */ +/* effect range setting */ +void rgblight_set_effect_range(uint8_t start_pos, uint8_t num_leds); + +/* direct operation */ +void rgblight_setrgb_at(uint8_t r, uint8_t g, uint8_t b, uint8_t index); +void rgblight_sethsv_at(uint8_t hue, uint8_t sat, uint8_t val, uint8_t index); +void rgblight_setrgb_range(uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t end); +void rgblight_sethsv_range(uint8_t hue, uint8_t sat, uint8_t val, uint8_t start, uint8_t end); +void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b); + +#ifndef RGBLIGHT_SPLIT +void rgblight_setrgb_master(uint8_t r, uint8_t g, uint8_t b); +void rgblight_setrgb_slave(uint8_t r, uint8_t g, uint8_t b); +void rgblight_sethsv_master(uint8_t hue, uint8_t sat, uint8_t val); +void rgblight_sethsv_slave(uint8_t hue, uint8_t sat, uint8_t val); #endif -void rgblight_init(void); +/* effect mode change */ +void rgblight_mode(uint8_t mode); +void rgblight_mode_noeeprom(uint8_t mode); void rgblight_increase(void); void rgblight_decrease(void); +void rgblight_step(void); +void rgblight_step_noeeprom(void); +void rgblight_step_reverse(void); +void rgblight_step_reverse_noeeprom(void); + +/* effects mode disable/enable */ void rgblight_toggle(void); +void rgblight_toggle_noeeprom(void); void rgblight_enable(void); +void rgblight_enable_noeeprom(void); void rgblight_disable(void); -void rgblight_step(void); -void rgblight_step_reverse(void); -uint8_t rgblight_get_mode(void); -void rgblight_mode(uint8_t mode); -void rgblight_set(void); -uint32_t rgblight_read_dword(void); -void rgblight_update_dword(uint32_t dword); +void rgblight_disable_noeeprom(void); + +/* hue, sat, val change */ void rgblight_increase_hue(void); +void rgblight_increase_hue_noeeprom(void); void rgblight_decrease_hue(void); +void rgblight_decrease_hue_noeeprom(void); void rgblight_increase_sat(void); +void rgblight_increase_sat_noeeprom(void); void rgblight_decrease_sat(void); +void rgblight_decrease_sat_noeeprom(void); void rgblight_increase_val(void); +void rgblight_increase_val_noeeprom(void); void rgblight_decrease_val(void); +void rgblight_decrease_val_noeeprom(void); void rgblight_increase_speed(void); void rgblight_decrease_speed(void); void rgblight_sethsv(uint8_t hue, uint8_t sat, uint8_t val); +void rgblight_sethsv_noeeprom(uint8_t hue, uint8_t sat, uint8_t val); + +/* query */ +uint8_t rgblight_get_mode(void); uint8_t rgblight_get_hue(void); uint8_t rgblight_get_sat(void); uint8_t rgblight_get_val(void); -void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b); -void rgblight_setrgb_at(uint8_t r, uint8_t g, uint8_t b, uint8_t index); -void rgblight_sethsv_at(uint8_t hue, uint8_t sat, uint8_t val, uint8_t index); -void rgblight_setrgb_range(uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t end); -void rgblight_sethsv_range(uint8_t hue, uint8_t sat, uint8_t val, uint8_t start, uint8_t end); -void rgblight_setrgb_master(uint8_t r, uint8_t g, uint8_t b); -void rgblight_setrgb_slave(uint8_t r, uint8_t g, uint8_t b); -void rgblight_sethsv_master(uint8_t hue, uint8_t sat, uint8_t val); -void rgblight_sethsv_slave(uint8_t hue, uint8_t sat, uint8_t val); -void rgblight_set_clipping_range(uint8_t start_pos, uint8_t num_leds); +/* === qmk_firmware (core)internal Functions === */ +void rgblight_init(void); +uint32_t rgblight_read_dword(void); +void rgblight_update_dword(uint32_t dword); uint32_t eeconfig_read_rgblight(void); void eeconfig_update_rgblight(uint32_t val); void eeconfig_update_rgblight_default(void); @@ -233,27 +251,9 @@ void eeconfig_debug_rgblight(void); void rgb_matrix_increase(void); void rgb_matrix_decrease(void); -void sethsv(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1); -void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1); - -void rgblight_sethsv_noeeprom(uint8_t hue, uint8_t sat, uint8_t val); -void rgblight_mode_noeeprom(uint8_t mode); -void rgblight_toggle_noeeprom(void); -void rgblight_enable_noeeprom(void); -void rgblight_disable_noeeprom(void); -void rgblight_step_noeeprom(void); -void rgblight_step_reverse_noeeprom(void); -void rgblight_increase_hue_noeeprom(void); -void rgblight_decrease_hue_noeeprom(void); -void rgblight_increase_sat_noeeprom(void); -void rgblight_decrease_sat_noeeprom(void); -void rgblight_increase_val_noeeprom(void); -void rgblight_decrease_val_noeeprom(void); - void rgblight_sethsv_eeprom_helper(uint8_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom); void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom); - #define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF) void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b); @@ -264,6 +264,25 @@ void rgblight_timer_enable(void); void rgblight_timer_disable(void); void rgblight_timer_toggle(void); +#ifdef RGBLIGHT_SPLIT + #define RGBLIGHT_STATUS_CHANGE_MODE (1<<0) + #define RGBLIGHT_STATUS_CHANGE_HSVS (1<<1) + #define RGBLIGHT_STATUS_CHANGE_TIMER (1<<2) + #define RGBLIGHT_STATUS_ANIMATION_TICK (1<<3) + + typedef struct _rgblight_syncinfo_t { + rgblight_config_t config; + rgblight_status_t status; + } rgblight_syncinfo_t; + + /* for split keyboard master side */ + uint8_t rgblight_get_change_flags(void); + void rgblight_clear_change_flags(void); + void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo); + /* for split keyboard slave side */ + void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom); +#endif + #ifdef RGBLIGHT_USE_TIMER typedef struct _animation_status_t { diff --git a/quantum/rgblight_types.h b/quantum/rgblight_types.h deleted file mode 100644 index 49ef5c8ea7..0000000000 --- a/quantum/rgblight_types.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * light weight WS2812 lib include - * - * Version 2.3 - Nev 29th 2015 - * Author: Tim (cpldcpu@gmail.com) - * - * Please do not change this file! All configuration is handled in "ws2812_config.h" - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - */ - -#ifndef RGBLIGHT_TYPES -#define RGBLIGHT_TYPES - -#ifdef __AVR__ - #include <avr/io.h> -#endif - -#ifdef RGBW - #define LED_TYPE struct cRGBW -#else - #define LED_TYPE struct cRGB -#endif - - -/* - * Structure of the LED array - * - * cRGB: RGB for WS2812S/B/C/D, SK6812, SK6812Mini, SK6812WWA, APA104, APA106 - * cRGBW: RGBW for SK6812RGBW - */ - -struct cRGB { uint8_t g; uint8_t r; uint8_t b; }; -struct cRGBW { uint8_t g; uint8_t r; uint8_t b; uint8_t w;}; - -#endif diff --git a/quantum/split_common/post_config.h b/quantum/split_common/post_config.h index 0e59df3d06..ff0fc5e193 100644 --- a/quantum/split_common/post_config.h +++ b/quantum/split_common/post_config.h @@ -4,6 +4,10 @@ #define RGBLIGHT_SPLIT #endif + #ifndef F_SCL + #define F_SCL 100000UL // SCL frequency + #endif + #else // use serial // When using serial, the user must define RGBLIGHT_SPLIT explicitly // in config.h as needed. diff --git a/quantum/split_common/transport.c b/quantum/split_common/transport.c index a3539576f5..b32d48eb88 100644 --- a/quantum/split_common/transport.c +++ b/quantum/split_common/transport.c @@ -74,7 +74,7 @@ bool transport_master(matrix_row_t matrix[]) { # endif # ifdef ENCODER_ENABLE - i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)i2c_buffer->encoder_state, sizeof(I2C_slave_buffer_t.encoder_state), TIMEOUT); + i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)i2c_buffer->encoder_state, sizeof(i2c_buffer->encoder_state), TIMEOUT); encoder_update_raw(i2c_buffer->encoder_state); # endif diff --git a/quantum/template/avr/config.h b/quantum/template/avr/config.h index 48d7afb149..1e41a2d31d 100644 --- a/quantum/template/avr/config.h +++ b/quantum/template/avr/config.h @@ -1,5 +1,5 @@ /* -Copyright 2019 %YOUR_NAME% +Copyright %YEAR% %YOUR_NAME% This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -86,7 +86,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #endif /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ -#define DEBOUNCING_DELAY 5 +#define DEBOUNCE 5 /* define if matrix has ghost (lacks anti-ghosting diodes) */ //#define MATRIX_HAS_GHOST diff --git a/quantum/template/avr/template.c b/quantum/template/avr/template.c index 86dc69abce..e852a42c40 100644 --- a/quantum/template/avr/template.c +++ b/quantum/template/avr/template.c @@ -1,4 +1,4 @@ -/* Copyright 2019 %YOUR_NAME% +/* Copyright %YEAR% %YOUR_NAME% * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/quantum/template/base/keymaps/default/config.h b/quantum/template/base/keymaps/default/config.h index 44382016a1..5b00c8956f 100644 --- a/quantum/template/base/keymaps/default/config.h +++ b/quantum/template/base/keymaps/default/config.h @@ -1,4 +1,4 @@ -/* Copyright 2019 %YOUR_NAME% +/* Copyright %YEAR% %YOUR_NAME% * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/quantum/template/base/keymaps/default/keymap.c b/quantum/template/base/keymaps/default/keymap.c index 482a445448..0e9fad357f 100644 --- a/quantum/template/base/keymaps/default/keymap.c +++ b/quantum/template/base/keymaps/default/keymap.c @@ -1,4 +1,4 @@ -/* Copyright 2019 %YOUR_NAME% +/* Copyright %YEAR% %YOUR_NAME% * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/quantum/template/base/template.h b/quantum/template/base/template.h index 5b5076c476..2e531b1fd4 100644 --- a/quantum/template/base/template.h +++ b/quantum/template/base/template.h @@ -1,4 +1,4 @@ -/* Copyright 2019 %YOUR_NAME% +/* Copyright %YEAR% %YOUR_NAME% * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/quantum/template/ps2avrgb/config.h b/quantum/template/ps2avrgb/config.h index 8d9a993cf1..320d71fcbc 100644 --- a/quantum/template/ps2avrgb/config.h +++ b/quantum/template/ps2avrgb/config.h @@ -1,5 +1,5 @@ /* -Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com> +Copyright %YEAR% %YOUR_NAME% This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -37,7 +37,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define UNUSED_PINS {} #define DIODE_DIRECTION COL2ROW -#define DEBOUNCING_DELAY 5 +#define DEBOUNCE 5 #define NO_BACKLIGHT_CLOCK #define BACKLIGHT_LEVELS 1 diff --git a/quantum/template/ps2avrgb/rules.mk b/quantum/template/ps2avrgb/rules.mk index bd0eed0527..98a920e182 100644 --- a/quantum/template/ps2avrgb/rules.mk +++ b/quantum/template/ps2avrgb/rules.mk @@ -1,18 +1,3 @@ -# Copyright 2019 Luiz Ribeiro <luizribeiro@gmail.com> -# -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 2 of the License, or -# (at your option) any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program. If not, see <http://www.gnu.org/licenses/>. - # MCU name MCU = atmega32a PROTOCOL = VUSB diff --git a/quantum/template/ps2avrgb/template.c b/quantum/template/ps2avrgb/template.c index 3f920de48c..07f27bbb22 100644 --- a/quantum/template/ps2avrgb/template.c +++ b/quantum/template/ps2avrgb/template.c @@ -1,4 +1,4 @@ -/* Copyright 2019 %YOUR_NAME% +/* Copyright %YEAR% %YOUR_NAME% * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/quantum/template/ps2avrgb/usbconfig.h b/quantum/template/ps2avrgb/usbconfig.h index 54a7d20f14..465db3a134 100644 --- a/quantum/template/ps2avrgb/usbconfig.h +++ b/quantum/template/ps2avrgb/usbconfig.h @@ -1,13 +1,3 @@ -/* Name: usbconfig.h - * Project: V-USB, virtual USB port for Atmel's(r) AVR(r) microcontrollers - * Author: Christian Starkjohann - * Creation Date: 2005-04-01 - * Tabsize: 4 - * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH - * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) - * This Revision: $Id: usbconfig-prototype.h 785 2010-05-30 17:57:07Z cs $ - */ - #pragma once #include "config.h" |