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