colors.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
  1. /* colors command: full-screen animated rainbow in VESA LFB. Target 30fps (matches flush rate). Press ESC to return. */
  2. #include "fbtext.h"
  3. #include "io.h"
  4. #include "timer.h"
  5. #include "vga.h"
  6. #define RAINBOW_SEG 256
  7. #define RAINBOW_FULL (6 * RAINBOW_SEG)
  8. #define FRAME_MS 33 /* matches 30Hz flush rate */
  9. #define PHASE_STEP 32
  10. /* FPS overlay: 7 chars × 8 px wide, 8 px tall. Rainbow must not draw here. */
  11. #define FPS_RECT_W (7 * 8)
  12. #define FPS_RECT_H 8
  13. /* Precomputed hue-to-RGB lookup table. Packed as 0x00BBGGRR for fast 32-bit load.
  14. * The hue cycle is RAINBOW_FULL entries, but the table is decimated by
  15. * LUT_STEP: a 4-hue step is ~1.5% of a color segment and invisible, and the
  16. * smaller table keeps the kernel image under the 0x49000 memory-bound. */
  17. #define LUT_STEP 4
  18. #define LUT_SIZE (RAINBOW_FULL / LUT_STEP)
  19. static unsigned int hue_lut[LUT_SIZE];
  20. static void build_hue_lut(void)
  21. {
  22. unsigned int i;
  23. for (i = 0; i < LUT_SIZE; i++) {
  24. unsigned int hue = i * LUT_STEP;
  25. unsigned int seg = hue / RAINBOW_SEG;
  26. unsigned int f = hue % RAINBOW_SEG;
  27. unsigned int r1, g1, b1, r2, g2, b2;
  28. if (seg >= 6)
  29. seg = 0;
  30. switch (seg) {
  31. case 0: r1=255; g1=0; b1=0; r2=255; g2=255; b2=0; break;
  32. case 1: r1=255; g1=255; b1=0; r2=0; g2=255; b2=0; break;
  33. case 2: r1=0; g1=255; b1=0; r2=0; g2=255; b2=255; break;
  34. case 3: r1=0; g1=255; b1=255; r2=0; g2=0; b2=255; break;
  35. case 4: r1=0; g1=0; b1=255; r2=255; g2=0; b2=255; break;
  36. default: r1=255; g1=0; b1=255; r2=255; g2=0; b2=0; break;
  37. }
  38. unsigned int r = (r1 * (RAINBOW_SEG - f) + r2 * f) / RAINBOW_SEG;
  39. unsigned int g = (g1 * (RAINBOW_SEG - f) + g2 * f) / RAINBOW_SEG;
  40. unsigned int b = (b1 * (RAINBOW_SEG - f) + b2 * f) / RAINBOW_SEG;
  41. hue_lut[i] = b | (g << 8) | (r << 16);
  42. }
  43. }
  44. static void draw_frame(unsigned char *fb, unsigned int w, unsigned int h,
  45. unsigned int pitch, unsigned int bpp, unsigned int phase)
  46. {
  47. unsigned int scale_x = RAINBOW_FULL / (w ? w : 1);
  48. unsigned int scale_y = RAINBOW_FULL / (h ? h : 1);
  49. unsigned int y;
  50. for (y = 0; y < h; y++) {
  51. unsigned int row_hue = (phase + y * scale_y) % RAINBOW_FULL;
  52. unsigned char *row = fb + (unsigned long)y * pitch;
  53. if (y < FPS_RECT_H) {
  54. /* Skip FPS rect columns */
  55. unsigned int x;
  56. if (bpp == 32) {
  57. unsigned int *p = (unsigned int *)row;
  58. for (x = 0; x < w; x++) {
  59. if (x >= FPS_RECT_W) {
  60. unsigned int packed = hue_lut[row_hue / LUT_STEP];
  61. *p = packed;
  62. }
  63. p++;
  64. row_hue += scale_x;
  65. if (row_hue >= RAINBOW_FULL)
  66. row_hue -= RAINBOW_FULL;
  67. }
  68. } else if (bpp == 24) {
  69. for (x = 0; x < w; x++) {
  70. if (x >= FPS_RECT_W) {
  71. unsigned int packed = hue_lut[row_hue / LUT_STEP];
  72. row[x * 3] = (unsigned char)(packed & 0xFF);
  73. row[x * 3 + 1] = (unsigned char)((packed >> 8) & 0xFF);
  74. row[x * 3 + 2] = (unsigned char)((packed >> 16) & 0xFF);
  75. }
  76. row_hue += scale_x;
  77. if (row_hue >= RAINBOW_FULL)
  78. row_hue -= RAINBOW_FULL;
  79. }
  80. } else if (bpp == 16) {
  81. for (x = 0; x < w; x++) {
  82. if (x >= FPS_RECT_W) {
  83. unsigned int packed = hue_lut[row_hue / LUT_STEP];
  84. unsigned int r = (packed >> 16) & 0xFF;
  85. unsigned int g = (packed >> 8) & 0xFF;
  86. unsigned int b = packed & 0xFF;
  87. unsigned int rgb16 = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
  88. unsigned short *p = (unsigned short *)(row + x * 2);
  89. *p = (unsigned short)rgb16;
  90. }
  91. row_hue += scale_x;
  92. if (row_hue >= RAINBOW_FULL)
  93. row_hue -= RAINBOW_FULL;
  94. }
  95. }
  96. } else {
  97. /* Full row, no FPS rect check — tight inner loop */
  98. unsigned int x;
  99. if (bpp == 32) {
  100. unsigned int *p = (unsigned int *)row;
  101. for (x = 0; x < w; x++) {
  102. *p++ = hue_lut[row_hue / LUT_STEP];
  103. row_hue += scale_x;
  104. if (row_hue >= RAINBOW_FULL)
  105. row_hue -= RAINBOW_FULL;
  106. }
  107. } else if (bpp == 24) {
  108. for (x = 0; x < w; x++) {
  109. unsigned int packed = hue_lut[row_hue / LUT_STEP];
  110. row[x * 3] = (unsigned char)(packed & 0xFF);
  111. row[x * 3 + 1] = (unsigned char)((packed >> 8) & 0xFF);
  112. row[x * 3 + 2] = (unsigned char)((packed >> 16) & 0xFF);
  113. row_hue += scale_x;
  114. if (row_hue >= RAINBOW_FULL)
  115. row_hue -= RAINBOW_FULL;
  116. }
  117. } else if (bpp == 16) {
  118. for (x = 0; x < w; x++) {
  119. unsigned int packed = hue_lut[row_hue / LUT_STEP];
  120. unsigned int r = (packed >> 16) & 0xFF;
  121. unsigned int g = (packed >> 8) & 0xFF;
  122. unsigned int b = packed & 0xFF;
  123. unsigned int rgb16 = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
  124. unsigned short *p = (unsigned short *)(row + x * 2);
  125. *p = (unsigned short)rgb16;
  126. row_hue += scale_x;
  127. if (row_hue >= RAINBOW_FULL)
  128. row_hue -= RAINBOW_FULL;
  129. }
  130. }
  131. }
  132. }
  133. }
  134. #define FPS_BUF_SIZE 8
  135. static void format_fps(unsigned int fps, char *buf)
  136. {
  137. unsigned int f = fps;
  138. if (f > 999)
  139. f = 999;
  140. buf[0] = (char)('0' + (f / 100));
  141. buf[1] = (char)('0' + ((f / 10) % 10));
  142. buf[2] = (char)('0' + (f % 10));
  143. buf[3] = ' ';
  144. buf[4] = 'f';
  145. buf[5] = 'p';
  146. buf[6] = 's';
  147. buf[7] = '\0';
  148. }
  149. void program_colors_main(void)
  150. {
  151. unsigned char *fb;
  152. unsigned int w, h, pitch, bpp;
  153. unsigned int phase = 0;
  154. unsigned int frame_start;
  155. unsigned int frame_count = 0;
  156. unsigned int last_fps_ticks;
  157. unsigned int displayed_fps = 0;
  158. char fps_buf[FPS_BUF_SIZE];
  159. if (!vga_has_vesa())
  160. return;
  161. build_hue_lut();
  162. fb = (unsigned char *)vga_fb_ptr();
  163. if (!fb)
  164. return;
  165. w = vga_fb_width();
  166. h = vga_fb_height();
  167. pitch = vga_fb_pitch();
  168. bpp = vga_fb_bpp();
  169. if (bpp != 16 && bpp != 24 && bpp != 32)
  170. return;
  171. io_drain_keyboard();
  172. last_fps_ticks = get_ticks_ms();
  173. for (;;) {
  174. frame_start = get_ticks_ms();
  175. if (io_poll_key() == 0x1B)
  176. break;
  177. draw_frame(fb, w, h, pitch, bpp, phase);
  178. phase = (phase + PHASE_STEP) % RAINBOW_FULL;
  179. /* Mark all rows dirty since we drew the full screen */
  180. vga_fb_mark_dirty_rect(0, h);
  181. /* Trigger flush so the 30Hz timer sees dirty rows */
  182. vga_fb_flush_pending_check();
  183. frame_count++;
  184. if (get_ticks_ms() - last_fps_ticks >= 1000) {
  185. displayed_fps = frame_count;
  186. frame_count = 0;
  187. last_fps_ticks = get_ticks_ms();
  188. }
  189. format_fps(displayed_fps, fps_buf);
  190. fbtext_draw_string_xy(0, 0, fps_buf, 255, 255, 255, 0);
  191. /* Sleep with hlt to give the system breathing room */
  192. while (get_ticks_ms() - frame_start < FRAME_MS)
  193. __asm__ volatile ("hlt");
  194. }
  195. }