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
#define	SQRT_2   1.4142135623730951
#define	SQRT_5   2.23606797749979

Functions
digital_rain_t *	digital_rain_init (int num_columns, int num_rows)
void	digital_rain_destroy (digital_rain_t *rain)
void	digital_rain_reset (digital_rain_t *rain)
void	digital_rain_set_fall_speed (digital_rain_t *rain, float speed)
void	digital_rain_set_raindrop_length (digital_rain_t *rain, float length)
void	digital_rain_set_color (digital_rain_t *rain, uint8_t r, uint8_t g, uint8_t b)
void	digital_rain_set_color_from_filter (digital_rain_t *rain, color_filter_t filter)
char *	digital_rain_apply (digital_rain_t *rain, const char *frame, float delta_time)

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 22 of file digital_rain.c.

SQRT_2

#define SQRT_2   1.4142135623730951

Definition at line 25 of file digital_rain.c.

SQRT_5

#define SQRT_5   2.23606797749979

Definition at line 26 of file digital_rain.c.

Function Documentation

digital_rain_apply()

char * digital_rain_apply	(	digital_rain_t *	rain,
		const char *	frame,
		float	delta_time
	)

Definition at line 369 of file digital_rain.c.

                                                                                    {
  if (!rain || !frame) {
    log_error("digital_rain_apply: NULL parameter");
    return NULL;
  }
 
  // Update time
  rain->time += delta_time * rain->animation_speed;
  float sim_time = rain->time;
 
  // Update rainbow color if rainbow mode is enabled
  if (rain->rainbow_mode) {
    color_filter_calculate_rainbow(sim_time, &rain->color_r, &rain->color_g, &rain->color_b);
  }
 
  // Allocate output buffer (input size + overhead for ANSI codes)
  // Estimate: each character might need up to 20 bytes for ANSI codes
  size_t input_len = strlen(frame);
  size_t output_capacity = input_len * 20 + 1024;
  char *output = SAFE_MALLOC(output_capacity, char *);
  if (!output) {
    log_error("digital_rain_apply: failed to allocate output buffer");
    return NULL;
  }
 
  const char *src = frame;
  char *dst = output;
  size_t remaining = output_capacity;
 
  int col = 0;
  int row = 0;
 
  while (*src && remaining > 100) {
    // Try to parse and modify ANSI color sequences
    if (*src == '\033') {
      int r, g, b;
      bool is_foreground;
      const char *after = parse_ansi_color(src, &r, &g, &b, &is_foreground);
 
      if (after) {
        // Found a color sequence - calculate brightness for this position
        float brightness = get_rain_brightness(rain, col, row, sim_time);
        float brightness_below = get_rain_brightness(rain, col, row + 1, sim_time);
        bool is_cursor = brightness > brightness_below;
 
        // Blend with previous brightness for smooth transitions
        if (!rain->first_frame && row < rain->num_rows && col < rain->num_columns) {
          size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
          float prev_brightness = rain->previous_brightness[idx];
          brightness = prev_brightness + (brightness - prev_brightness) * rain->brightness_decay;
          rain->previous_brightness[idx] = brightness;
        } else if (row < rain->num_rows && col < rain->num_columns) {
          size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
          rain->previous_brightness[idx] = brightness;
        }
 
        // Generate modulated color
        char ansi_buf[32];
        int ansi_len =
            generate_modulated_color(ansi_buf, sizeof(ansi_buf), r, g, b, brightness, is_foreground, is_cursor);
 
        if ((size_t)ansi_len < remaining) {
          memcpy(dst, ansi_buf, (size_t)ansi_len);
          dst += ansi_len;
          remaining -= (size_t)ansi_len;
        }
 
        src = after;
        continue;
      } else {
        // Not a color sequence - copy as-is
        const char *after_skip = skip_ansi_sequence(src);
        size_t ansi_len = (size_t)(after_skip - src);
        if (ansi_len < remaining) {
          memcpy(dst, src, ansi_len);
          dst += ansi_len;
          remaining -= ansi_len;
          src = after_skip;
        } else {
          break;
        }
        continue;
      }
    }
 
    // Handle newline
    if (*src == '\n') {
      *dst++ = *src++;
      remaining--;
      row++;
      col = 0;
      continue;
    }
 
    // Copy regular characters - inject color for non-colored characters
    if (remaining > 0) {
      // Calculate brightness for this position
      float brightness = get_rain_brightness(rain, col, row, sim_time);
      float brightness_below = get_rain_brightness(rain, col, row + 1, sim_time);
      bool is_cursor = brightness > brightness_below;
 
      // Blend with previous brightness
      if (!rain->first_frame && row < rain->num_rows && col < rain->num_columns) {
        size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
        float prev_brightness = rain->previous_brightness[idx];
        brightness = prev_brightness + (brightness - prev_brightness) * rain->brightness_decay;
        rain->previous_brightness[idx] = brightness;
      } else if (row < rain->num_rows && col < rain->num_columns) {
        size_t idx = (size_t)row * (size_t)rain->num_columns + (size_t)col;
        rain->previous_brightness[idx] = brightness;
      }
 
      // For characters without explicit color codes, use the rain's default color
      char ansi_buf[32];
      int ansi_len = generate_modulated_color(ansi_buf, sizeof(ansi_buf), rain->color_r, rain->color_g, rain->color_b,
                                              brightness, true, is_cursor);
 
      if ((size_t)ansi_len < remaining) {
        memcpy(dst, ansi_buf, (size_t)ansi_len);
        dst += ansi_len;
        remaining -= (size_t)ansi_len;
      }
 
      // Decode UTF-8 character to get byte length
      uint32_t codepoint;
      int utf8_len = utf8_decode((const uint8_t *)src, &codepoint);
      if (utf8_len < 0) {
        // Invalid UTF-8, treat as single byte
        utf8_len = 1;
      }
 
      // Copy all bytes of the UTF-8 character
      for (int i = 0; i < utf8_len && *src && remaining > 0; i++) {
        *dst++ = *src++;
        remaining--;
      }
 
      // Only increment column once per character (not per byte)
      col++;
    } else {
      break;
    }
  }
 
  // Null-terminate
  if (remaining > 0) {
    *dst = '\0';
  } else {
    output[output_capacity - 1] = '\0';
  }
 
  rain->first_frame = false;
  return output;
}

References color_filter_calculate_rainbow(), and utf8_decode().

Referenced by mirror_convert_frame(), and session_display_convert_to_ascii().

digital_rain_destroy()

void digital_rain_destroy

(

digital_rain_t *

rain

)

Definition at line 154 of file digital_rain.c.

                                                {
  if (!rain) {
    return;
  }
 
  SAFE_FREE(rain->columns);
  SAFE_FREE(rain->previous_brightness);
  SAFE_FREE(rain);
}

Referenced by mirror_cleanup(), mirror_convert_frame(), and session_display_destroy().

digital_rain_init()

digital_rain_t * digital_rain_init	(	int	num_columns,
		int	num_rows
	)

Definition at line 96 of file digital_rain.c.

                                                                 {
  if (num_columns <= 0 || num_rows <= 0) {
    log_error("digital_rain_init: invalid dimensions %dx%d", num_columns, num_rows);
    return NULL;
  }
 
  digital_rain_t *rain = SAFE_CALLOC(1, sizeof(digital_rain_t), digital_rain_t *);
  if (!rain) {
    log_error("digital_rain_init: failed to allocate context");
    return NULL;
  }
 
  rain->num_columns = num_columns;
  rain->num_rows = num_rows;
 
  // Allocate column state array
  rain->columns = SAFE_CALLOC((size_t)num_columns, sizeof(digital_rain_column_t), digital_rain_column_t *);
  if (!rain->columns) {
    log_error("digital_rain_init: failed to allocate column array");
    SAFE_FREE(rain);
    return NULL;
  }
 
  // Allocate previous brightness array
  size_t grid_size = (size_t)num_columns * (size_t)num_rows;
  rain->previous_brightness = SAFE_CALLOC(grid_size, sizeof(float), float *);
  if (!rain->previous_brightness) {
    log_error("digital_rain_init: failed to allocate brightness array");
    SAFE_FREE(rain->columns);
    SAFE_FREE(rain);
    return NULL;
  }
 
  // Initialize per-column random offsets
  for (int col = 0; col < num_columns; col++) {
    digital_rain_column_t *column = &rain->columns[col];
    column->time_offset = random_float((float)col, 0.0f) * 1000.0f;
    column->speed_multiplier = random_float((float)col + 0.1f, 0.0f) * 0.5f + 0.5f;
    column->phase_offset = random_float((float)col + 0.2f, 0.0f) * (float)M_PI * 2.0f;
  }
 
  // Set default parameters
  rain->fall_speed = DIGITAL_RAIN_DEFAULT_FALL_SPEED;
  rain->raindrop_length = DIGITAL_RAIN_DEFAULT_RAINDROP_LENGTH;
  rain->brightness_decay = DIGITAL_RAIN_DEFAULT_BRIGHTNESS_DECAY;
  rain->animation_speed = DIGITAL_RAIN_DEFAULT_ANIMATION_SPEED;
  rain->color_r = DIGITAL_RAIN_DEFAULT_COLOR_R;
  rain->color_g = DIGITAL_RAIN_DEFAULT_COLOR_G;
  rain->color_b = DIGITAL_RAIN_DEFAULT_COLOR_B;
  rain->cursor_brightness = DIGITAL_RAIN_DEFAULT_CURSOR_BRIGHTNESS;
  rain->rainbow_mode = false;
  rain->first_frame = true;
  rain->time = 0.0f;
 
  log_info("Digital rain initialized: %dx%d grid", num_columns, num_rows);
  return rain;
}

References M_PI.

Referenced by mirror_convert_frame(), and session_display_create().

digital_rain_reset()

void digital_rain_reset

(

digital_rain_t *

rain

)

Definition at line 164 of file digital_rain.c.

                                              {
  if (!rain) {
    return;
  }
 
  rain->time = 0.0f;
  rain->first_frame = true;
 
  // Clear previous brightness
  size_t grid_size = (size_t)rain->num_columns * (size_t)rain->num_rows;
  memset(rain->previous_brightness, 0, grid_size * sizeof(float));
}

digital_rain_set_color()

void digital_rain_set_color	(	digital_rain_t *	rain,
		uint8_t	r,
		uint8_t	g,
		uint8_t	b
	)

Definition at line 193 of file digital_rain.c.

                                                                                   {
  if (rain) {
    rain->color_r = r;
    rain->color_g = g;
    rain->color_b = b;
  }
}

Referenced by digital_rain_set_color_from_filter().

digital_rain_set_color_from_filter()

void digital_rain_set_color_from_filter	(	digital_rain_t *	rain,
		color_filter_t	filter
	)

Definition at line 201 of file digital_rain.c.

                                                                                     {
  if (!rain) {
    return;
  }
 
  // If no filter is set, use default Matrix green
  if (filter == COLOR_FILTER_NONE) {
    rain->rainbow_mode = false;
    digital_rain_set_color(rain, DIGITAL_RAIN_DEFAULT_COLOR_R, DIGITAL_RAIN_DEFAULT_COLOR_G,
                           DIGITAL_RAIN_DEFAULT_COLOR_B);
    return;
  }
 
  // Rainbow mode: enable dynamic color cycling
  if (filter == COLOR_FILTER_RAINBOW) {
    rain->rainbow_mode = true;
    // Set initial color to red (will be overridden during rendering)
    digital_rain_set_color(rain, 255, 0, 0);
    return;
  }
 
  // Get color from filter metadata
  rain->rainbow_mode = false;
  const color_filter_def_t *filter_def = color_filter_get_metadata(filter);
  if (filter_def) {
    digital_rain_set_color(rain, filter_def->r, filter_def->g, filter_def->b);
  }
}

References color_filter_get_metadata(), and digital_rain_set_color().

Referenced by mirror_convert_frame(), and session_display_create().

digital_rain_set_fall_speed()

void digital_rain_set_fall_speed	(	digital_rain_t *	rain,
		float	speed
	)

Definition at line 181 of file digital_rain.c.

                                                                    {
  if (rain) {
    rain->fall_speed = speed;
  }
}

digital_rain_set_raindrop_length()

void digital_rain_set_raindrop_length	(	digital_rain_t *	rain,
		float	length
	)

Definition at line 187 of file digital_rain.c.

                                                                          {
  if (rain) {
    rain->raindrop_length = length;
  }
}