768 lines
22 KiB
C
768 lines
22 KiB
C
// Copyright 2021 Nicolas Druoton (druotoni)
|
|
// Copyright 2021 ugfx
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include QMK_KEYBOARD_H
|
|
|
|
#include "draw_helper.h"
|
|
#include "fast_random.h"
|
|
|
|
void drawline(uint8_t x, uint8_t y, uint8_t width, bool bHorizontal, bool bPositiveDirection, bool color) {
|
|
if (width <= 0) return;
|
|
uint8_t yPlus = 0;
|
|
uint8_t yMois = 0;
|
|
uint8_t nbtour = 0;
|
|
|
|
if (!bPositiveDirection) {
|
|
if (bHorizontal) {
|
|
x -= width;
|
|
} else {
|
|
y -= width;
|
|
}
|
|
}
|
|
|
|
yMois = (width / 2) - 1 + (width % 2);
|
|
|
|
yPlus = (width / 2);
|
|
nbtour = (width / 4) + 1;
|
|
|
|
bool bWhite = color;
|
|
|
|
if (bHorizontal) {
|
|
for (uint8_t i = 0; i < nbtour; i++) {
|
|
oled_write_pixel(x + yPlus + i, y, bWhite);
|
|
oled_write_pixel(x + yMois - i, y, bWhite);
|
|
|
|
oled_write_pixel(x + i, y, bWhite);
|
|
oled_write_pixel(x + width - 1 - i, y, bWhite);
|
|
}
|
|
} else {
|
|
for (uint8_t i = 0; i < nbtour; i++) {
|
|
oled_write_pixel(x, y + yPlus + i, bWhite);
|
|
oled_write_pixel(x, y + yMois - i, bWhite);
|
|
|
|
oled_write_pixel(x, y + i, bWhite);
|
|
|
|
oled_write_pixel(x, y + width - 1 - i, bWhite);
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawline_vb(uint8_t x, uint8_t y, uint8_t width, bool color) { drawline(x, y, width, false, true, color); }
|
|
|
|
void drawline_vt(uint8_t x, uint8_t y, uint8_t width, bool color) { drawline(x, y, width, false, false, color); }
|
|
|
|
void drawline_hr(uint8_t x, uint8_t y, uint8_t width, bool color) { drawline(x, y, width, true, true, color); }
|
|
|
|
void drawline_hl(uint8_t x, uint8_t y, uint8_t width, bool color) { drawline(x, y, width, true, false, color); }
|
|
|
|
void draw_rectangle(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, bool color) {
|
|
drawline_hr(x, y, width, color);
|
|
drawline_hr(x, y + heigth - 1, width, color);
|
|
drawline_vb(x, y, heigth, color);
|
|
drawline_vb(x + width - 1, y, heigth, color);
|
|
}
|
|
|
|
void draw_rectangle_fill(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, bool color) {
|
|
for (uint8_t i = 0; i < heigth; i++) {
|
|
drawline_hr(x, y + i, width, color);
|
|
}
|
|
}
|
|
|
|
void drawline_hr_heigth(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, bool color) {
|
|
for (int i = 0; i < heigth; i++) {
|
|
drawline_hr(x, y - i, width, color);
|
|
drawline_hr(x, y + i, width, color);
|
|
}
|
|
}
|
|
|
|
void drawline_point_hr(short x, short y, short x1, bool color) {
|
|
if (y < 0 || y > 127) return;
|
|
|
|
if (x1 < x) {
|
|
short iTemp = x;
|
|
x = x1;
|
|
x1 = iTemp;
|
|
}
|
|
|
|
if (x1 > 31) x1 = 31;
|
|
if (x < 0) x = 0;
|
|
if (x > 31) x = 31;
|
|
|
|
drawline(x, y, x1 - x, true, true, color);
|
|
}
|
|
|
|
void flip_flap_x(short px, short py, uint8_t val, bool color) {
|
|
oled_write_pixel(px + val, py, color);
|
|
oled_write_pixel(px - val, py, color);
|
|
}
|
|
|
|
void draw_circle(uint8_t x, uint8_t y, uint8_t radius, bool color) {
|
|
short a, b, P;
|
|
|
|
// Calculate intermediates
|
|
a = 1;
|
|
b = radius;
|
|
P = 4 - radius;
|
|
|
|
short py, px;
|
|
|
|
// Away we go using Bresenham's circle algorithm
|
|
// Optimized to prevent double drawing
|
|
px = x;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
px = x;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
|
|
flip_flap_x(x, y, b, color);
|
|
|
|
do {
|
|
flip_flap_x(x, y + b, a, color);
|
|
flip_flap_x(x, y - b, a, color);
|
|
flip_flap_x(x, y + a, b, color);
|
|
flip_flap_x(x, y - a, b, color);
|
|
|
|
if (P < 0)
|
|
P += 3 + 2 * a++;
|
|
else
|
|
P += 5 + 2 * (a++ - b--);
|
|
} while (a < b);
|
|
|
|
flip_flap_x(x, y + b, a, color);
|
|
flip_flap_x(x, y - b, a, color);
|
|
}
|
|
|
|
void draw_ellipse(uint8_t x, uint8_t y, uint8_t a, uint8_t b, bool color) {
|
|
int dx, dy;
|
|
int a2, b2;
|
|
int err, e2;
|
|
|
|
// short py, px;
|
|
// Calculate intermediates
|
|
dx = 0;
|
|
dy = b;
|
|
a2 = a * a;
|
|
b2 = b * b;
|
|
err = b2 - (2 * b - 1) * a2;
|
|
|
|
// Away we go using Bresenham's ellipse algorithm
|
|
do {
|
|
flip_flap_x(x, y + dy, dx, color);
|
|
flip_flap_x(x, y - dy, dx, color);
|
|
|
|
e2 = 2 * err;
|
|
if (e2 < (2 * dx + 1) * b2) {
|
|
dx++;
|
|
err += (2 * dx + 1) * b2;
|
|
}
|
|
if (e2 > -(2 * dy - 1) * a2) {
|
|
dy--;
|
|
err -= (2 * dy - 1) * a2;
|
|
}
|
|
} while (dy >= 0);
|
|
}
|
|
|
|
void draw_ellipse_fill(uint8_t x, uint8_t y, uint8_t a, uint8_t b, bool color) { return; }
|
|
// void draw_ellipse_fill(uint8_t x, uint8_t y, uint8_t a, uint8_t b, uint8_t color) {
|
|
// int dx, dy;
|
|
// int a2, b2;
|
|
// int err, e2;
|
|
|
|
// // Calculate intermediates
|
|
// dx = 0;
|
|
// dy = b;
|
|
// a2 = a * a;
|
|
// b2 = b * b;
|
|
// err = b2 - (2 * b - 1) * a2;
|
|
|
|
// short py, px, px1;
|
|
|
|
// // Away we go using Bresenham's ellipse algorithm
|
|
// // This is optimized to prevent overdrawing by drawing a line only when a y is about to change value
|
|
// do {
|
|
// e2 = 2 * err;
|
|
// if (e2 < (2 * dx + 1) * b2) {
|
|
// dx++;
|
|
// err += (2 * dx + 1) * b2;
|
|
// }
|
|
// if (e2 > -(2 * dy - 1) * a2) {
|
|
// py = y + dy;
|
|
// px = x - dx;
|
|
// px1 = x + dx;
|
|
// drawline_point_hr(px, py, px1, color);
|
|
// if (y) {
|
|
// py = y - dy;
|
|
// px = x - dx;
|
|
// px1 = x + dx;
|
|
// drawline_point_hr(px, py, px1, color);
|
|
// }
|
|
// dy--;
|
|
// err -= (2 * dy - 1) * a2;
|
|
// }
|
|
// } while (dy >= 0);
|
|
// }
|
|
|
|
bool test_limit(short x, short y) { return !(y < 0 || y > 127 || x < 0 || x > 31); }
|
|
|
|
void flip_flap_y_point(short px, short py, short px1, uint8_t val, bool color) {
|
|
// firmware size optimisation : one fonction for 2 lines of code
|
|
drawline_point_hr(px, py + val, px1, color);
|
|
drawline_point_hr(px, py - val, px1, color);
|
|
}
|
|
|
|
void draw_fill_circle(short x, short y, uint8_t radius, bool color) {
|
|
short a, b, P;
|
|
|
|
// Calculate intermediates
|
|
a = 1;
|
|
b = radius;
|
|
P = 4 - radius;
|
|
|
|
// Away we go using Bresenham's circle algorithm
|
|
// This is optimized to prevent overdrawing by drawing a line only when a variable is about to change value
|
|
short py, px, px1;
|
|
|
|
py = y;
|
|
px = x - b;
|
|
px1 = x + b;
|
|
drawline_point_hr(px, py, px1, color);
|
|
|
|
py = y + b;
|
|
px = x;
|
|
if (test_limit(px, py)) oled_write_pixel(px, py, color);
|
|
py = y - b;
|
|
px = x;
|
|
if (test_limit(px, py)) oled_write_pixel(px, py, color);
|
|
do {
|
|
flip_flap_y_point(x - b, y, x + b, a, color);
|
|
|
|
if (P < 0) {
|
|
P += 3 + 2 * a++;
|
|
} else {
|
|
flip_flap_y_point(x - a, y, x + a, b, color);
|
|
|
|
P += 5 + 2 * (a++ - b--);
|
|
}
|
|
} while (a < b);
|
|
|
|
flip_flap_y_point(x - b, y, x + b, a, color);
|
|
}
|
|
|
|
bool apres_moitie(int a, int b) { return (a > b / 2); }
|
|
bool arrive_moitie(int a, int b) { return (a > b / 2); }
|
|
bool avant_moitie(int a, int b) { return (a <= b / 2 && !apres_moitie(a, b)); }
|
|
|
|
void draw_arc_sector(uint8_t x, uint8_t y, uint8_t radius, unsigned char sectors, unsigned char half, bool color) {
|
|
short a, b, P;
|
|
short py, px;
|
|
// Calculate intermediates
|
|
a = 1; // x in many explanations
|
|
b = radius; // y in many explanations
|
|
P = 4 - radius;
|
|
|
|
if (half != 2) {
|
|
// Away we go using Bresenham's circle algorithm
|
|
// Optimized to prevent double drawing
|
|
if (sectors & 0x06) {
|
|
px = x;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper upper
|
|
if (sectors & 0x60) {
|
|
px = x;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower lower
|
|
if (sectors & 0x81) {
|
|
px = x + b;
|
|
py = y;
|
|
oled_write_pixel(px, py, color);
|
|
} // Right right
|
|
if (sectors & 0x18) {
|
|
px = x - b;
|
|
py = y;
|
|
oled_write_pixel(px, py, color);
|
|
} // Left left
|
|
}
|
|
|
|
bool dessiner = false;
|
|
|
|
do {
|
|
if (half == 1 && arrive_moitie(a, b)) break;
|
|
|
|
if (half == 2 && avant_moitie(a, b)) {
|
|
dessiner = false;
|
|
} else {
|
|
dessiner = true;
|
|
}
|
|
|
|
if (dessiner) {
|
|
if (sectors & 0x01) {
|
|
px = x + b;
|
|
py = y - a;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper right right
|
|
if (sectors & 0x02) {
|
|
px = x + a;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper upper right
|
|
if (sectors & 0x04) {
|
|
px = x - a;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper upper left
|
|
if (sectors & 0x08) {
|
|
px = x - b;
|
|
py = y - a;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper left left
|
|
if (sectors & 0x10) {
|
|
px = x - b;
|
|
py = y + a;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower left left
|
|
if (sectors & 0x20) {
|
|
px = x - a;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower lower left
|
|
if (sectors & 0x40) {
|
|
px = x + a;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower lower right
|
|
if (sectors & 0x80) {
|
|
px = x + b;
|
|
py = y + a;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower right right
|
|
}
|
|
|
|
if (P < 0)
|
|
P += 3 + 2 * a++;
|
|
else
|
|
P += 5 + 2 * (a++ - b--);
|
|
} while (a < b);
|
|
|
|
if (half != 1) {
|
|
if (sectors & 0xC0) {
|
|
px = x + a;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower right
|
|
if (sectors & 0x03) {
|
|
px = x + a;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper right
|
|
if (sectors & 0x30) {
|
|
px = x - a;
|
|
py = y + b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Lower left
|
|
if (sectors & 0x0C) {
|
|
px = x - a;
|
|
py = y - b;
|
|
oled_write_pixel(px, py, color);
|
|
} // Upper left
|
|
}
|
|
}
|
|
|
|
void draw_static(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, int color, uint8_t density) {
|
|
unsigned long rx = fastrand_long();
|
|
unsigned long ry = fastrand_long();
|
|
unsigned long maskx = 1;
|
|
unsigned long masky = 1;
|
|
unsigned long mask_base = 1;
|
|
|
|
// more 1 in the octet
|
|
for (int r = 0; r < density; r++) {
|
|
rx &= fastrand_long();
|
|
ry &= fastrand_long();
|
|
}
|
|
|
|
color = ((rx >> 1) % 2) == 0;
|
|
|
|
for (uint8_t i = 0; i < width; i++) {
|
|
for (uint8_t j = 0; j < heigth; j++) {
|
|
// new mask based on ij loop
|
|
maskx = (mask_base << i);
|
|
masky = (mask_base << j);
|
|
|
|
// logic AND with the masks
|
|
if (((rx & maskx) == maskx) && ((ry & masky) == masky)) {
|
|
oled_write_pixel(x + i, y + j, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void copy_pixel(int from, int shift, unsigned char mask) {
|
|
if (shift == 0) return;
|
|
|
|
// pixel cluster from
|
|
char c_from = get_oled_char(from);
|
|
char extract = c_from & mask;
|
|
|
|
// pixel cluster shift
|
|
char c_from_shift = get_oled_char(from + shift);
|
|
c_from_shift &= ~(mask);
|
|
c_from_shift |= extract;
|
|
oled_write_raw_byte(c_from_shift, from + shift);
|
|
|
|
// fill blank with black
|
|
c_from &= ~(mask);
|
|
oled_write_raw_byte(c_from, from);
|
|
}
|
|
|
|
void draw_glitch_comb(uint8_t x, uint8_t y, uint8_t width, uint16_t height, uint8_t iSize, bool odd) {
|
|
// work only on row
|
|
uint16_t y_start = (y / 8) * 32;
|
|
uint8_t nb_h = height / 8;
|
|
|
|
uint8_t w_max = width;
|
|
uint16_t index = y_start + x;
|
|
|
|
// shift pair even pixel
|
|
int mask_1 = 85;
|
|
int mask_2 = 170;
|
|
|
|
if (!odd) {
|
|
// shift odd pixel
|
|
mask_1 = 170;
|
|
mask_2 = 85;
|
|
}
|
|
|
|
// wobble
|
|
uint16_t pos = 0;
|
|
for (uint16_t j = 0; j < nb_h; j++) {
|
|
// next line
|
|
index = (y_start + x) + (j * 32);
|
|
|
|
for (uint16_t i = 0; i < w_max; i++) {
|
|
if (i + iSize < w_max) {
|
|
pos = index + i;
|
|
copy_pixel(pos + iSize, iSize * -1, mask_1);
|
|
}
|
|
|
|
if (w_max - 1 - i - iSize >= 0) {
|
|
pos = (index + w_max - 1) - i;
|
|
copy_pixel(pos - iSize, iSize, mask_2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void draw_random_char(uint8_t column, uint8_t row, char final_char, int value, uint8_t style) {
|
|
if (value < 0) return;
|
|
|
|
char c = final_char;
|
|
|
|
if (value < 100) {
|
|
c = ((fastrand() % 15) + 1);
|
|
}
|
|
|
|
oled_set_cursor(column, row);
|
|
oled_write_char(c, false);
|
|
}
|
|
|
|
void get_glitch_index_new(uint16_t *glitch_timer, uint8_t *current_glitch_scope_time, uint8_t *glitch_index, uint8_t min_time, uint16_t max_time, uint8_t glitch_probobility, uint8_t glitch_frame_number) {
|
|
if (timer_elapsed(*glitch_timer) > *current_glitch_scope_time) {
|
|
// end of the last glitch period
|
|
*glitch_timer = timer_read();
|
|
|
|
// new random glich period
|
|
*current_glitch_scope_time = min_time + fastrand() % (max_time - min_time);
|
|
|
|
bool bGenerateGlitch = (fastrand() % 100) < glitch_probobility;
|
|
if (!bGenerateGlitch) {
|
|
// no glitch
|
|
*glitch_index = 0;
|
|
return;
|
|
}
|
|
|
|
// get a new glitch index
|
|
*glitch_index = fastrand() % glitch_frame_number;
|
|
}
|
|
}
|
|
|
|
uint8_t get_glitch_frame_index(uint8_t glitch_probobility, uint8_t glitch_frame_number) {
|
|
bool bGenerateGlitch = (fastrand() % 100) < glitch_probobility;
|
|
if (!bGenerateGlitch) {
|
|
// no glitch
|
|
return 0;
|
|
}
|
|
|
|
// get a new glitch index
|
|
return fastrand() % glitch_frame_number;
|
|
}
|
|
|
|
uint8_t get_glitch_duration(uint8_t min_time, uint16_t max_time) { return min_time + fastrand() % (max_time - min_time); }
|
|
|
|
void get_glitch_index(uint32_t *glitch_timer, int *current_glitch_scope_time, uint8_t *glitch_index, uint8_t min_time, uint16_t max_time, uint8_t glitch_probobility, uint8_t glitch_frame_number) {
|
|
if (timer_elapsed32(*glitch_timer) > *current_glitch_scope_time) {
|
|
// end of the last glitch period
|
|
*glitch_timer = timer_read32();
|
|
|
|
// new random glich period
|
|
*current_glitch_scope_time = min_time + fastrand() % (max_time - min_time);
|
|
|
|
bool bGenerateGlitch = (fastrand() % 100) < glitch_probobility;
|
|
if (!bGenerateGlitch) {
|
|
// no glitch
|
|
*glitch_index = 0;
|
|
return;
|
|
}
|
|
|
|
// get a new glitch index
|
|
*glitch_index = fastrand() % glitch_frame_number;
|
|
}
|
|
}
|
|
|
|
void draw_progress(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, int value, uint8_t style, bool color) {
|
|
if (value > 100) {
|
|
value = 100;
|
|
}
|
|
int lenght = (width * value) / 100;
|
|
for (uint8_t i = 0; i < lenght; i++) {
|
|
switch (style) {
|
|
case 0:
|
|
drawline_vb(x + i, y, heigth - 1, color);
|
|
break;
|
|
|
|
// case 1:
|
|
// drawline_vb(x + i, y + 1, heigth - 3, ((i % 3) < 2));
|
|
// break;
|
|
// case 2:
|
|
// // . . . . .
|
|
// drawline_vb(x + i, y + 3, 2, ((i % 2) == 0));
|
|
// break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void oled_write_raw_P_cursor(uint8_t col, uint8_t line, const char *data, uint16_t size) {
|
|
// raw_P at cursor position
|
|
oled_set_cursor(col, line);
|
|
oled_write_raw_P(data, size);
|
|
}
|
|
|
|
void oled_write_cursor(uint8_t col, uint8_t line, const char *data, bool invert) {
|
|
// write at cursor position
|
|
oled_set_cursor(col, line);
|
|
oled_write(data, invert);
|
|
}
|
|
|
|
void draw_label(const char *data, uint8_t len, uint8_t row, int value) {
|
|
if (value < 0) return;
|
|
if (row >= 16 || row < 0) return;
|
|
oled_write_cursor(0, row, data, false);
|
|
}
|
|
|
|
void draw_box(const char *data, uint8_t len, uint8_t row, long value, uint8_t style) {
|
|
if (value < 0) return;
|
|
if (row >= 16 || row < 0) return;
|
|
|
|
oled_write_cursor(0, row, data, false);
|
|
|
|
uint8_t y = row * 8;
|
|
|
|
uint8_t x = 6 * len;
|
|
uint8_t w = 32 - x;
|
|
|
|
if (value < 0) value = 0;
|
|
if (value > 100) value = 100;
|
|
draw_progress(x, y, w, 7, value, style, 1);
|
|
}
|
|
|
|
char get_oled_char(uint16_t start_index) {
|
|
oled_buffer_reader_t reader;
|
|
reader = oled_read_raw(start_index);
|
|
return *reader.current_element;
|
|
}
|
|
|
|
static int get_index_first_block(uint8_t y) { return ((y / 8) * 32); }
|
|
|
|
void move_block(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, int shift) {
|
|
// clip
|
|
if (x >= 31) return;
|
|
if (y >= 127) return;
|
|
|
|
int max_screen = 32 - 1;
|
|
if ((width + x) > max_screen + 1) width = max_screen + 1 - x;
|
|
|
|
if (width <= 1) return;
|
|
|
|
if ((heigth + y) > 127) heigth = 127 - y;
|
|
if (heigth <= 1) return;
|
|
|
|
// [-32 & +32]
|
|
if (shift > max_screen) shift = max_screen;
|
|
if (shift < -1 * max_screen) shift = -1 * max_screen;
|
|
|
|
if ((width + x + shift) > max_screen) width = width - shift;
|
|
|
|
int pixelTop = 8 - (y % 8);
|
|
int pixelBottom = (y + heigth) % 8;
|
|
|
|
unsigned char cMastTop = ~((unsigned)255 >> (pixelTop));
|
|
unsigned char cMastBottom = ~((unsigned)255 << (pixelBottom));
|
|
|
|
int indexFirstBloc = get_index_first_block(y) + x;
|
|
int indexFirstBlocFull = get_index_first_block(y + pixelTop) + x;
|
|
int indexFirstBlocEnd = get_index_first_block(y + heigth) + x;
|
|
|
|
int nbBlockHeigth = (heigth - pixelTop - pixelBottom) / 8;
|
|
|
|
if (nbBlockHeigth < 0) {
|
|
// just single row
|
|
nbBlockHeigth = 0;
|
|
cMastBottom = 0;
|
|
}
|
|
|
|
if (shift < 0) {
|
|
for (uint16_t i = 0; i < width; i++) {
|
|
copy_pixel(indexFirstBloc + i, shift, cMastTop);
|
|
copy_pixel(indexFirstBlocEnd + i, shift, cMastBottom);
|
|
|
|
for (uint16_t j = 0; j < nbBlockHeigth; j++) {
|
|
copy_pixel(indexFirstBlocFull + i + (j * 32), shift, 255);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
for (int i = width - 1; i >= 0; i--) {
|
|
copy_pixel(indexFirstBloc + i, shift, cMastTop);
|
|
copy_pixel(indexFirstBlocEnd + i, shift, cMastBottom);
|
|
|
|
for (uint16_t j = 0; j < nbBlockHeigth; j++) {
|
|
copy_pixel(indexFirstBlocFull + i + (j * 32), shift, 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int interpo_pourcent(int min, int max, int v) {
|
|
// interpolation
|
|
float x0 = min;
|
|
float x1 = max;
|
|
float y0 = 0;
|
|
float y1 = 100;
|
|
float xp = v;
|
|
float yp = y0 + ((y1 - y0) / (x1 - x0)) * (xp - x0);
|
|
|
|
return (int)yp;
|
|
}
|
|
|
|
uint8_t BAYER_PATTERN_4[4][4] = {{15, 135, 45, 165}, {195, 75, 225, 105}, {60, 180, 30, 150}, {240, 120, 210, 90}};
|
|
|
|
void draw_gradient(uint8_t x, uint8_t y, uint8_t width, uint8_t heigth, uint8_t color_start, uint8_t color_end, uint8_t tres) {
|
|
bool invert = color_start > color_end;
|
|
|
|
if (invert) {
|
|
color_start = 255 - color_start;
|
|
color_end = 255 - color_end;
|
|
}
|
|
|
|
int step = (100 / tres);
|
|
int step_minus = (100 / (tres - 1));
|
|
int distance = color_end - color_start;
|
|
|
|
for (uint8_t i = 0; i < width; i++) {
|
|
int position = interpo_pourcent(0, width, i);
|
|
|
|
float color = position;
|
|
color = ((int)(color / step)) * step_minus;
|
|
|
|
color = color_start + ((distance * color) / 100);
|
|
|
|
for (uint8_t j = 0; j < heigth; j++) {
|
|
uint8_t m = BAYER_PATTERN_4[i % 4][j % 4];
|
|
unsigned char color_d = (color > m) ? !invert : invert;
|
|
|
|
oled_write_pixel(x + i, y + j, color_d);
|
|
}
|
|
}
|
|
}
|
|
|
|
void render_tv_animation(uint8_t frame_number, uint8_t x, uint8_t y, uint8_t width, uint8_t heigth) {
|
|
uint8_t xCenter = x + (width / 2);
|
|
uint8_t yCenter = y + (heigth / 2);
|
|
|
|
switch (frame_number) {
|
|
case 0:
|
|
// a fond : allume
|
|
drawline_hr_heigth(x, yCenter, width, 17, true);
|
|
break;
|
|
|
|
case 1:
|
|
drawline_hr_heigth(x, yCenter, width, 12, true);
|
|
draw_ellipse_fill(xCenter, yCenter, 7, 15, true);
|
|
break;
|
|
|
|
case 2:
|
|
drawline_hr_heigth(x, yCenter, width, 5, true);
|
|
draw_ellipse_fill(xCenter, yCenter, 5, 8, true);
|
|
break;
|
|
|
|
case 3:
|
|
drawline_hr_heigth(x, yCenter, width, 3, true);
|
|
draw_ellipse_fill(xCenter, yCenter, 3, 4, true);
|
|
break;
|
|
|
|
case 4:
|
|
drawline_hr_heigth(x, yCenter, width, 2, true);
|
|
draw_fill_circle(xCenter, yCenter, 3, true);
|
|
break;
|
|
|
|
case 5:
|
|
// central line
|
|
drawline_hr(x, yCenter, width, true);
|
|
draw_fill_circle(xCenter, yCenter, 2, true);
|
|
break;
|
|
|
|
case 6:
|
|
// cross
|
|
drawline_hr(xCenter, yCenter + 1, 2, true);
|
|
drawline_hr(xCenter, yCenter - 1, 2, true);
|
|
|
|
// central line
|
|
drawline_hr(x, yCenter, width, true);
|
|
break;
|
|
|
|
case 7:
|
|
// cross
|
|
drawline_hr(xCenter, yCenter + 1, 2, true);
|
|
drawline_hr(xCenter, yCenter - 1, 2, true);
|
|
// central line
|
|
drawline_hr(xCenter - 8, yCenter, 18, true);
|
|
// static
|
|
oled_write_pixel(xCenter - 11, yCenter, true);
|
|
oled_write_pixel(xCenter + 12, yCenter, true);
|
|
break;
|
|
|
|
case 8:
|
|
// cross
|
|
drawline_hr(xCenter, yCenter + 1, 2, true);
|
|
drawline_hr(xCenter, yCenter - 1, 2, true);
|
|
// central line
|
|
drawline_hr(xCenter - 2, yCenter, 4, true);
|
|
// static
|
|
drawline_hr(xCenter - 7, yCenter, 2, true);
|
|
drawline_hr(xCenter + 6, yCenter, 3, true);
|
|
|
|
// oled_write_pixel(xCenter - 11, yCenter, true);
|
|
oled_write_pixel(xCenter - 9, yCenter, true);
|
|
oled_write_pixel(xCenter + 12, yCenter, true);
|
|
oled_write_pixel(xCenter + 14, yCenter, true);
|
|
break;
|
|
|
|
case 9:
|
|
// central line
|
|
drawline_hr(xCenter, yCenter, 2, true);
|
|
break;
|
|
}
|
|
} |