git.mutantstargoat.com Git - dosdemo/blob - src/screen.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <assert.h>
   5 #include "screen.h"
   6 #include "demo.h"
   7 #include "gfxutil.h"
   8 #include "timer.h"
   9
  10 #define DBG_SCRCHG \
  11         do { \
  12                 dbg_curscr_name = cur->name ? cur->name : "<unknown>"; \
  13                 dbg_curscr_name_len = strlen(dbg_curscr_name); \
  14                 dbg_curscr_name_pos = 320 - dbg_curscr_name_len * 9; \
  15         } while(0)
  16
  17 struct screen *tunnel_screen(void);
  18 struct screen *fract_screen(void);
  19 struct screen *grise_screen(void);
  20 struct screen *polytest_screen(void);
  21 struct screen *plasma_screen(void);
  22 struct screen *bump_screen(void);
  23 struct screen *thunder_screen(void);
  24 struct screen *metaballs_screen(void);
  25 struct screen *greets_screen(void);
  26 struct screen *infcubes_screen(void);
  27 struct screen *hairball_screen(void);
  28 struct screen *cybersun_screen(void);
  29 struct screen *raytrace_screen(void);
  30
  31 void start_loadscr(void);
  32 void end_loadscr(void);
  33 void loadscr(int n, int count);
  34
  35 #define NUM_SCR 32
  36 static struct screen *scr[NUM_SCR];
  37 static int num_screens;
  38
  39 static struct screen *cur, *prev, *next;
  40 static long trans_start, trans_dur;
  41
  42 const char *dbg_curscr_name;
  43 int dbg_curscr_name_len, dbg_curscr_name_pos;
  44
  45 int scr_init(void)
  46 {
  47         int i, idx = 0;
  48
  49         start_loadscr();
  50
  51         if(!(scr[idx++] = tunnel_screen())) {
  52                 return -1;
  53         }
  54         if(!(scr[idx++] = fract_screen())) {
  55                 return -1;
  56         }
  57         if (!(scr[idx++] = grise_screen())) {
  58                 return -1;
  59         }
  60         if(!(scr[idx++] = polytest_screen())) {
  61                 return -1;
  62         }
  63         if (!(scr[idx++] = plasma_screen())) {
  64                 return -1;
  65         }
  66         if (!(scr[idx++] = bump_screen())) {
  67                 return -1;
  68         }
  69         if (!(scr[idx++] = thunder_screen())) {
  70                 return -1;
  71         }
  72         if(!(scr[idx++] = metaballs_screen())) {
  73                 return -1;
  74         }
  75         if(!(scr[idx++] = greets_screen())) {
  76                 return -1;
  77         }
  78         if(!(scr[idx++] = infcubes_screen())) {
  79                 return -1;
  80         }
  81         if(!(scr[idx++] = hairball_screen())) {
  82                 return -1;
  83         }
  84         if(!(scr[idx++] = cybersun_screen())) {
  85                 return -1;
  86         }
  87         if(!(scr[idx++] = raytrace_screen())) {
  88                 return -1;
  89         }
  90         num_screens = idx;
  91
  92         assert(num_screens <= NUM_SCR);
  93
  94         for(i=0; i<num_screens; i++) {
  95                 loadscr(i, num_screens);
  96                 if(scr[i]->init() == -1) {
  97                         return -1;
  98                 }
  99         }
 100
 101         end_loadscr();
 102         return 0;
 103 }
 104
 105 void scr_shutdown(void)
 106 {
 107         int i;
 108         for(i=0; i<num_screens; i++) {
 109                 scr[i]->shutdown();
 110         }
 111 }
 112
 113 void scr_update(void)
 114 {
 115         if(prev) {  /* we're in the middle of a transition */
 116                 long interval = time_msec - trans_start;
 117                 if(interval >= trans_dur) {
 118                         if(next->start) {
 119                                 next->start(trans_dur);
 120                         }
 121                         prev = 0;
 122                         cur = next;
 123                         next = 0;
 124
 125                         DBG_SCRCHG;
 126                 }
 127         }
 128 }
 129
 130
 131 void scr_draw(void)
 132 {
 133         if(cur) {
 134                 cur->draw();
 135         }
 136 }
 137
 138 void scr_keypress(int key)
 139 {
 140         if(cur && cur->keypress) {
 141                 cur->keypress(key);
 142         }
 143 }
 144
 145 struct screen *scr_lookup(const char *name)
 146 {
 147         int i;
 148         for(i=0; i<num_screens; i++) {
 149                 if(strcmp(scr[i]->name, name) == 0) {
 150                         return scr[i];
 151                 }
 152         }
 153         return 0;
 154 }
 155
 156 struct screen *scr_screen(int idx)
 157 {
 158         return scr[idx];
 159 }
 160
 161 int scr_num_screens(void)
 162 {
 163         return num_screens;
 164 }
 165
 166 int scr_change(struct screen *s, long trans_time)
 167 {
 168         if(!s) return -1;
 169         if(s == cur) return 0;
 170
 171         if(trans_time) {
 172                 trans_dur = trans_time / 2; /* half for each part transition out then in */
 173                 trans_start = time_msec;
 174         } else {
 175                 trans_dur = 0;
 176         }
 177
 178         if(cur && cur->stop) {
 179                 cur->stop(trans_dur);
 180                 prev = cur;
 181                 next = s;
 182         } else {
 183                 if(s->start) {
 184                         s->start(trans_dur);
 185                 }
 186
 187                 cur = s;
 188                 prev = 0;
 189
 190                 DBG_SCRCHG;
 191         }
 192         return 0;
 193 }
 194
 195 /* loading screen */
 196 extern uint16_t loading_pixels[];
 197 static long prev_load_msec;
 198 static long load_delay;
 199
 200 void start_loadscr(void)
 201 {
 202         char *env;
 203         if((env = getenv("MLAPSE_LOADDELAY"))) {
 204                 load_delay = atoi(env);
 205                 printf("load delay: %ld ms\n", load_delay);
 206         }
 207
 208         swap_buffers(loading_pixels);
 209         if(load_delay) {
 210                 sleep_msec(load_delay * 2);
 211         }
 212         prev_load_msec = get_msec();
 213 }
 214
 215 #define SPLAT_X 288
 216 #define SPLAT_Y 104
 217
 218 #define FING_X  217
 219 #define FING_LAST_X     291
 220 #define FING_Y  151
 221 #define FING_W  7
 222 #define FING_H  8
 223
 224 void end_loadscr(void)
 225 {
 226         blitfb(loading_pixels + SPLAT_Y * 320 + SPLAT_X, loading_pixels + 320 * 240, 32, 72, 32);
 227         blit_key(loading_pixels + FING_Y * 320 + FING_LAST_X, 320, loading_pixels + 247 * 320 + 64, FING_W, FING_H, FING_W, 0);
 228         swap_buffers(loading_pixels);
 229         if(load_delay) {
 230                 sleep_msec(load_delay * 3);
 231         }
 232 }
 233
 234 void loadscr(int n, int count)
 235 {
 236         int xoffs = 75 * n / (count - 1);
 237         static int prev_xoffs;
 238         uint16_t *sptr, *dptr;
 239         long delta;
 240
 241         sptr = loading_pixels + 247 * 320 + 64;
 242         dptr = loading_pixels + FING_Y * 320 + FING_X + prev_xoffs;
 243
 244         while(prev_xoffs < xoffs) {
 245                 blit_key(dptr, 320, sptr, FING_W, FING_H, FING_W, 0);
 246                 dptr++;
 247                 prev_xoffs++;
 248         }
 249
 250         swap_buffers(loading_pixels);
 251
 252         delta = get_msec() - prev_load_msec;
 253         if(delta < load_delay) {
 254                 sleep_msec(load_delay - delta);
 255         }
 256         prev_load_msec = get_msec();
 257 }