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