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