ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
digital_rain.c File Reference

Matrix-style digital rain effect implementation. More...

Go to the source code of this file.

Macros

#define M_PI   3.14159265358979323846

Functions

int digital_rain_glyph_group (uint32_t codepoint)
digital_rain_t * digital_rain_init (int num_columns, int num_rows)
 Initialize digital rain effect context.
void digital_rain_destroy (digital_rain_t *rain)
 Destroy digital rain effect context.
void digital_rain_reset (digital_rain_t *rain)
 Reset digital rain effect state.
void digital_rain_set_fall_speed (digital_rain_t *rain, float speed)
 Set digital rain fall speed.
void digital_rain_set_raindrop_length (digital_rain_t *rain, float length)
 Set digital rain raindrop length.
void digital_rain_set_color (digital_rain_t *rain, uint8_t r, uint8_t g, uint8_t b)
 Set digital rain color.
void digital_rain_set_color_from_filter (digital_rain_t *rain, color_filter_t filter)
 Set digital rain color from color filter.
char * digital_rain_apply (digital_rain_t *rain, const char *frame, float delta_time)
 Apply digital rain effect to ASCII frame.
char * digital_rain_render_at (digital_rain_t *rain, const char *frame, float seconds)

Detailed Description

Matrix-style digital rain effect implementation.

Definition in file digital_rain.c.

Macro Definition Documentation

◆ M_PI

#define M_PI   3.14159265358979323846

Definition at line 24 of file digital_rain.c.

Function Documentation

◆ digital_rain_render_at()

char * digital_rain_render_at ( digital_rain_t * rain,
const char * frame,
float seconds )

Definition at line 376 of file digital_rain.c.

376 {
377 if (!rain || !frame) {
378 log_error("NULL parameter");
379 return NULL;
380 }
381
382 if (!isfinite(seconds) || seconds < 0)
383 return NULL;
384 float elapsed = fmaxf(0.0f, seconds - rain->time);
385 rain->time = seconds;
386 float sim_time = seconds;
387 // brightness_decay retains its meaning as a blend factor at 60 Hz.
388 float decay = fminf(1.0f, fmaxf(0.0f, rain->brightness_decay));
389 float alpha = elapsed > 0 ? 1.0f - powf(1.0f - decay, elapsed * 60.0f) : 0.0f;
390
391 if (rain->rainbow_mode)
392 color_filter_calculate_rainbow(sim_time, &rain->color_r, &rain->color_g, &rain->color_b);
393
394 size_t input_len = strlen(frame);
395 if (input_len > (SIZE_MAX - 1024) / 48)
396 return NULL;
397 size_t output_capacity = input_len * 48 + 1024;
398 char *output = SAFE_MALLOC(output_capacity, char *);
399 if (!output)
400 return NULL;
401
402 const char *src = frame;
403 char *dst = output;
404 size_t remaining = output_capacity;
405 int col = 0, row = 0;
406 float foreground_luminance = 1.0f, background_luminance = 0.0f;
407 bool has_background = false;
408 bool colored = false;
409
410 while (*src && remaining > 100) {
411 if (*src == '\033') {
412 int r, g, b;
413 bool foreground;
414 const char *after = parse_ansi_color(src, &r, &g, &b, &foreground);
415 if (after) {
416 float luminance = fminf(1.0f, fmaxf(0.0f, (0.2126f * r + 0.7152f * g + 0.0722f * b) / 255.0f));
417 if (foreground)
418 foreground_luminance = luminance;
419 else {
420 background_luminance = luminance;
421 has_background = true;
422 }
423 src = after;
424 } else {
425 after = skip_ansi_sequence(src);
426 size_t count = (size_t)(after - src);
427 if ((count == 4 && memcmp(src, "\033[0m", 4) == 0) || (count == 3 && memcmp(src, "\033[m", 3) == 0)) {
428 foreground_luminance = 1.0f;
429 has_background = false;
430 }
431 memcpy(dst, src, count);
432 dst += count;
433 remaining -= count;
434 src = after;
435 }
436 continue;
437 }
438 if (*src == '\n' || *src == '\r') {
439 if (*src == '\n')
440 row++;
441 col = 0;
442 *dst++ = *src++;
443 remaining--;
444 continue;
445 }
446
447 float head;
448 float brightness = get_rain_brightness(rain, col, row, sim_time, &head);
449 // Update once per cell, independently of how many ANSI sequences precede it.
450 if (row < rain->num_rows && col < rain->num_columns) {
451 size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
452 if (!rain->first_frame)
453 brightness = rain->previous_brightness[idx] + (brightness - rain->previous_brightness[idx]) * alpha;
454 rain->previous_brightness[idx] = brightness;
455 }
456 int count = generate_rain_color(dst, remaining, rain, brightness, head, foreground_luminance, true);
457 colored = true;
458 dst += count;
459 remaining -= (size_t)count;
460 if (has_background) {
461 count = generate_rain_color(dst, remaining, rain, brightness, head, background_luminance, false);
462 dst += count;
463 remaining -= (size_t)count;
464 }
465 uint32_t codepoint;
466 int bytes = utf8_decode((const uint8_t *)src, &codepoint);
467 if (bytes <= 0) {
468 bytes = 1;
469 codepoint = (uint8_t)*src;
470 }
471 if (bytes == 1 && codepoint > 32 && codepoint < 127) {
472 *dst++ = (char)mutate_glyph(codepoint, col, row, sim_time);
473 src++;
474 remaining--;
475 } else {
476 memcpy(dst, src, (size_t)bytes);
477 dst += bytes;
478 src += bytes;
479 remaining -= (size_t)bytes;
480 }
481 col++;
482 }
483 // Monochrome input has no trailing SGR reset to copy. The effect introduces
484 // colors itself, so every colored result must restore terminal attributes.
485 if (colored) {
486 const char reset[] = "\033[0m";
487 if (remaining < sizeof(reset)) {
488 SAFE_FREE(output);
489 return NULL;
490 }
491 memcpy(dst, reset, sizeof(reset));
492 } else {
493 *dst = '\0';
494 }
495 rain->first_frame = false;
496 return output;
497}
unsigned int uint32_t
#define SAFE_FREE(ptr)
#define SAFE_MALLOC(size, cast)
unsigned char uint8_t
#define log_error(...)
Log an ERROR message.
Definition log/log.h:628
int utf8_decode(const uint8_t *s, uint32_t *codepoint)
Decode a UTF-8 sequence to a Unicode codepoint.
Definition utf8.c:27
void color_filter_calculate_rainbow(float time, uint8_t *r, uint8_t *g, uint8_t *b)
Calculate rainbow color from time (3.5s cycle).
uint8_t color_g
Matrix green G component.
uint8_t color_b
Matrix green B component.
float brightness_decay
Brightness smoothing factor (0-1).
float time
Current simulation time (accumulated).
uint8_t color_r
Matrix green R component.
bool first_frame
True if this is the first frame.
bool rainbow_mode
True if rainbow color cycling is enabled.
float * previous_brightness
Previous frame brightness (for smoothing).
int num_columns
Number of columns in grid.

References digital_rain::brightness_decay, digital_rain::color_b, color_filter_calculate_rainbow(), digital_rain::color_g, digital_rain::color_r, digital_rain::first_frame, log_error, digital_rain::num_columns, digital_rain::previous_brightness, digital_rain::rainbow_mode, SAFE_FREE, SAFE_MALLOC, digital_rain::time, and utf8_decode().

Referenced by animation_apply().