gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2024-12-15 06:10:53 +00:00
Code Issues Packages Projects Releases Wiki Activity
793cba0963
qmk_firmware/keyboards/lily58/keymaps/druotoni/draw_helper.c
druotoni b3c0548ed3
[Keymap] Lily58 : HELL0 NAVI. Interface (#15469) 
Co-authored-by: Drashna Jaelre <drashna@live.com>
Co-authored-by: Joel Challis <git@zvecr.com>
2022-01-13 11:00:35 -08:00

768 lines
22 KiB
C
Raw Blame History

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