433 lines
12 KiB
C++
433 lines
12 KiB
C++
struct EffectEntry {
|
|
char* name;
|
|
Effect* effect;
|
|
};
|
|
|
|
class Bell : public Effect {
|
|
private:
|
|
|
|
CRGB color_on = CRGB(0xFFFF00);
|
|
CRGB color_off = CRGB(0x000000);
|
|
boolean invert = false;
|
|
|
|
public:
|
|
void loop() {
|
|
Serial.println("This is Bell.loop()");
|
|
for (int y = 0; y < 16; y++) {
|
|
for (int x = 0; x < 2; x++) {
|
|
for (int z = 0; z < 8; z++) {
|
|
leds[XYsafe(x * 8 + z, y)] = sprite_bell[y * 2 + x] >> (7 - z) & 1 ^ invert ? color_on : color_off;
|
|
}
|
|
}
|
|
}
|
|
|
|
EVERY_N_MILLISECONDS(300) {
|
|
invert = !invert;
|
|
}
|
|
}
|
|
};
|
|
|
|
class BigClock : public Effect {
|
|
private:
|
|
CRGB color_h = CRGB(0xFF0000);
|
|
CRGB color_m = CRGB(0x00FF00);
|
|
CRGB color_colon = CRGB(0xFFFF00);
|
|
|
|
void drawNumber(uint8_t number, int x, int y, CRGB color) {
|
|
char buffer[7];
|
|
sprintf(buffer, "%02d", number);
|
|
drawText(buffer, x, y, color);
|
|
}
|
|
|
|
void drawText(char *text, int x, int y, CRGB color) {
|
|
for (int i = 0; i < strlen(text); i++) {
|
|
drawSprite(font_char(numbers4x7, text[i]), x + i * 4, y, color);
|
|
}
|
|
}
|
|
|
|
unsigned char* font_char(unsigned char* font, char c) {
|
|
return &font[(c - 48) * 4];
|
|
}
|
|
|
|
void drawSprite(unsigned char* sprite, int xOffset, int yOffset, CRGB color) {
|
|
for ( byte y = 0; y < 7; y++) {
|
|
for ( byte x = 0; x < 4; x++) {
|
|
bool on = (sprite[x] >> y & 1) * 255;
|
|
if (on) {
|
|
leds[ XYsafe(x + xOffset, y + yOffset) ] = color;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public:
|
|
BigClock() {}
|
|
void loop() {
|
|
clear();
|
|
drawNumber(ntpClient.getHours(), 0, 0, color_h);
|
|
drawNumber(ntpClient.getMinutes(), 8, 0, color_m);
|
|
/*if (ntpClient.getSeconds() & 1) {
|
|
leds[XYsafe(13, 2)] = color_colon;
|
|
leds[XYsafe(13, 5)] = color_colon;
|
|
}*/
|
|
drawNumber(ntpClient.getSeconds(), 8, 8, color_colon);
|
|
}
|
|
};
|
|
|
|
class Clock : public Effect {
|
|
private:
|
|
Window window = {0, LED_HEIGHT - 6, LED_WIDTH, 6};
|
|
|
|
public:
|
|
Clock() {}
|
|
void loop() { loop(false, CRGB(0xFFFFFF), CRGB(0x000000)); }
|
|
void loop(boolean invert, CRGB fg_color, CRGB bg_color) {
|
|
if (!invert) {
|
|
clear(window, bg_color);
|
|
} else {
|
|
// Manually clear the needed parts
|
|
for(int i=0; i<window.w; i++) setPixel(window, i, 0, bg_color);
|
|
for(int y=0; y<6; y++) {
|
|
setPixel(window, 3, y, bg_color);
|
|
if (y!=2 && y!=4) {
|
|
setPixel(window, 7, y, bg_color);
|
|
}
|
|
setPixel(window, 8, y, bg_color);
|
|
setPixel(window, 12, y, bg_color);
|
|
}
|
|
fg_color = bg_color;
|
|
}
|
|
int h = ntpClient.getHours();
|
|
drawDigit(window, numbers3x5, 3, 5, 0, 1, h / 10, fg_color, invert);
|
|
drawDigit(window, numbers3x5, 3, 5, 4, 1, h % 10, fg_color, invert);
|
|
int m = ntpClient.getMinutes();
|
|
drawDigit(window, numbers3x5, 3, 5, 9, 1, m / 10, fg_color, invert);
|
|
drawDigit(window, numbers3x5, 3, 5, 13, 1, m % 10, fg_color, invert);
|
|
if (ntpClient.getSeconds() & 1) {
|
|
setPixel(window, 7, 2, fg_color);
|
|
setPixel(window, 7, 4, fg_color);
|
|
}
|
|
}
|
|
};
|
|
|
|
class Sinematrix3 : public Effect {
|
|
private:
|
|
double pangle = 0;
|
|
double angle = 0;
|
|
double sx = 0;
|
|
double sy = 0;
|
|
double tx = 0;
|
|
double ty = 0;
|
|
double cx = 0;
|
|
double cy = 0;
|
|
double rcx = 0;
|
|
double rcy = 0;
|
|
double angle2 = 0;
|
|
double sx2 = 0;
|
|
double sy2 = 0;
|
|
double tx2 = 0;
|
|
double ty2 = 0;
|
|
double basecol = 0;
|
|
double fx = 1.0 / (LED_WIDTH / PI);
|
|
double fy = 1.0 / (LED_HEIGHT / PI);
|
|
Matrix rotate;
|
|
|
|
public:
|
|
boolean supports_window = true;
|
|
boolean can_be_shown_with_clock() { return true; };
|
|
boolean clock_as_mask() { return true; };
|
|
Sinematrix3() {}
|
|
void loop() {
|
|
pangle = addmodpi( pangle, 0.0133 + (angle / 256) );
|
|
angle = cos(pangle) * PI;
|
|
sx = addmodpi( sx, 0.00673 );
|
|
sy = addmodpi( sy, 0.00437 );
|
|
tx = addmodpi( tx, 0.00239 );
|
|
ty = addmodpi( ty, 0.00293 );
|
|
cx = addmodpi( cx, 0.00197 );
|
|
cy = addmodpi( cy, 0.00227 );
|
|
rcx = (LED_WIDTH / 2) + (sin(cx) * LED_WIDTH);
|
|
rcy = (LED_HEIGHT / 2) + (sin(cy) * LED_HEIGHT);
|
|
angle2 = addmodpi( angle2, 0.0029 );
|
|
sx2 = addmodpi( sx2, 0.0041);
|
|
sy2 = addmodpi( sy2, 0.0031);
|
|
tx2 = addmodpi( tx2, 0.0011 );
|
|
ty2 = addmodpi( ty2, 0.0023 );
|
|
basecol = addmod( basecol, 1.0, 0.007 );
|
|
|
|
rotate = {
|
|
.a11 = cos(angle),
|
|
.a12 = -sin(angle),
|
|
.a21 = sin(angle),
|
|
.a22 = cos(angle)
|
|
};
|
|
Matrix zoom = {
|
|
.a11 = sin(sx) / 4.0 + 0.15,
|
|
.a12 = 0, //atan(cos(sx2)),
|
|
.a21 = 0, //atan(cos(sy2)),
|
|
.a22 = cos(sy) / 4.0 + 0.15
|
|
};
|
|
Vector translate = {
|
|
.x1 = sin(tx) * LED_WIDTH,
|
|
.x2 = sin(ty) * LED_HEIGHT
|
|
};
|
|
|
|
for ( int x = 0; x < LED_WIDTH; x++ ) {
|
|
for ( int y = 0; y < LED_HEIGHT; y++ ) {
|
|
Vector c = add(multiply( multiply(rotate, zoom), { .x1 = x - rcx, .x2 = y - rcy } ), translate);
|
|
int sat = (basecol + basefield(c.x1, c.x2)) * 255;
|
|
setPixel(window, x, y, CHSV(sat, 120, 255));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
class Static : public Effect {
|
|
private:
|
|
CRGB color;
|
|
public:
|
|
Static(CRGB col) {
|
|
color = col;
|
|
}
|
|
boolean supports_window = true;
|
|
void loop() {
|
|
EVERY_N_SECONDS(1) {
|
|
clear(window, color);
|
|
}
|
|
}
|
|
};
|
|
|
|
class Animation : public Effect {
|
|
private:
|
|
AnimationData *animation;
|
|
int frame = 0;
|
|
CRGB background_color;
|
|
int xOffset, yOffset;
|
|
long frameSince = 0;
|
|
public:
|
|
Animation(AnimationData *anim) {
|
|
Animation(anim, CRGB(0), 0, 0);
|
|
}
|
|
Animation(AnimationData *anim, CRGB background_color) {
|
|
Animation(anim, background_color, 0, 0);
|
|
}
|
|
Animation(AnimationData *anim, CRGB bg_color, int x, int y) {
|
|
animation = anim;
|
|
background_color = bg_color;
|
|
xOffset = x;
|
|
yOffset = y;
|
|
}
|
|
void loop() {
|
|
Serial.printf("Animation.loop. Animation is %p.", (void *)animation);
|
|
CRGB colors[animation->color_count];
|
|
int led_index = 0;
|
|
uint8_t *color_data = new uint8_t[animation->color_count * 3];
|
|
memcpy_P(color_data, animation->colors, animation->color_count * 3);
|
|
for (int i = 0; i < animation->color_count; i++) colors[i] = CRGB(color_data[i * 3], color_data[i * 3 + 1], color_data[i * 3 + 2]);
|
|
free(color_data);
|
|
// Data is stored in progmem, so get it from there.
|
|
int length = animation->offsets[frame + 1] - animation->offsets[frame];
|
|
uint8_t *data = new uint8_t[length];
|
|
memcpy_P(data, animation->data + animation->offsets[frame], length);
|
|
for (int i = 0; i < length; i++) {
|
|
uint8_t color_index;
|
|
uint8_t count;
|
|
if (data[i] == 255) { // Run-length encoded data
|
|
color_index = data[i + 2];
|
|
count = data[i + 1];
|
|
i += 2;
|
|
} else {
|
|
color_index = data[i];
|
|
count = 1;
|
|
}
|
|
|
|
if (color_index == 0) { // color #0 = skip this pixels
|
|
led_index += count;
|
|
} else {
|
|
CRGB* color;
|
|
if (color_index == 1) {
|
|
color = &background_color;
|
|
} else if (color_index >= 2) {
|
|
color = &colors[color_index - 2];
|
|
}
|
|
|
|
for (int j = 0; j < count; j++) set(led_index++, color);
|
|
}
|
|
}
|
|
free(data);
|
|
if (frameSince == 0 || frameSince + frameDelay(animation, frame) < millis() || frameSince > millis()) {
|
|
frame = (frame + 1) % animation->frame_count;
|
|
frameSince = millis();
|
|
}
|
|
}
|
|
void set(int i, CRGB* color) {
|
|
setPixel(xOffset + (i % animation->w), yOffset + (i / animation->h), *color);
|
|
}
|
|
uint16_t frameDelay(AnimationData* animation, int frame) {
|
|
if (animation->individual_delays) return animation->delays[frame];
|
|
return animation->delays[0];
|
|
}
|
|
};
|
|
|
|
class SingleDynamic : public Effect {
|
|
protected:
|
|
static const int factor = 2;
|
|
static const int tile_count = LED_WIDTH/factor * LED_HEIGHT/factor;
|
|
virtual int getLoopTime() { return config_effect_single_dynamic_loop_time; }
|
|
CRGB tiles[tile_count];
|
|
CRGB old_tiles[tile_count];
|
|
uint8_t blend = 0;
|
|
public:
|
|
SingleDynamic() {
|
|
for (int i=0; i<tile_count; i++) tiles[i] = CHSV(random8(), 180, 255);
|
|
}
|
|
virtual void update() {
|
|
tiles[random8(tile_count)] = CHSV(random8(), 180, 255);
|
|
}
|
|
boolean can_be_shown_with_clock() { return true; }
|
|
virtual void loop() {
|
|
EVERY_N_MILLISECONDS(getLoopTime()) {
|
|
memcpy(old_tiles, tiles, tile_count*sizeof(CRGB));
|
|
blend = 0;
|
|
update();
|
|
}
|
|
|
|
for (int x=0; x<window.w; x++) for (int y=0; y<window.h; y++) {
|
|
int index = y/2 * window.w/2 + x/2;
|
|
setPixel(window, x, y, nblend(old_tiles[index], tiles[index], blend));
|
|
}
|
|
if (blend < 255) blend+=20;
|
|
}
|
|
};
|
|
|
|
class MultiDynamic : public SingleDynamic {
|
|
protected:
|
|
int getLoopTime() { return config_effect_multi_dynamic_loop_time; }
|
|
public:
|
|
void update() {
|
|
for (int i=0; i<tile_count; i++) tiles[i] = CHSV(random8(), 180, 255);
|
|
}
|
|
};
|
|
|
|
class MatrixColumn {
|
|
private:
|
|
int x, y;
|
|
int length;
|
|
Window* window;
|
|
int speed;
|
|
boolean running;
|
|
long last_move = 0;
|
|
public:
|
|
MatrixColumn() {}
|
|
MatrixColumn(Window* win, int xPos) {
|
|
window = win;
|
|
x = xPos;
|
|
start();
|
|
y = random8(0, win->h);
|
|
}
|
|
|
|
void start() {
|
|
y=-1;
|
|
length = random8(config_effect_matrix_length_min, config_effect_matrix_length_max);
|
|
running = true;
|
|
speed = random8(config_effect_matrix_speed_min, config_effect_matrix_speed_max);
|
|
}
|
|
|
|
void advance() {
|
|
y++;
|
|
if (y-length > window->h) running = false;
|
|
}
|
|
|
|
void draw() {
|
|
for(int i=0; i<length; i++) {
|
|
CRGB color;
|
|
if (i==0) color=CHSV(85, 0, 192);
|
|
else color=CHSV(85, 255, 255/(length-1)*(length-i));
|
|
|
|
setPixel(*window, x, y-i, color);
|
|
}
|
|
}
|
|
|
|
void loop() {
|
|
if (!running) {
|
|
if (random8() < 20) {
|
|
// Start the column again.
|
|
start();
|
|
}
|
|
} else {
|
|
if (millis() - last_move > speed) {
|
|
advance();
|
|
last_move = millis();
|
|
}
|
|
|
|
draw();
|
|
}
|
|
}
|
|
};
|
|
|
|
class MatrixEffect : public Effect {
|
|
private:
|
|
MatrixColumn columns[LED_WIDTH];
|
|
public:
|
|
boolean can_be_shown_with_clock() { return true; };
|
|
MatrixEffect() {
|
|
for (int i=0; i<LED_WIDTH; i++) columns[i]=MatrixColumn(&window, i);
|
|
}
|
|
void loop() {
|
|
clear(window);
|
|
for (int i=0; i<LED_WIDTH; i++) columns[i].loop();
|
|
}
|
|
};
|
|
|
|
class CycleEffect : public Effect {
|
|
private:
|
|
Effect* effect;
|
|
long effectSince = 0;
|
|
public:
|
|
void changeEffect() {
|
|
Effect* new_effect;
|
|
do {
|
|
int new_id = random8(cycle_effects->size());
|
|
new_effect = cycle_effects->get(new_id);
|
|
} while (&new_effect == &effect);
|
|
effect = new_effect;
|
|
effectSince = millis();
|
|
}
|
|
|
|
boolean can_be_shown_with_clock() {
|
|
return effect->can_be_shown_with_clock();
|
|
};
|
|
boolean clock_as_mask() {
|
|
return effect->clock_as_mask();
|
|
};
|
|
|
|
CycleEffect() {};
|
|
|
|
void loop() {
|
|
if (!effect) changeEffect(); // If this is the first run, we have to select an effect first!
|
|
effect->loop();
|
|
// Don't use EVERY_N_SECONDS(config_effect_cycle_time) here because that function isn't relly made
|
|
// to be used with changing values.
|
|
EVERY_N_SECONDS(1) {
|
|
if (effectSince + config_effect_cycle_time*1000 < millis()) {
|
|
changeEffect();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
class TwirlEffect : public Effect {
|
|
private:
|
|
uint8_t angleOffset = 0;
|
|
double center_x = 8;
|
|
double center_y = 8;
|
|
public:
|
|
void loop() {
|
|
for (int x=0; x<window.w; x++) for (int y=0; y<window.h; y++) {
|
|
uint8_t angle = (x==center_x && y==center_y) ? 0 : atan2(y - center_y, x - center_x) / M_PI * 128 + 128 + angleOffset;
|
|
uint8_t brightness = sqrt16((center_x - x) * (center_x - x) + (center_y - y) * (center_y - y)) & 0xFF;
|
|
setPixel(window, x, y, CHSV(angle, (brightness<<5) & 0xFF, 255));
|
|
}
|
|
angleOffset += 1;
|
|
}
|
|
};
|