colors.c 6.3 KB

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