Merge remote-tracking branch 'origin/master' into develop

This commit is contained in:
QMK Bot 2021-06-24 02:22:11 +00:00
commit b69fa51ec3
17 changed files with 1919 additions and 1 deletions

View File

@ -0,0 +1,55 @@
/*
This is the c configuration file for the keymap
Copyright 2012 Jun Wako <wakojun@gmail.com>
Copyright 2015 Jack Humbert
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/>.
*/
#pragma once
//#define USE_MATRIX_I2C
/* Select hand configuration */
#define MASTER_LEFT
// #define MASTER_RIGHT
// #define EE_HANDS
#define USE_SERIAL_PD2
#define TAPPING_FORCE_HOLD
#define TAPPING_TERM 200
#define IGNORE_MOD_TAP_INTERRUPT
#undef PERMISSIVE_HOLD
#ifdef RGBLIGHT_ENABLE
#undef RGBLED_NUM
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 27
#define RGBLIGHT_LIMIT_VAL 120
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17
#define RGBLIGHT_VAL_STEP 17
#endif
#define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c"
// fix for me putting alt under A and being a fast typist
#define IGNORE_MOD_TAP_INTERRUPT
//#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
#define LAYER_STATE_8BIT

View File

@ -0,0 +1,81 @@
/*
* Copyright 2020 Drashna Jaelre <@drashna>
* Copyright 2021 Tyler Thrailkill <@snowe/@snowe2010>
*
* 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/>.
*/
#pragma once
#define GUI_ESC GUI_T(KC_ESC)
#define CTL_ESC CTL_T(KC_ESC)
#define SH_BKSP SFT_T(KC_BSPC)
#define SP_RAIS LT(_UPPER, KC_SPC)
#define LOWER MO(_LOWER)
#define RAISE MO(_UPPER)
#define ADJUST MO(_ADJUST)
#define TG_MODS TG(_MODS)
//#define TG_GAME TG(_GAMEPAD)
//#define OS_LWR OSL(_LOWER)
//#define OS_RSE OSL(_UPPER)
//#define KC_SEC1 KC_SECRET_1
//#define KC_SEC2 KC_SECRET_2
//#define KC_SEC3 KC_SECRET_3
//#define KC_SEC4 KC_SECRET_4
//#define KC_SEC5 KC_SECRET_5
#define QWERTY KC_QWERTY
#define DVORAK KC_DVORAK
#define COLEMAK KC_COLEMAK
#define WORKMAN KC_WORKMAN
#define KC_RESET RESET
#define KC_RST KC_RESET
#ifdef SWAP_HANDS_ENABLE
# define KC_C1R3 SH_TT
#else // SWAP_HANDS_ENABLE
# define KC_C1R3 KC_BSPC
#endif // SWAP_HANDS_ENABLE
#define BK_LWER LT(_LOWER, KC_BSPC)
#define SP_LWER LT(_LOWER, KC_SPC)
#define DL_RAIS LT(_UPPER, KC_DEL)
#define ET_RAIS LT(_UPPER, KC_ENTER)
#define SFT_ENT SFT_T(KC_ENTER)
#define SP_RAIS LT(_UPPER, KC_SPC)
/* OSM keycodes, to keep things clean and easy to change */
#define KC_MLSF OSM(MOD_LSFT)
#define KC_MRSF OSM(MOD_RSFT)
#define OS_LGUI OSM(MOD_LGUI)
#define OS_RGUI OSM(MOD_RGUI)
#define OS_LSFT OSM(MOD_LSFT)
#define OS_RSFT OSM(MOD_RSFT)
#define OS_LCTL OSM(MOD_LCTL)
#define OS_RCTL OSM(MOD_RCTL)
#define OS_LALT OSM(MOD_LALT)
#define OS_RALT OSM(MOD_RALT)
#define OS_MEH OSM(MOD_MEH)
#define OS_HYPR OSM(MOD_HYPR)
#define ALT_APP ALT_T(KC_APP)
#define MG_NKRO MAGIC_TOGGLE_NKRO
#define UC_IRNY UC(0x2E2E)
#define UC_CLUE UC(0x203D)

View File

@ -0,0 +1,190 @@
/*
Copyright 2019 @foostan
Copyright 2020 Drashna Jaelre <@drashna>
Copyright 2021 Tyler Thrailkill <@snowe/@snowe2010>
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/>.
*/
#include QMK_KEYBOARD_H
#include "snowe.h"
// Symbols chart
// ↯ hyper key (ctrl, alt, shift, super)
// ⌘ command
// ⌥ option
// ⌃ control
// ⇧ shift
// ⌫ backspace
// ⌦ delete
// ⎋ escape
// ↩ enter
/* Wrapper
* ,-----------------------------------------------. .-----------------------------------------------.
* | Tab | K01 | K02 | K03 | K04 | K05 | | K06 | K07 | K08 | K09 | K0A | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | / | /K11 | K12 | K13 | K14 | K15 | | K16 | K17 | K18 | K19 | /K1A | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | / | /K21 | K22 | K23 | K24 | K25 | | K26 | K27 | K28 | K29 | /K2A | |
* `-----------------------. | | .-----------------------'
* |-------+-------+-------| |-------+-------+-------|
* | | / | /LWR | | /RAY | | R |
* `-----------------------' '-----------------------'
*/
// clang-format off
#define LAYOUT_crkbd_base( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \
) \
LAYOUT_wrapper( \
KC_TAB, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
GUI_ESC, CTL_T(K11), K12, K13, K14, K15, K16, K17, K18, K19, ALT_T(K1A), KC_QUOT, \
HYPR_T(KC_DEL), ALT_T(K21), K22, K23, K24, K25, K26, K27, K28, K29, RCTL_T(K2A), KC_BSLS, \
KC_LCTL, LOWER, SH_BKSP, KC_ENTER, SP_RAIS, KC_LALT \
)
// clang-format on
#define LAYOUT_crkbd_base_wrapper(...) LAYOUT_crkbd_base(__VA_ARGS__)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// clang-format off
/* QWERTY
* ,-----------------------------------------------. .-----------------------------------------------.
* | | Q | W | E | R | T | | Y | U | I | O | P | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | A | S | D | F | G | | H | J | K | L | ; | ' |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | Z | X | C | V | B | | N | M | , | . | / | |
* `-----------------------. | | .-----------------------'
* |-------+-------+-------| |-------+-------+-------|
* | | | | | | | |
* `-----------------------' '-----------------------'
*/
[_MAIN] = LAYOUT_crkbd_base_wrapper(
_________________QWERTY_L1_________________, _________________QWERTY_R1_________________,
_________________QWERTY_L2_________________, _________________QWERTY_R2_________________,
_________________QWERTY_L3_________________, _________________QWERTY_R3_________________
),
/* Lower
* ,-----------------------------------------------. .-----------------------------------------------.
* | ~ | ! | @ | # | $ | % | | ^ | & | * | ( | ) | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | _ | + | [ | ] | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | | | | | |
* `-----------------------. | | .-----------------------'
* |-------+-------+-------| |-------+-------+-------|
* | | | | | | | |
* `-----------------------' '-----------------------'
*/
[_LOWER] = LAYOUT_wrapper(
KC_TILDE, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_F11,
KC_F12 , _________________LOWER_L2__________________, _________________LOWER_R2__________________, KC_PIPE,
_______ , _________________LOWER_L3__________________, _________________LOWER_R3__________________, _______,
_______, _______, _______, _______, _______, _______
),
/*
* ,-----------------------------------------------. .-----------------------------------------------.
* | | | | | | | | | | | | | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | | | | | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | | | | | |
* `-----------------------. | | .-----------------------'
* |-------+-------+-------| |-------+-------+-------|
* | | | | | | | |
* `-----------------------' '-----------------------'
*/
/* Raise
* ,-----------------------------------------------. .-----------------------------------------------.
* | ` | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | | | | | |
* |-------+-------+-------+-------+-------+-------| |-------+-------+-------+-------+-------+-------|
* | | | | | | | | | home |pg down| pg up | end | |
* `-----------------------. | | .-----------------------'
* |-------+-------+-------| |-------+-------+-------|
* | | | | | | | |
* `-----------------------' '-----------------------'
*/
[_UPPER] = LAYOUT_wrapper( \
KC_GRV, _________________RAISE_L1__________________, _________________RAISE_R1__________________, _______,
_______, _________________RAISE_L2__________________, _________________RAISE_R2__________________, KC_BSLS,
_______, _________________RAISE_L3__________________, _________________RAISE_R3__________________, _______,
_______, _______, _______, _______, _______, _______
),
[_ADJUST] = LAYOUT_wrapper( \
_______, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RESET,
_______, _________________ADJUST_L2_________________, _________________ADJUST_R2_________________, EEP_RST,
_______, _________________ADJUST_L3_________________, _________________ADJUST_R3_________________, KC_MPLY,
_______, _______, _______, _______, _______, _______
)
// clang-format on
};
layer_state_t layer_state_set_user(layer_state_t state) { return update_tri_layer_state(state, _LOWER, _UPPER, _ADJUST); }
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case KC_LCTL:
case KC_RCTL:
#ifdef OCEAN_DREAM_ENABLE
is_calm = (record->event.pressed) ? true : false;
#endif
#ifdef LUNA_ENABLE
if (record->event.pressed) {
isSneaking = true;
} else {
isSneaking = false;
}
#endif
break;
case KC_SPC:
#ifdef LUNA_ENABLE
if (record->event.pressed) {
isJumping = true;
showedJump = false;
} else {
isJumping = false;
}
#endif
break;
}
return true;
}
// uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
// switch (keycode) {
// case ALT_T(KC_A):
// case SH_BKSP:
// return TAPPING_TERM + 500;
// default:
// return TAPPING_TERM;
// }
//}
//
// bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) {
// switch (keycode) {
// case ALT_T(KC_A):
// case SH_BKSP:
// return true;
// default:
// return false;
// }
//}

View File

@ -0,0 +1,25 @@
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
AUDIO_ENABLE = no # Audio output on port C6
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight.
LEADER_ENABLE = no
MIDI_ENABLE = no # MIDI controls
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
SWAP_HANDS_ENABLE = no # Enable one-hand typing
RGBLIGHT_TWINKLE = no
OLED_DRIVER_ENABLE = yes
RGB_MATRIX_ENABLE = yes
OCEAN_DREAM_ENABLE = yes
LUNA_ENABLE = no # disabled so travis build succeeds
# if firmware size over limit, try this option
CFLAGS += -flto
WPM_ENABLE = yes

View File

@ -25,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL, KC_END, KC_PGDN, \
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, \
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, \
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RALT, KC_RCTL, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, MO(1), KC_MENU, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
),
[1] = LAYOUT(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, _______, RESET , \

View File

@ -0,0 +1,48 @@
/* Copyright 2021 Mike Tsao
*
* 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/>.
*/
// keymaps/sowbug/keymap.c
#include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_PSCR, KC_SLCK, KC_PAUS, \
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_INS, KC_HOME, KC_PGUP, \
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_DEL, KC_END, KC_PGDN, \
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, \
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, \
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(1), KC_RALT, KC_RCTL, KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
),
[1] = LAYOUT(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, _______, RESET , \
_______, BL_TOGG, BL_STEP, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPLY, KC_MSTP, KC_VOLU, \
_______, RGB_SPD, RGB_VAI, RGB_SPI, RGB_HUI, RGB_SAI, _______, _______, _______, _______, _______, _______, _______, _______, KC_MPRV, KC_MNXT, KC_VOLD, \
_______, RGB_RMOD,RGB_VAD, RGB_MOD, RGB_HUD, RGB_SAD, _______, _______, _______, _______, _______, _______, _______, \
_______, RGB_TOG, _______, _______, _______, _______, NK_TOGG, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
),
/*
[X] = LAYOUT(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, NK_TOGG, _______, _______, _______, _______, _______, _______, \
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
),
*/
};

229
users/snowe/luna.c Normal file
View File

@ -0,0 +1,229 @@
/*
* Copyright 2021 QMK Community
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#include "quantum.h"
#include "luna.h"
// KEYBOARD PET START
// settings
#define MIN_WALK_SPEED 10
#define MIN_RUN_SPEED 40
// advanced settings
#define ANIM_FRAME_DURATION 200 // how long each frame lasts in ms
#define ANIM_SIZE 96 // number of bytes in array. If you change sprites, minimize for adequate firmware size. max is 1024
bool isSneaking = false;
bool isJumping = false;
bool showedJump = true;
// status variables
int current_wpm = 0;
led_t led_usb_state = {
.num_lock = false,
.caps_lock = false,
.scroll_lock = false
};
// current frame
uint8_t current_frame = 0;
// timers
uint32_t anim_timer = 0;
uint32_t anim_sleep = 0;
// logic
void render_luna(int LUNA_X, int LUNA_Y) {
// Sit
static const char PROGMEM sit[2][ANIM_SIZE] = {
// 'sit1', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c,
0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x68, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28,
0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
},
// 'sit2', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c,
0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x90, 0x08, 0x18, 0x60, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28,
0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}
};
// Walk
static const char PROGMEM walk[2][ANIM_SIZE] = {
// 'walk1', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x90, 0x90, 0x90, 0xa0, 0xc0, 0x80, 0x80,
0x80, 0x70, 0x08, 0x14, 0x08, 0x90, 0x10, 0x10, 0x08, 0xa4, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x08, 0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0xea, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x03,
0x06, 0x18, 0x20, 0x20, 0x3c, 0x0c, 0x12, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
},
// 'walk2', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x20, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00,
0x00, 0xe0, 0x10, 0x28, 0x10, 0x20, 0x20, 0x20, 0x10, 0x48, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x20, 0xf8, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x30, 0xd5, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e,
0x02, 0x1c, 0x14, 0x08, 0x10, 0x20, 0x2c, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
// Run
static const char PROGMEM run[2][ANIM_SIZE] = {
// 'run1', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x08, 0xc8, 0xb0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x40, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0xc4, 0xa4, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x58, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x09, 0x04, 0x04, 0x04, 0x04, 0x02, 0x03, 0x02, 0x01, 0x01,
0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
},
// 'run2', 32x22px
{
0x00, 0x00, 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
0x80, 0x80, 0x78, 0x28, 0x08, 0x10, 0x20, 0x30, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0xb0, 0x50, 0x55, 0x20, 0x1f, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37,
0x02, 0x1e, 0x20, 0x20, 0x18, 0x0c, 0x14, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
// Bark
static const char PROGMEM bark[2][ANIM_SIZE] = {
// 'bark1', 32x22px
{
0x00, 0xc0, 0x20, 0x10, 0xd0, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40,
0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02,
0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
},
// 'bark2', 32x22px
{
0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40,
0x40, 0x2c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x20, 0x4a, 0x09, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02,
0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
// Sneak
static const char PROGMEM sneak[2][ANIM_SIZE] = {
// 'sneak1', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xc0, 0x40, 0x40, 0x80, 0x00, 0x80, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1e, 0x21, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x04,
0x04, 0x04, 0x03, 0x01, 0x00, 0x00, 0x09, 0x01, 0x80, 0x80, 0xab, 0x04, 0xf8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x02, 0x06,
0x18, 0x20, 0x20, 0x38, 0x08, 0x10, 0x18, 0x04, 0x04, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
},
// 'sneak2', 32x22px
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xe0, 0xa0, 0x20, 0x40, 0x80, 0xc0, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x3e, 0x41, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x04,
0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x40, 0x40, 0x55, 0x82, 0x7c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x04,
0x18, 0x10, 0x08, 0x10, 0x20, 0x28, 0x34, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
// animation
void animation_phase(void) {
// jump
if (isJumping || !showedJump) {
// clear
oled_set_cursor(LUNA_X,LUNA_Y +2);
oled_write(" ", false);
oled_set_cursor(LUNA_X,LUNA_Y -1);
showedJump = true;
} else {
// clear
oled_set_cursor(LUNA_X,LUNA_Y -1);
oled_write(" ", false);
oled_set_cursor(LUNA_X,LUNA_Y);
}
// switch frame
current_frame = (current_frame + 1) % 2;
// current status
if(led_usb_state.caps_lock) {
oled_write_raw_P(bark[abs(1 - current_frame)], ANIM_SIZE);
} else if(isSneaking) {
oled_write_raw_P(sneak[abs(1 - current_frame)], ANIM_SIZE);
} else if(current_wpm <= MIN_WALK_SPEED) {
oled_write_raw_P(sit[abs(1 - current_frame)], ANIM_SIZE);
} else if(current_wpm <= MIN_RUN_SPEED) {
oled_write_raw_P(walk[abs(1 - current_frame)], ANIM_SIZE);
} else {
oled_write_raw_P(run[abs(1 - current_frame)], ANIM_SIZE);
}
}
// animation timer
if(timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) {
anim_timer = timer_read32();
current_wpm = get_current_wpm();
animation_phase();
}
// this fixes the screen on and off bug
if (current_wpm > 0) {
oled_on();
anim_sleep = timer_read32();
} else if(timer_elapsed32(anim_sleep) > OLED_TIMEOUT) {
oled_off();
}
}
// KEYBOARD PET END

31
users/snowe/luna.h Normal file
View File

@ -0,0 +1,31 @@
/*
* Copyright 2021 QMK Community
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#pragma once
extern bool isSneaking;
extern bool isJumping;
extern bool showedJump;
// status variables
extern led_t led_usb_state;
//extern int current_wpm;
void render_luna(int LUNA_X, int LUNA_Y);

555
users/snowe/ocean_dream.c Normal file
View File

@ -0,0 +1,555 @@
/*
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#include "ocean_dream.h"
#include "quantum.h"
#include "print.h"
// Calculated Parameters
#define TWINKLE_PROBABILITY_MODULATOR 100 / TWINKLE_PROBABILITY // CALCULATED: Don't Touch
#define TOTAL_STARS STARS_PER_LINE *NUMBER_OF_STAR_LINES // CALCULATED: Don't Touch
#define OCEAN_ANIMATION_MODULATOR NUMBER_OF_FRAMES / OCEAN_ANIMATION_SPEED // CALCULATED: Don't Touch
#define SHOOTING_STAR_ANIMATION_MODULATOR NUMBER_OF_FRAMES / SHOOTING_STAR_ANIMATION_SPEED // CALCULATED: Don't Touch
#define STAR_ANIMATION_MODULATOR NUMBER_OF_FRAMES / STAR_ANIMATION_SPEED // CALCULATED: Don't Touch
uint8_t animation_counter = 0; // global animation counter.
bool is_calm = false;
uint32_t starry_night_anim_timer = 0;
uint32_t starry_night_anim_sleep = 0;
static int current_wpm = 0;
static uint8_t increment_counter(uint8_t counter, uint8_t max) {
counter++;
if (counter >= max) {
return 0;
} else {
return counter;
}
}
#ifdef ENABLE_WAVE
static uint8_t decrement_counter(uint8_t counter, uint8_t max) {
counter--;
if (counter < 0 || counter > max) {
return max;
} else {
return counter;
}
}
#endif
#ifdef ENABLE_MOON // region
# ifndef STATIC_MOON
uint8_t moon_animation_frame = 0; // keeps track of current moon frame
uint16_t moon_animation_counter = 0; // counts how many frames to wait before animating moon to next frame
# endif
# ifdef STATIC_MOON
static const char PROGMEM moon[6] = {
0x18, 0x7E, 0xFF, 0xC3, 0x81, 0x81,
};
# endif
# ifndef STATIC_MOON
static const char PROGMEM moon_animation[14][8] = {
// clang-format off
{ 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
{ 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xFF, 0x42, 0x00, },
{ 0x3C, 0x7E, 0xFF, 0xFF, 0xFF, 0xC3, 0x00, 0x00, },
{ 0x3C, 0x7E, 0xFF, 0xFF, 0xC3, 0x81, 0x00, 0x00, },
{ 0x3C, 0x7E, 0xFF, 0xC3, 0x81, 0x00, 0x00, 0x00, },
{ 0x3C, 0x7E, 0xC3, 0x81, 0x81, 0x00, 0x00, 0x00, },
{ 0x3C, 0x42, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
{ 0x00, 0x00, 0x00, 0x00, 0x81, 0x81, 0x42, 0x3C, },
{ 0x00, 0x00, 0x00, 0x81, 0x81, 0xC3, 0x7E, 0x3C, },
{ 0x00, 0x00, 0x00, 0x81, 0xC3, 0xFF, 0x7E, 0x3C, },
{ 0x00, 0x00, 0x81, 0xC3, 0xFF, 0xFF, 0x7E, 0x3C, },
{ 0x00, 0x00, 0xC3, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
{ 0x00, 0x42, 0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, },
// clang-format on
};
# endif
static void draw_moon(void) {
# ifdef STATIC_MOON
oled_set_cursor(MOON_COLUMN, MOON_LINE);
oled_write_raw_P(moon, 6);
# endif
# ifndef STATIC_MOON
moon_animation_counter = increment_counter(moon_animation_counter, ANIMATE_MOON_EVERY_N_FRAMES);
if (moon_animation_counter == 0) {
moon_animation_frame = increment_counter(moon_animation_frame, 14);
oled_set_cursor(MOON_COLUMN, MOON_LINE);
oled_write_raw_P(moon_animation[moon_animation_frame], 8);
}
# endif
}
#endif // endregion
#ifdef ENABLE_WAVE // region
uint8_t starry_night_wave_frame_width_counter = 31;
uint8_t rough_waves_frame_counter = 0;
// clang-format off
static const char PROGMEM ocean_top[8][32] = {
// still ocean
{
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
},
// small ripples
{
0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
},
// level 2 ripples
{
0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
0x20, 0x60, 0x40, 0x40, 0x20, 0x60, 0x40, 0x40,
},
// level 3 waves
{
0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
0x40, 0x20, 0x10, 0x20, 0x40, 0x40, 0x40, 0x40,
},
{
0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
0x40, 0x40, 0x20, 0x10, 0x28, 0x50, 0x40, 0x40,
},
{
0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
0x40, 0x40, 0x40, 0x20, 0x10, 0x30, 0x70, 0x60,
},
};
static const char PROGMEM ocean_bottom[8][32] = {
// still ocean
{
0x00, 0x40, 0x40, 0x41, 0x01, 0x01, 0x01, 0x21,
0x20, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x44,
0x44, 0x40, 0x40, 0x00, 0x00, 0x08, 0x08, 0x00,
0x01, 0x01, 0x01, 0x00, 0x40, 0x40, 0x00, 0x00,
},
// small ripples
{
0x00, 0x00, 0x40, 0x40, 0x01, 0x01, 0x01, 0x20,
0x20, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,
0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
0x00, 0x01, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00,
},
// level 2 ripples
{
0x00, 0x00, 0x40, 0x40, 0x01, 0x01, 0x01, 0x20,
0x20, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,
0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
0x00, 0x01, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00,
},
// level 3 waves
{
0x00, 0x40, 0x40, 0x42, 0x42, 0x03, 0x11, 0x11,
0x20, 0x20, 0x00, 0x00, 0x08, 0x0C, 0x0C, 0x04,
0x05, 0x41, 0x41, 0x21, 0x20, 0x00, 0x00, 0x08,
0x0A, 0x0A, 0x0B, 0x41, 0x41, 0x41, 0x41, 0x00,
},
{
0x10, 0x10, 0x00, 0x80, 0x84, 0xC4, 0x02, 0x06,
0x84, 0x44, 0xC0, 0x80, 0x80, 0x20, 0x20, 0x10,
0x08, 0x12, 0x91, 0x81, 0x42, 0x40, 0x00, 0x00,
0x10, 0x12, 0x22, 0x22, 0x24, 0x04, 0x84, 0x80,
},
{
0x08, 0x80, 0x80, 0x82, 0x82, 0x03, 0x21, 0x21,
0x10, 0x10, 0x00, 0x00, 0x04, 0x04, 0x0C, 0x08,
0x09, 0x41, 0x42, 0x22, 0x20, 0x00, 0x00, 0x08,
0x0A, 0x0A, 0x0B, 0x41, 0x43, 0x42, 0x42, 0x00,
},
};
// clang-format on
static void animate_waves(void) {
starry_night_wave_frame_width_counter = decrement_counter(starry_night_wave_frame_width_counter, WIDTH - 1); // only 3 frames for last wave type
rough_waves_frame_counter = increment_counter(rough_waves_frame_counter, 3); // only 3 frames for last wave type
void draw_ocean(uint8_t frame, uint16_t offset, uint8_t byte_index) {
oled_write_raw_byte(pgm_read_byte(ocean_top[frame] + byte_index), offset);
oled_write_raw_byte(pgm_read_byte(ocean_bottom[frame] + byte_index), offset + WIDTH);
}
for (int i = 0; i < WIDTH; ++i) {
uint16_t offset = OCEAN_LINE * WIDTH + i;
uint8_t byte_index = starry_night_wave_frame_width_counter + i;
if (byte_index >= WIDTH) {
byte_index = byte_index - WIDTH;
}
if (is_calm || current_wpm <= WAVE_CALM) {
draw_ocean(0, offset, byte_index);
} else if (current_wpm <= WAVE_HEAVY_STORM) {
draw_ocean(1, offset, byte_index);
} else if (current_wpm <= WAVE_HURRICANE) {
draw_ocean(2, offset, byte_index);
} else {
draw_ocean(3 + rough_waves_frame_counter, offset, byte_index);
}
}
}
#endif // endregion
#ifdef ENABLE_ISLAND // region
uint8_t island_frame_1 = 0;
// clang-format off
// only use 46 bytes (first 18 are blank, so we don't write them, makes it smaller and we can see the shooting stars properly!)
// To save space and allow the shooting stars to be seen, only draw the tree on every frame.
// Tree is only 14bytes wide so we save 108 bytes on just the first row. Second row, the
// first 18 bytes is always the same piece of land, so only store that once, which saves 90 bytes
static const char PROGMEM islandRightTop[6][14] = {
{0x84, 0xEC, 0x6C, 0x3C, 0xF8, 0xFE, 0x3F, 0x6B, 0xDB, 0xB9, 0x30, 0x40, 0x00, 0x00,},
{0x80, 0xC3, 0xEE, 0x7C, 0xB8, 0xFC, 0xFE, 0x6F, 0xDB, 0x9B, 0xB2, 0x30, 0x00, 0x00,},
{0x00, 0xC0, 0xEE, 0x7F, 0x3D, 0xF8, 0xFC, 0x7E, 0x57, 0xDB, 0xDB, 0x8A, 0x00, 0x00,},
{0x00, 0xC0, 0xE6, 0x7F, 0x3B, 0xF9, 0xFC, 0xFC, 0xB6, 0xB3, 0x33, 0x61, 0x00, 0x00,},
{0x00, 0x00, 0x00, 0x00, 0x80, 0xEE, 0xFF, 0xFB, 0xF9, 0xFC, 0xDE, 0xB6, 0xB6, 0x24,},
{0x00, 0x00, 0x00, 0x00, 0xC0, 0xEE, 0xFE, 0xFF, 0xFB, 0xFD, 0xEE, 0xB6, 0xB6, 0x92,},
};
static const char PROGMEM islandRightBottom[6][14] = {
{0x41, 0x40, 0x60, 0x3E, 0x3F, 0x23, 0x20, 0x60, 0x41, 0x43, 0x40, 0x40, 0x40, 0x80,},
{0x40, 0x41, 0x60, 0x3E, 0x3F, 0x23, 0x20, 0x60, 0x40, 0x40, 0x41, 0x41, 0x40, 0x80,},
{0x40, 0x40, 0x61, 0x3D, 0x3F, 0x27, 0x21, 0x60, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80,},
{0x40, 0x43, 0x61, 0x3C, 0x3F, 0x27, 0x21, 0x60, 0x41, 0x43, 0x43, 0x42, 0x40, 0x80,},
{0x40, 0x40, 0x60, 0x3C, 0x3F, 0x27, 0x23, 0x63, 0x44, 0x40, 0x41, 0x41, 0x41, 0x81,},
{0x40, 0x40, 0x60, 0x3C, 0x3F, 0x27, 0x23, 0x63, 0x42, 0x42, 0x41, 0x41, 0x41, 0x80,},
};
static const char PROGMEM islandLeft[18] = {
0x80, 0x40, 0x40, 0x40, 0x40, 0x60,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x60, 0x40, 0x40,
};
// clang-format on
static void animate_island(void) {
if (animation_counter == 0) {
island_frame_1 = increment_counter(island_frame_1, 2);
}
void draw_island_parts(uint8_t frame) {
oled_set_cursor(ISLAND_COLUMN + 3, ISLAND_LINE);
oled_write_raw_P(islandRightTop[frame], 14);
oled_set_cursor(ISLAND_COLUMN + 0, ISLAND_LINE + 1);
oled_write_raw_P(islandLeft, 18);
oled_set_cursor(ISLAND_COLUMN + 3, ISLAND_LINE + 1);
oled_write_raw_P(islandRightBottom[frame], 14);
}
if (is_calm || current_wpm < ISLAND_CALM) {
draw_island_parts(0);
} else if (current_wpm >= ISLAND_CALM && current_wpm < ISLAND_HEAVY_STORM) {
draw_island_parts(island_frame_1 + 1);
} else if (current_wpm >= ISLAND_HEAVY_STORM && current_wpm < ISLAND_HURRICANE) {
draw_island_parts(island_frame_1 + 2);
} else {
draw_island_parts(island_frame_1 + 4);
}
}
#endif // endregion
#ifdef ENABLE_STARS // region
bool stars_setup = false; // only setup stars once, then we just twinkle them
struct Coordinate {
int x;
int y;
bool exists;
};
struct Coordinate stars[TOTAL_STARS]; // tracks all stars/coordinates
/**
* Setup all the initial stars on the screen
* This function divides the screen into regions based on STARS_PER_LINE and NUMBER_OF_STAR_LINES
* where each line is made up of 8x8 pixel groups, that are populated by a single star.
*
* Not sure how this function will work with larger or smaller screens.
* It should be fine, as long as the screen width is a multiple of 8
*/
static void setup_stars(void) {
// For every line, split the line into STARS_PER_LINE, find a random point in that region, and turn the pixel on
// 36% probability it will not be added
// (said another way, 80% chance it will start out lit in the x direction, then 80% chance it will start out lit in the y direction = 64% probability it will start out lit at all)
for (int line = 0; line < NUMBER_OF_STAR_LINES; ++line) {
for (int column_group = 0; column_group < STARS_PER_LINE; ++column_group) {
uint8_t rand_column = rand() % 10;
uint8_t rand_row = rand() % 10;
if (rand_column < 8 && rand_row < 8) {
int column_adder = column_group * 8;
int line_adder = line * 8;
int x = rand_column + column_adder;
int y = rand_row + line_adder;
oled_write_pixel(x, y, true);
stars[column_group + (line * STARS_PER_LINE)].x = x;
stars[column_group + (line * STARS_PER_LINE)].y = y;
stars[column_group + (line * STARS_PER_LINE)].exists = true;
} else {
stars[column_group + (line * STARS_PER_LINE)].exists = false;
}
}
}
stars_setup = true;
}
/**
* Twinkle the stars (move them one pixel in any direction) with a probability of 50% to twinkle any given star
*/
static void twinkle_stars(void) {
for (int line = 0; line < NUMBER_OF_STAR_LINES; ++line) {
for (int column_group = 0; column_group < STARS_PER_LINE; ++column_group) {
struct Coordinate star = stars[column_group + (line * STARS_PER_LINE)];
// skip stars that were never added
if (!star.exists) {
continue;
}
if (rand() % TWINKLE_PROBABILITY_MODULATOR == 0) {
oled_write_pixel(star.x, star.y, false); // black out pixel
// don't allow stars to leave their own region
if (star.x == (column_group * 8)) { // star is the farthest left it can go in its region
star.x++; // move it right immediately
} else if (star.x == (((column_group + 1) * 8) - 1)) { // star is farthest right it can go in its region
star.x--; // move it left immediately
}
if (star.y == (line * 8)) { // star is the farthest up it can go in its region
star.y++; // move it down immediately
} else if (star.y == (((line + 1) * 8) - 1)) { // star is farthest down it can go in its region
star.y--; // move it up immediately
}
// now decide direction
int new_x;
int x_choice = rand() % 3;
if (x_choice == 0) {
new_x = star.x - 1;
} else if (x_choice == 1) {
new_x = star.x + 1;
} else {
new_x = star.x;
}
int new_y;
int y_choice = rand() % 3;
if (y_choice == 0) {
new_y = star.y - 1;
} else if (y_choice == 1) {
new_y = star.y + 1;
} else {
new_y = star.y;
}
star.x = new_x;
star.y = new_y;
oled_write_pixel(new_x, new_y, true);
}
stars[column_group + (line * STARS_PER_LINE)] = star;
}
}
}
/**
* Setup the stars and then animate them on subsequent frames
*/
static void animate_stars(void) {
if (!stars_setup) {
setup_stars();
} else {
twinkle_stars();
}
}
#endif // endregion
#ifdef ENABLE_SHOOTING_STARS // region
bool shooting_stars_setup = false; // only setup shooting stars array once with defaults
struct ShootingStar {
int x_1;
int y_1;
int x_2;
int y_2;
bool running;
int frame;
int delay;
};
struct ShootingStar shooting_stars[MAX_NUMBER_OF_SHOOTING_STARS]; // tracks all the shooting stars
static void setup_shooting_star(struct ShootingStar *shooting_star) {
int column_to_start = rand() % (WIDTH / 2);
int row_to_start = rand() % (HEIGHT - 48); // shooting_stars travel diagonally 1 down, 1 across. So the lowest a shooting_star can start and not 'hit' the ocean is 32 above the ocean.
shooting_star->x_1 = column_to_start;
shooting_star->y_1 = row_to_start;
shooting_star->x_2 = column_to_start + 1;
shooting_star->y_2 = row_to_start + 1;
shooting_star->running = true;
shooting_star->frame++;
shooting_star->delay = rand() % SHOOTING_STAR_DELAY;
}
static void move_shooting_star(struct ShootingStar *shooting_star) {
oled_write_pixel(shooting_star->x_1, shooting_star->y_1, false);
oled_write_pixel(shooting_star->x_2, shooting_star->y_2, false);
shooting_star->x_1++;
shooting_star->y_1++;
shooting_star->x_2++;
shooting_star->y_2++;
shooting_star->frame++;
oled_write_pixel(shooting_star->x_1, shooting_star->y_1, true);
oled_write_pixel(shooting_star->x_2, shooting_star->y_2, true);
}
static void finish_shooting_star(struct ShootingStar *shooting_star) {
oled_write_pixel(shooting_star->x_1, shooting_star->y_1, false);
oled_write_pixel(shooting_star->x_2, shooting_star->y_2, false);
shooting_star->running = false;
shooting_star->frame = 0;
}
static void animate_shooting_star(struct ShootingStar *shooting_star) {
if (shooting_star->frame > SHOOTING_STAR_FRAMES) {
finish_shooting_star(shooting_star);
return;
} else if (!shooting_star->running) {
setup_shooting_star(shooting_star);
} else {
if (shooting_star->delay == 0) {
move_shooting_star(shooting_star);
} else {
shooting_star->delay--;
}
}
}
static void animate_shooting_stars(void) {
if (is_calm) {
return;
}
if (!shooting_stars_setup) {
for (int i = 0; i < MAX_NUMBER_OF_SHOOTING_STARS; ++i) {
shooting_stars[i].running = false;
}
shooting_stars_setup = true;
}
/**
* Fixes issue with stars that were falling _while_ the
* wpm dropped below the condition for them to keep falling
*/
void end_extra_stars(uint8_t starting_index) {
for (int shooting_star_index = starting_index; shooting_star_index < MAX_NUMBER_OF_SHOOTING_STARS; ++shooting_star_index) {
struct ShootingStar shooting_star = shooting_stars[shooting_star_index];
if (shooting_star.running) {
finish_shooting_star(&shooting_star);
shooting_stars[shooting_star_index] = shooting_star;
}
}
}
int number_of_shooting_stars = current_wpm / SHOOTING_STAR_WPM_INCREMENT;
number_of_shooting_stars = (number_of_shooting_stars > MAX_NUMBER_OF_SHOOTING_STARS) ? MAX_NUMBER_OF_SHOOTING_STARS : number_of_shooting_stars;
if (number_of_shooting_stars == 0) {
// make sure all shooting_stars are ended
end_extra_stars(0);
} else {
for (int shooting_star_index = 0; shooting_star_index < number_of_shooting_stars; ++shooting_star_index) {
struct ShootingStar shooting_star = shooting_stars[shooting_star_index];
animate_shooting_star(&shooting_star);
shooting_stars[shooting_star_index] = shooting_star;
}
end_extra_stars(number_of_shooting_stars);
}
}
#endif // endregion
/**
* Main rendering function
*
* Calls all different animations at different rates
*/
void render_stars(void) {
// // animation timer
if (timer_elapsed32(starry_night_anim_timer) > STARRY_NIGHT_ANIM_FRAME_DURATION) {
starry_night_anim_timer = timer_read32();
current_wpm = get_current_wpm();
#ifdef ENABLE_ISLAND
animate_island();
#endif
#ifdef ENABLE_SHOOTING_STARS
if (animation_counter % SHOOTING_STAR_ANIMATION_MODULATOR == 0) {
animate_shooting_stars();
}
#endif
#ifdef ENABLE_STARS
// TODO offsetting the star animation from the wave animation would look better,
// but if I do that, then the stars appear in the water because
// the ocean animation has to wait a bunch of frames to overwrite it.
// Possible solutions:
// 1. Only draw stars to the top of the island/ocean.
// 2. Draw ocean every frame, only move ocean on frames matching modulus
// Problems:
// 1. What if someone wants to move the island up a bit, or they want to have the stars reflect in the water?
// 2. More cpu intensive. And I'm already running out of cpu as it is...
if (animation_counter % STAR_ANIMATION_MODULATOR == 0) {
animate_stars();
}
#endif
#ifdef ENABLE_WAVE
if (animation_counter % OCEAN_ANIMATION_MODULATOR == 0) {
animate_waves();
}
#endif
#ifdef ENABLE_MOON
draw_moon();
#endif
animation_counter = increment_counter(animation_counter, NUMBER_OF_FRAMES);
}
// this fixes the screen on and off bug
if (current_wpm > 0) {
oled_on();
starry_night_anim_sleep = timer_read32();
} else if (timer_elapsed32(starry_night_anim_sleep) > OLED_TIMEOUT) {
oled_off();
}
}

103
users/snowe/ocean_dream.h Normal file
View File

@ -0,0 +1,103 @@
/*
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#pragma once
#include "quantum.h"
/**
* Features:
* You can turn on and off features in this section
*/
#define ENABLE_MOON // Uses 182 bytes
#define ENABLE_WAVE // Uses 844 bytes
#define ENABLE_SHOOTING_STARS // Uses 872 bytes
#define ENABLE_ISLAND
#define ENABLE_STARS // Uses 606 bytes
/**
* Global Settings
*/
#define STARRY_NIGHT_ANIM_FRAME_DURATION 30 // how long each frame lasts in ms
#define NUMBER_OF_FRAMES 20 // Self explanatory. Probably shouldn't touch this, not sure how stuff will work if it's changed. If changed should be multiple of 1, 2, 3, 4, and 5
#define WIDTH OLED_DISPLAY_HEIGHT // for vertical displays
#define HEIGHT OLED_DISPLAY_WIDTH // for vertical displays
/**
* Moon Parameters
*/
#define MOON_LINE 4 // the line you want the moon to appear at
#define MOON_COLUMN 4 // the column you want the moon to appear at
//#define STATIC_MOON // uncomment this to make the moon a static image, no animation
#ifndef STATIC_MOON
# define ANIMATE_MOON_EVERY_N_FRAMES 100 // animate the moon every n frames
#endif
/**
* Wave Parameters
*/
#define OCEAN_LINE 14 // Line you want to render the ocean starting at (best at oled_max_lines() - 2)
#define WAVE_CALM 20 // render calm ocean under this WPM and ripple ocean at this WPM
#define WAVE_HEAVY_STORM 40 // render medium ocean at this WPM
#define WAVE_HURRICANE 60 // render heavy waves above this WPM
// What number of frames you want to animate the ocean at.
// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 30, would animate on every other frame, 20, every third frame, etc
// Don't set equal to 0.
#define OCEAN_ANIMATION_SPEED 1
/**
* Shooting Star Parameters
*/
#define SHOOTING_STAR_DELAY 12 // delay modulus for time between shooting stars. Decides number of frames to delay, e.g. 12 means 0-11 frames of delay between each shooting star
#define SHOOTING_STAR_FRAMES 16 // how many 2 pixel frames per shooting star. Increment this for longer shooting stars
#define MAX_NUMBER_OF_SHOOTING_STARS 12 // maximum number of shooting stars that can be on screen at the same time
#define SHOOTING_STAR_WPM_INCREMENT 10 // every n WPM increase, add an extra star, up to MAX_NUMBER_OF_SHOOTING_STARS, e.g. an increment of 5 would result in 1 shooting star at 5-9wpm, 2 at 10-14, etc.
// What number of frames you want to animate the shooting stars at.
// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 30, would animate on every other frame, 20, every third frame, etc
// Don't set equal to 0.
#define SHOOTING_STAR_ANIMATION_SPEED 30
/**
* Star Parameters
*/
#define STARS_PER_LINE 4 // number of stars per line (for a display that is 128x32, this would be 4 stars spread out evenly over the 32byte width, one every 8 bytes)
#define NUMBER_OF_STAR_LINES 16 // number of lines to fill up with stars (for a display that is 128x32, 16 bytes are filled with the ocean animation, so that leaves 112 pixels left over. The number of lines depends on your OLED_FONT_HEIGHT)
#define TWINKLE_PROBABILITY 25 // probability that any star twinkles on a given frame
// What number of frames you want to animate the stars at.
// Should be equal to or smaller than NUMBER_OF_FRAMES, e.g. 20, would animate on every frame, 10, every other frame, etc
// Don't set equal to 0.
#define STAR_ANIMATION_SPEED 1
/**
* Island Parameters
*/
#define ISLAND_LINE 12 // line that the island starts at. Island is 2 lines tall
#define ISLAND_COLUMN 0 // column that the island starts at
#define ISLAND_CALM 20 // WPM at which the palm tree calmly moves
#define ISLAND_HEAVY_STORM 40 // WPM at which the heavy storm occurs
#define ISLAND_HURRICANE 60 // WPM at which THE HURRICANE STARTS
/*
* DON'T TOUCH
*/
extern bool is_calm;
// timers
extern uint32_t starry_night_anim_timer;
extern uint32_t starry_night_anim_sleep;
void render_stars(void);

141
users/snowe/oled_setup.c Normal file
View File

@ -0,0 +1,141 @@
/*
* Copyright QMK Community
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#ifdef OLED_DRIVER_ENABLE
# include QMK_KEYBOARD_H
# include "quantum.h"
# include "snowe.h"
# include <stdio.h> // for keylog?
oled_rotation_t oled_init_user(oled_rotation_t rotation) {
if (!is_master) {
return OLED_ROTATION_270; // flips the display 180 degrees if offhand
}
return OLED_ROTATION_270;
}
# define L_BASE 0
# define L_LOWER 2
# define L_RAISE 4
# define L_ADJUST 8
void oled_render_layer_state(void) {
oled_write_P(PSTR("Layer"), false);
switch (layer_state) {
case L_BASE:
oled_write_ln_P(PSTR("Main"), false);
break;
case L_LOWER:
oled_write_ln_P(PSTR("Bot"), false);
break;
case L_RAISE:
oled_write_ln_P(PSTR("Top"), false);
break;
case L_ADJUST:
case L_ADJUST | L_LOWER:
case L_ADJUST | L_RAISE:
case L_ADJUST | L_LOWER | L_RAISE:
oled_write_ln_P(PSTR("Comb"), false);
break;
}
}
char keylog_str[24] = {};
const char code_to_name[60] = {
' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'R', 'E', 'B', 'T', '_', '-', '=', '[', ']', '\\',
'#', ';', '\'', '`', ',', '.', '/', ' ', ' ', ' '};
void set_keylog(uint16_t keycode, keyrecord_t *record) {
char name = ' ';
if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
keycode = keycode & 0xFF;
}
if (keycode < 60) {
name = code_to_name[keycode];
}
// update keylog
snprintf(keylog_str, sizeof(keylog_str), "%dx%d, k%2d : %c", record->event.key.row, record->event.key.col, keycode, name);
}
void oled_render_keylog(void) { oled_write(keylog_str, false); }
// void render_bootmagic_status(bool status) {
// /* Show Ctrl-Gui Swap options */
// static const char PROGMEM logo[][2][3] = {
// {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
// {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
// };
// if (status) {
// oled_write_ln_P(logo[0][0], false);
// oled_write_ln_P(logo[0][1], false);
// } else {
// oled_write_ln_P(logo[1][0], false);
// oled_write_ln_P(logo[1][1], false);
// }
//}
void render_bootmagic_status(void) {
/* Show Ctrl-Gui Swap options */
static const char PROGMEM logo[][2][3] = {
{{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
{{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
};
oled_write_P(PSTR("BTMGK"), false);
oled_write_P(PSTR(""), false);
if (!keymap_config.swap_lctl_lgui) {
oled_write_P(logo[1][0], false);
oled_write_P(PSTR(" "), false);
oled_write_P(logo[1][1], false);
} else {
oled_write_P(logo[0][0], false);
oled_write_P(PSTR(" "), false);
oled_write_P(logo[0][1], false);
}
oled_write_P(PSTR(" NKRO "), keymap_config.nkro);
oled_write_P(PSTR("WPM: "), false);
char wpm[6];
itoa(get_current_wpm(), wpm, 10);
oled_write_ln(wpm, false);
}
void oled_task_user(void) {
if (is_master) {
oled_render_layer_state();
oled_render_keylog();
render_bootmagic_status();
# ifdef LUNA_ENABLE
led_usb_state = host_keyboard_led_state();
render_luna(0, 13);
# endif
} else {
# ifdef OCEAN_DREAM_ENABLE
render_stars();
# endif
}
}
#endif // OLED_DRIVER_ENABLE

30
users/snowe/oled_setup.h Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#pragma once
#include "quantum.h"
#ifdef OLED_DRIVER_ENABLE
# include "oled_driver.h"
# define OLED_RENDER_WPM_COUNTER " WPM: "
#endif
#ifdef LUNA_ENABLE
# include "luna.h"
#endif
#ifdef OCEAN_DREAM_ENABLE
# include "ocean_dream.h"
#endif

10
users/snowe/readme.md Normal file
View File

@ -0,0 +1,10 @@
# Welcome
Welcome to my userspace.
There's nothing really outstanding here, except the [Ocean Dream](readme_ocean_dream.md)
animation I made.
A lot of the code for my wrappers/keymaps came from other users.
I will probably update this with more in-depth information later.

View File

@ -0,0 +1,258 @@
# Ocean Dream
Tapping away at your IMX Corne with Box Jades, you feel yourself
drifting off, into a soundscape of waves and rustling leaves.
You open your eyes only to find yourself in an _Ocean Dream_.
Introducing, **Ocean Dream**, an animation for keyboards with tall OLED
screens. Built for 128x32 screens, this animation should work for 128x64
at least, though it hasn't been tested there.
Completely customizable, you can change everything about the animation,
from the number of falling stars, to how likely a star is to twinkle, and
even if the moon has phases or not.
# Installation
Installation is easy.
1. Add `ocean.h` and `ocean.c` to your keyboard folder or userspace.
2. In your `keymap.c` or wherever you handle your oled code, add
```c
# ifdef OCEAN_DREAM_ENABLE
render_stars();
# endif
```
to `oled_task_user(void)`, where you would like (see [my keymap](../../keyboards/crkbd/keymaps/snowe/keymap.c) for an example)
3. In your `keymap.c` or wherever you handle your process_record code,
add an event that sets `is_calm` when you press `ctrl`
```c
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case KC_LCTL:
case KC_RCTL:
#ifdef OCEAN_DREAM_ENABLE
is_calm = (record->event.pressed) ? true : false;
#endif
break;
}
return true;
}
```
4. In your `rules.mk` to make it easier to turn the animation on/off, add
```makefile
ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
#... your code here...
ifdef OCEAN_DREAM_ENABLE
ifeq ($(strip $(OCEAN_DREAM_ENABLE)), yes)
SRC += ocean_dream.c
OPT_DEFS += -DOCEAN_DREAM_ENABLE
endif
endif
ifndef OCEAN_DREAM_ENABLE
SRC += ocean_dream.c
OPT_DEFS += -DOCEAN_DREAM_ENABLE
endif
endif
```
You're done! Now you can enable **Ocean Dream** by simply turning on the OLED feature
```makefile
OLED_DRIVER_ENABLE = yes
```
And if you want to disable it without turning off the OLED Driver you can simply set
```makefile
OCEAN_DREAM_ENABLE = no
```
# Settings
**Ocean Dream** comes with several different animations, all individually configurable:
* 🌌 Stars that twinkle
* 🌠 Meteor showers that get more vibrant the faster you type
* 🌊 Waves that get rougher the faster you type
* 🏝 An island with a palm tree that blows in the wind the faster you type
* 🌗 A moon that goes through the moon phases (or not, your choice!)
Each feature can be individually turned on and off, with a simple `#define`.
You can see all the options and more documentation by looking at `ocean_dream.h`.
All options come enabled by default.
## Global Flags:
### Toggles:
You can toggle on/off any features using these flags:
* `ENABLE_MOON` // Uses 182 bytes
* `ENABLE_WAVE` // Uses 844 bytes
* `ENABLE_SHOOTING_STARS` // Uses 872 bytes
* `ENABLE_ISLAND`
* `ENABLE_STARS` // Uses 606 bytes
### Global Configuration:
* `STARRY_NIGHT_ANIM_FRAME_DURATION` - configures how long each frame lasts in ms
* `NUMBER_OF_FRAMES` - configures the number of frames that constitute a single 'round trip' of animation.
Enables keeping animations in sync/timed with each other.
Probably shouldn't touch this, not sure how stuff will work if it's changed.
If changed should probably be multiple of 1, 2, 3, 4, and 5
* `WIDTH` - for vertical displays, configures the width (the shortest measurement of your display). defaults to `OLED_DISPLAY_HEIGHT`
* `HEIGHT` - for vertical displays, configures the height (the longest measurement of your display). defaults to `OLED_DISPLAY_WIDTH`
## Stars
### Description
The 🌌 stars animation is a background of slowly twinkling stars.
The stars are built on a grid of sorts, where each cell of the grid
is 8x8 pixels with 1 star per cell. There is a probability of any
star twinkling on any given frame, decided by the corresponding flags.
### Flags
Enabled with the `#define ENABLE_STARS` directive.
The stars come with several configuration options:
* `STARS_PER_LINE` - configures the number of stars per line. Defaulting to 4, this would
mean that you have 4 stars across each line (8x32 on a 128x32 display), where each star
is in a 8x8 grid
* `NUMBER_OF_STAR_LINES` - configures the number of lines to fill up with stars.
Defaults to 16, filling the whole display.
* `TWINKLE_PROBABILITY` - configures the probability of a star twinkling on a given frame.
* `STAR_ANIMATION_SPEED` - configures the number of frames you want to animate the star at.
Must be equal to or lower than `NUMBER_OF_FRAMES`.
Example:
```c
#define NUMBER_OF_FRAMES 20
#define STAR_ANIMATION_SPEED 5
```
would result in the star animation happening every 4 frames. 20 would result in every frame,
1 would be once every 20 frames. This essentially changes how fast stars will twinkle, but
does not change the probability of the stars twinkling.
## Moon
### Description
The 🌗 moon animation is an 8x8 animation of a moon, or, if you are running out of program memory, you
can set it to just a static crescent moon, with no animation.
### Flags
Enabled with the `#define ENABLE_MOON` directive.
The moon comes with only a few configuration options:
* `STATIC_MOON` - include this directive if you want your moon to have no animation. It will simply be a static crescent
moon, only taking up 6 bytes of space. If you do not include this directive, then the moon will have an animation.
The default is a moon with animation.
* `MOON_LINE` - defines the line that the moon sits on. Default is `4`. (see [reference](#reference))
* `MOON_COLUMN` - defines the column that the moon sits at. Default is `4`. (see [reference](#reference))
* `ANIMATE_MOON_EVERY_N_FRAMES` - only enabled when `STATIC_MOON` is disabled, this affects how often the moon changes phases.
Example:
```c
#define STARRY_NIGHT_ANIM_FRAME_DURATION 30
#ifndef STATIC_MOON
# define ANIMATE_MOON_EVERY_N_FRAMES 100
#endif
```
would result in the moon changing phases every 3000ms, or every 3 seconds.
## Ocean
### Description
The 🌊 ocean animation is a full width animation of ocean waves, where the waves get rougher the faster you type.
You can configure the boundaries for each degree of _wave ferocity_ as well as how fast the ocean/waves move.
### Flags
* `OCEAN_LINE` - where to render the ocean at. Defaults to `14`. (see [reference](#reference))
* `OCEAN_ANIMATION_SPEED` - configures the number of frames you want to animate the ocean at.
Must be equal to or lower than `NUMBER_OF_FRAMES`.
Example:
```c
#define NUMBER_OF_FRAMES 20
#define OCEAN_ANIMATION_SPEED 5
```
would result in the ocean animation happening every 4 frames. 20 would result in every frame,
1 would be once every 20 frames. This essentially changes how fast the waves will move.
* `WAVE_CALM` - Defines the WPM at which the _Wave Ferocity_ kicks up.
At any WPM between `WAVE_CALM` and `WAVE_HEAVY_STORM`, the waves will be just tiny ripples.
* `WAVE_HEAVY_STORM` - Defines the WPM at which the _Wave Ferocity_ kicks up to medium.
At any WPM between `WAVE_HEAVY_STORM` and `WAVE_HURRICANE`, the waves will be medium sized waves.
* `WAVE_HURRICANE` - Defines the WPM at which the _Wave Ferocity_ kicks up to the last notch.
At any WPM above `WAVE_HURRICANE`, the waves will be torrential.
## Shooting Stars
The 🌠 shooting star animation is a full screen animation that renders a meteor shower based on your typing speed. The
faster you type, the more shooting stars there are!
You can configure many parts of the shooting stars, from shower size, to speed, to length of each trail, to how spaced
out they are.
Note: Each frame of a shooting star is only 2 pixels in length. This is a design decision, and could probably be changed
with a decent amount of work, but was chosen for looks and memory constraints.
### Flags
* `SHOOTING_STAR_DELAY` - Decides number of frames to delay, based on modulus, e.g. 12 means 0-11 frames of delay between each shooting star
* `SHOOTING_STAR_FRAMES` - how long each shooting star will be. A size of `16` will result in shooting stars that are 32 pixels long
* `MAX_NUMBER_OF_SHOOTING_STARS` - maximum number of shooting stars that can be on screen at the same time
* `SHOOTING_STAR_WPM_INCREMENT` - every n WPM increase, add an extra star, up to MAX_NUMBER_OF_SHOOTING_STARS
Example: an increment of 5 would result in 1 shooting star at 5-9wpm, 2 at 10-14, etc.
* `SHOOTING_STAR_ANIMATION_SPEED` - configures the number of frames you want to animate the shooting stars at.
Must be equal to or lower than `NUMBER_OF_FRAMES`.
Example:
```c
#define NUMBER_OF_FRAMES 20
#define SHOOTING_STAR_ANIMATION_SPEED 5
```
would result in the shooting star animation happening every 4 frames. 20 would result in every frame,
1 would be once every 20 frames. This essentially changes how fast the stars move through the sky.
## Island
The 🏝 island animation is a 32w x 16h animation of a small island with a single palm tree blowing in the wind. The faster
you type the harder the palm tree blows in the wind!
Since this animation has significant black space to the left side of the tree, certain design decisions were made to allow the
shooting stars to still show up in the sky there. This animation should work on any size screen >=32 pixels wide, and you
can place it anywhere on the screen, but above the ocean is recommended.
### Flags
* `ISLAND_LINE` - where to render the island at. Defaults to `12`. The island is 2 lines tall. (see [reference](#reference))
* `ISLAND_COLUMN` - where to render the island at. Defaults to `0`. The island is 32 pixels wide. (see [reference](#reference))
* `ISLAND_CALM` - Defines the WPM at which the _Storm Ferocity_ kicks up.
At any WPM between `ISLAND_CALM` and `ISLAND_HEAVY_STORM`, the palm tree will just calmly blow in the wind.
* `ISLAND_HEAVY_STORM` - Defines the WPM at which the _Storm Ferocity_ kicks up.
At any WPM between `ISLAND_HEAVY_STORM` and `ISLAND_HURRICANE`, the palm tree will be blowing hard in the wind
* `ISLAND_HURRICANE` - Defines the WPM at which the _Storm Ferocity_ kicks up.
At any WPM above `ISLAND_HURRICANE`, the palm tree will almost be torn from its roots!
# Reference
Any reference to `_LINE` or `COLUMN` refers to setting a cursor position using `oled_set_cursor()`, which uses
`OLED_FONT_WIDTH` and `OLED_FONT_HEIGHT` internally.
This will be the top-leftmost pixel of the image, so `_LINE 1` would start at the 9th pixel down and `_COLUMN 1`
would be the 7th pixel to the right, starting from the topleftmost pixel on the screen.
This code has been untested with different font heights/widths, so you might have to adjust a bit to make it work if you
have modified those values.
# ToDo
- [ ] don't require `is_calm` as a keyboard event. Not sure if the code will work without it currently.
- [ ] make all the stars twinkle brightly based on keypresses rather than timed. Not just a movement twinkle, but a larger
'full' twinkle, where the star actually gets bigger. This will be quite difficult, thus is left out of the v1.

27
users/snowe/rules.mk Normal file
View File

@ -0,0 +1,27 @@
ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
SRC += oled_setup.c
ifdef OCEAN_DREAM_ENABLE
ifeq ($(strip $(OCEAN_DREAM_ENABLE)), yes)
SRC += ocean_dream.c
OPT_DEFS += -DOCEAN_DREAM_ENABLE
endif
endif
ifndef OCEAN_DREAM_ENABLE
SRC += ocean_dream.c
OPT_DEFS += -DOCEAN_DREAM_ENABLE
endif
ifdef LUNA_ENABLE
ifeq ($(strip $(LUNA_ENABLE)), yes)
SRC += luna.c
OPT_DEFS += -DLUNA_ENABLE
endif
endif
ifndef LUNA_ENABLE
SRC += luna.c
OPT_DEFS += -DLUNA_ENABLE
endif
endif

43
users/snowe/snowe.h Normal file
View File

@ -0,0 +1,43 @@
/*
Copyright 2021 Tyler Thrailkill <@snowe/@snowe2010>
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/>.
*/
#pragma once
#include QMK_KEYBOARD_H
#ifndef QMK_FIRMWARE_SNOWE_H
# define QMK_FIRMWARE_SNOWE_H ;
#endif // QMK_FIRMWARE_SNOWE_H
#include "wrappers.h"
#include "keycode_aliases.h"
#define IGNORE_MOD_TAP_INTERRUPT
#undef PERMISSIVE_HOLD
//#if defined(RGBLIGHT_ENABLE)
//# include "rgb_stuff.h"
//#endif
//#if defined(RGB_MATRIX_ENABLE)
//# include "rgb_matrix_stuff.h"
//#endif
#ifdef OLED_DRIVER_ENABLE
# include "oled_setup.h"
#endif
enum layers { _MAIN, _LOWER, _UPPER, _ADJUST };

92
users/snowe/wrappers.h Normal file
View File

@ -0,0 +1,92 @@
/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
* 2021 Tyler Thrailkill (@snowe/@snowe2010) <tyler.b.thrailkill@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/>.
*/
#pragma once
#include "snowe.h"
/*
Since our quirky block definitions are basically a list of comma separated
arguments, we need a wrapper in order for these definitions to be
expanded before being used as arguments to the LAYOUT_xxx macro.
*/
#if (!defined(LAYOUT) && defined(KEYMAP))
# define LAYOUT KEYMAP
#endif
//#define LAYOUT_ergodox_wrapper(...) LAYOUT_ergodox(__VA_ARGS__)
//#define LAYOUT_ergodox_pretty_wrapper(...) LAYOUT_ergodox_pretty(__VA_ARGS__)
#define KEYMAP_wrapper(...) LAYOUT(__VA_ARGS__)
#define LAYOUT_wrapper(...) LAYOUT(__VA_ARGS__)
//#define LAYOUT_ortho_4x12_wrapper(...) LAYOUT_ortho_4x12(__VA_ARGS__)
//#define LAYOUT_ortho_5x12_wrapper(...) LAYOUT_ortho_5x12(__VA_ARGS__)
//#define LAYOUT_gergo_wrapper(...) LAYOUT_gergo(__VA_ARGS__)
/*
Blocks for each of the four major keyboard layouts
Organized so we can quickly adapt and modify all of them
at once, rather than for each keyboard, one at a time.
And this allows for much cleaner blocks in the keymaps.
For instance Tap/Hold for Control on all of the layouts
NOTE: These are all the same length. If you do a search/replace
then you need to add/remove underscores to keep the
lengths consistent.
*/
#define _________________QWERTY_L1_________________ KC_Q, KC_W, KC_E, KC_R, KC_T
#define _________________QWERTY_L2_________________ KC_A, KC_S, KC_D, KC_F, KC_G
#define _________________QWERTY_L3_________________ KC_Z, KC_X, KC_C, KC_V, KC_B
#define _________________QWERTY_R1_________________ KC_Y, KC_U, KC_I, KC_O, KC_P
#define _________________QWERTY_R2_________________ KC_H, KC_J, KC_K, KC_L, KC_SCLN
#define _________________QWERTY_R3_________________ KC_N, KC_M, KC_COMM, KC_DOT, KC_SLASH
#define ________________NUMBER_LEFT________________ KC_1, KC_2, KC_3, KC_4, KC_5
#define ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0
//#define ________________NUMBER_RIGHT_______________ KC_6, KC_7, TD(TD_8_UP), KC_9, KC_0
#define _________________FUNC_LEFT_________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5
#define _________________FUNC_RIGHT________________ KC_F6, KC_F7, KC_F8, KC_F9, KC_F10
#define ___________________BLANK___________________ _______, _______, _______, _______, _______
#define _________________LOWER_L1__________________ KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC
#define _________________LOWER_L2__________________ _________________FUNC_LEFT_________________
#define _________________LOWER_L3__________________ _________________FUNC_RIGHT________________
#define _________________LOWER_R1__________________ KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN
#define _________________LOWER_R2__________________ _______, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR
#define _________________LOWER_R3__________________ _______, KC_LEFT, KC_UP , KC_DOWN, KC_RGHT
#define _________________RAISE_L1__________________ ________________NUMBER_LEFT________________
#define _________________RAISE_L2__________________ _______, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC
#define _________________RAISE_L3__________________ ___________________BLANK___________________
#define _________________RAISE_R1__________________ ________________NUMBER_RIGHT_______________
#define _________________RAISE_R2__________________ KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______
#define _________________RAISE_R3__________________ _______, KC_HOME, KC_PGDN, KC_PGUP, KC_END
#define _________________ADJUST_L1_________________ RGB_MOD, RGB_HUI, RGB_SAI, RGB_VAI, RGB_TOG
#define _________________ADJUST_L2_________________ MU_TOG , CK_TOGG, AU_ON, AU_OFF, AG_NORM
#define _________________ADJUST_L3_________________ RGB_RMOD,RGB_HUD,RGB_SAD, RGB_VAD, _______
#define _________________ADJUST_R1_________________ _______, _______, _______, _______, _______
#define _________________ADJUST_R2_________________ RESET, CG_TOGG, _______, _______, _______
#define _________________ADJUST_R3_________________ _______, KC_MNXT, KC_VOLU, KC_VOLD, KC_MPLY