gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2024-12-17 23:23:21 +00:00
Code Issues Packages Projects Releases Wiki Activity
1c1ba06cfb
qmk_firmware/users/snowe/ocean_dream.c
Tyler Thrailkill 4a15eb593d
snowe keymap/userspace and Ocean Dream animation (#12477) 
* Add snowe keymap/userspace & Ocean Dream animation

* Add snowe userspace with keymap wrappers and two animations
* Add crkbd keymap
* Add Ocean Dream animation, a cool full screen animation with:
* * twinkling stars
* * meteor showers
* * ocean waves
* * island with palm tree
* * moon with phases

* Disable Luna so travis build succeeds.

* Add more copyrights

* Add pragma once to keycode_aliases.h

Co-authored-by: Drashna Jaelre <drashna@live.com>

Co-authored-by: Drashna Jaelre <drashna@live.com>
2021-06-24 12:21:40 +10:00

556 lines
21 KiB
C
Raw Blame History

/*
* 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();
}
}
Reference in New Issue View Git Blame Copy Permalink