![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ui-console.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / main|
Return to ui-console.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / main |
1.1 ! root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */ ! 2: ! 3: /* generic 640x480 console mode */ ! 4: ! 5: /* I call the first field the even field and the second field the odd field, ! 6: sorry - I counted lines from 0 when I wrote the code... strictly speaking ! 7: this is confusing... (it confuses me) */ ! 8: ! 9: #include <sys/types.h> ! 10: #include <sys/stat.h> ! 11: #include <fcntl.h> ! 12: #include <stdlib.h> ! 13: #include <stdio.h> ! 14: #include <stdarg.h> ! 15: #include <time.h> ! 16: #include <string.h> ! 17: #include <unistd.h> ! 18: #include <errno.h> ! 19: ! 20: #include "generator.h" ! 21: #include "snprintf.h" ! 22: ! 23: #include "cpu68k.h" ! 24: #include "cpuz80.h" ! 25: #include "ui.h" ! 26: #include "vdp.h" ! 27: #include "event.h" ! 28: #include "gensound.h" ! 29: #include "mem68k.h" ! 30: #include "logo.h" ! 31: #include "font.h" ! 32: #include "uip.h" ! 33: #include "ui-console.h" ! 34: #include "state.h" ! 35: ! 36: #define UI_LOGLINESIZE 128 ! 37: #define UI_LOGLINES 64 ! 38: ! 39: uint32 ui_fkeys = 0; ! 40: ! 41: uint8 ui_vdpsimple = 0; /* 0=raster, 1=cell based plotter */ ! 42: uint8 ui_clearnext = 0; /* flag indicating redraw required */ ! 43: uint8 ui_fullscreen = 0; /* does the user want full screen or not */ ! 44: uint8 ui_info = 1; /* does the user want info onscreen or not */ ! 45: uint8 ui_vsync = 0; /* does the user want us to wait for vsync */ ! 46: t_interlace ui_interlace = DEINTERLACE_WEAVEFILTER; /* type of de-interlace */ ! 47: ! 48: /*** forward reference declarations ***/ ! 49: ! 50: static void ui_usage(void); ! 51: static void ui_plotline(unsigned int line, uint8 *gfx); ! 52: void ui_exithandler(void); ! 53: void ui_newframe(void); ! 54: void ui_convertdata(uint8 *indata, uint16 *outdata, unsigned int pixels); ! 55: void ui_plotsprite_acorn(uint16 *logo, uint16 width, uint16 height, ! 56: uint16 x, uint16 y); ! 57: int ui_unpackfont(void); ! 58: uint16 ui_plotstring(const char *text, uint16 xpos, uint16 ypos); ! 59: uint16 ui_plotint2(uint8 num, uint16 xpos, uint16 ypos); ! 60: void ui_plotsettings(void); ! 61: void ui_drawbox(uint16 colour, uint16 x, uint16 y, uint16 width, ! 62: uint16 height); ! 63: void ui_rendertoscreen(void); ! 64: void ui_render_x1(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 65: unsigned int linewidth, unsigned int pixels); ! 66: void ui_render_x2(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 67: unsigned int linewidth, unsigned int pixels); ! 68: void ui_render_x2h(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 69: unsigned int linewidth, unsigned int pixels); ! 70: void ui_irender_weavefilter(uint16 *evendata, uint16 *odddata, uint8 *screen, ! 71: unsigned int linewidth, unsigned int pixels); ! 72: void ui_basicbits(void); ! 73: void ui_licensescreen(void); ! 74: void ui_imagescreen(void); ! 75: void ui_imagescreen_main(void); ! 76: void ui_statescreen(void); ! 77: void ui_statescreen_main(void); ! 78: int ui_statescreen_loadsavestate(int save); ! 79: void ui_resetscreen(void); ! 80: void ui_resetscreen_main(void); ! 81: int ui_saveimage(const char *type, char *filename, int buflen, ! 82: int *xsize, int *ysize); ! 83: int ui_setcolourbits(const char *str); ! 84: ! 85: /* we store up log lines and dump them right at the end for allegro */ ! 86: #ifdef ALLEGRO ! 87: void ui_printlog(void); ! 88: #endif ! 89: ! 90: /*** static variables ***/ ! 91: ! 92: static uint8 ui_vga = 0; /* flag for whether in VGA more or not */ ! 93: static uint8 ui_frameskip = 0; /* 0 for dynamic */ ! 94: static uint8 ui_actualskip = 0; /* the last skip we did (1..) */ ! 95: static uint8 ui_state = 0; /* 0=stop, 1=paused, 2=play */ ! 96: static uint32 ui_palcache[192]; ! 97: static char *ui_initload = NULL; /* filename to load on init */ ! 98: static char ui_loglines[UI_LOGLINES][UI_LOGLINESIZE]; ! 99: static uint32 ui_logline = 0; ! 100: static uint8 ui_plotfield = 0; /* flag indicating plotting this field */ ! 101: static uint8 ui_plotprevfield = 0; /* did we plot the previous field? */ ! 102: static uint16 *ui_font; /* unpacked font */ ! 103: static uint8 bigbuffer[8192]; /* stupid no-vsnprintf platforms */ ! 104: static uint16 ui_logcount = 0; /* log counter */ ! 105: static t_uipinfo ui_uipinfo; /* uipinfo filled in by uip 'sub-system' */ ! 106: static uint16 *ui_screen0; /* pointer to screen block for bank 0 */ ! 107: static uint16 *ui_screen1; /* pointer to screen block for bank 1 */ ! 108: static uint16 *ui_newscreen; /* pointer to new screen block */ ! 109: static int ui_saverom; /* flag to save rom and quit */ ! 110: ! 111: static uint16 ui_screen[3][320*240]; /* screen buffers */ ! 112: ! 113: /*** Program entry point ***/ ! 114: ! 115: int ui_init(int argc, char *argv[]) ! 116: { ! 117: int i; ! 118: int ch; ! 119: ! 120: for(i = 0; i < UI_LOGLINES; i++) ! 121: ui_loglines[i][0] = '\0'; ! 122: if (ui_unpackfont() == -1) { ! 123: fprintf(stderr, "Failed to unpack font, out of memory?\n"); ! 124: return 1; ! 125: } ! 126: while ((ch = getopt(argc, argv, "i:c:w:f:sd:v:l:")) != -1) { ! 127: switch (ch) { ! 128: case 'c': /* set colour bit positions */ ! 129: if (ui_setcolourbits(optarg)) { ! 130: fprintf(stderr, "-c option not understood, must be " ! 131: "'red,green,blue'\n"); ! 132: return 1; ! 133: } ! 134: break; ! 135: case 'i': /* de-interlacing mode */ ! 136: if (!strcasecmp(optarg, "bob")) { ! 137: ui_interlace = DEINTERLACE_BOB; ! 138: } else if (!strcasecmp(optarg, "weave")) { ! 139: ui_interlace = DEINTERLACE_WEAVE; ! 140: } else if (!strcasecmp(optarg, "weave-filter")) { ! 141: ui_interlace = DEINTERLACE_WEAVEFILTER; ! 142: } else { ! 143: fprintf(stderr, "-i option not understood, must be " ! 144: "bob|weave|weave-filter\n"); ! 145: return 1; ! 146: } ! 147: break; ! 148: case 'd': /* enable sound debug mode */ ! 149: /* re-write this to cope with comma separated items later */ ! 150: if (!strcasecmp(optarg, "sound")) ! 151: sound_debug = 1; ! 152: break; ! 153: case 's': /* save raw format rom */ ! 154: ui_saverom = 1; ! 155: break; ! 156: case 'l': /* set min fields / audio latency */ ! 157: sound_minfields = atoi(optarg); ! 158: break; ! 159: case 'f': /* set max fields / audio fragments */ ! 160: sound_maxfields = atoi(optarg); ! 161: break; ! 162: case 'k': /* set frame skip */ ! 163: ui_frameskip = atoi(optarg); ! 164: break; ! 165: case 'v': /* set log verbosity level */ ! 166: gen_loglevel = atoi(optarg); ! 167: break; ! 168: case 'w': /* saved game work dir */ ! 169: chdir(optarg); /* for the moment this will do */ ! 170: break; ! 171: case '?': ! 172: default: ! 173: ui_usage(); ! 174: } ! 175: } ! 176: argc-= optind; ! 177: argv+= optind; ! 178: ! 179: if (argc < 1 || argc > 3) ! 180: ui_usage(); ! 181: if ((ui_initload = malloc(strlen(argv[0])+1)) == NULL) { ! 182: fprintf(stderr, "Out of memory\n"); ! 183: return 1; ! 184: } ! 185: strcpy(ui_initload, argv[0]); ! 186: ! 187: if (atexit(ui_exithandler) == -1) { ! 188: LOG_CRITICAL(("Failed to set exit handler")); ! 189: return 1; ! 190: } ! 191: if (uip_init(&ui_uipinfo)) { ! 192: LOG_CRITICAL(("Failed to initialise platform dependent UI")); ! 193: return 1; ! 194: } ! 195: /* ui_newscreen is where the emulation data is rendered to - it is ! 196: then compared with ui_screen0 or ui_screen1 depending on which ! 197: screen bank it is being written to, and the delta changes are sent ! 198: to screen memory. The ui_screenX and ui_newscreen pointers are then ! 199: switched, and the next frame/field begins... */ ! 200: memset(ui_screen[0], 0, sizeof(ui_screen[0])); ! 201: memset(ui_screen[1], 0, sizeof(ui_screen[1])); ! 202: ui_screen0 = ui_screen[0]; ! 203: ui_screen1 = ui_screen[1]; ! 204: ui_newscreen = ui_screen[2]; ! 205: return 0; ! 206: } ! 207: ! 208: void ui_usage(void) ! 209: { ! 210: fprintf(stderr, "Generator is (c) James Ponder 1997-2001, all rights " ! 211: "reserved. " VERSTRING "\n\n"); ! 212: fprintf(stderr, "generator [options] <rom>\n\n"); ! 213: fprintf(stderr, " -v <verbose level> can be: 0 = none, 1 = critical, " ! 214: "2 = normal, 3 = verbose\n"); ! 215: fprintf(stderr, " -d sound - turns on debug mode for sound\n"); ! 216: fprintf(stderr, " -l <sound latency> is the number of video fields worth " ! 217: "of sound to\n try to keep buffered (default 5)\n"); ! 218: fprintf(stderr, " -f <sound fragments> is the number of video fields worth " ! 219: "of sound to\n allow buffered (approx) (default 10)\n"); ! 220: fprintf(stderr, " -w <work dir> indicates where saved games are stored " ! 221: "(default is current dir)\n"); ! 222: fprintf(stderr, " -c [<r>,<g>,<b>] sets the colour bit positions of where " ! 223: "red, green and blue\n 5-bit values should be shifted " ! 224: "to (default 10,5,0 for 15-bit modes)\n"); ! 225: fprintf(stderr, " -i <mode> selects de-interlace mode, one of: bob " ! 226: "weave weave-filter\n"); ! 227: fprintf(stderr, " -k <x> forces the frame step (1=all frames, 2=every other," ! 228: " etc.)\n"); ! 229: fprintf(stderr, " -s will save the ROM to the work directory in raw " ! 230: "format\n\n"); ! 231: fprintf(stderr, " ROM types supported: .rom or .smd interleaved " ! 232: "(autodetected)\n"); ! 233: fprintf(stderr, " Sound latency will be kept between -l and -a values. " ! 234: "If you are having sound\n problems try -l 20 -f 30\n"); ! 235: exit(1); ! 236: } ! 237: ! 238: #ifdef ALLEGRO ! 239: void ui_printlog(void) ! 240: { ! 241: unsigned int i; ! 242: char *p; ! 243: ! 244: printf("**** Last lines logged:\n"); ! 245: for (i = ui_logline; i < (UI_LOGLINES+ui_logline); i++) { ! 246: p = ui_loglines[(i < UI_LOGLINES) ? i : (i-UI_LOGLINES)]; ! 247: if (*p) ! 248: printf("%s\n", p); ! 249: } ! 250: printf("**** END\n"); ! 251: } ! 252: #endif ! 253: ! 254: void ui_exithandler(void) ! 255: { ! 256: if (ui_vga) ! 257: uip_textmode(); ! 258: ui_vga = 0; ! 259: #ifdef ALLEGRO ! 260: ui_printlog(); ! 261: #endif ! 262: } ! 263: ! 264: void ui_final(void) ! 265: { ! 266: if (ui_vga) ! 267: uip_textmode(); ! 268: ui_vga = 0; ! 269: #ifdef ALLEGRO ! 270: ui_printlog(); ! 271: #endif ! 272: } ! 273: ! 274: int ui_setcolourbits(const char *str) ! 275: { ! 276: char *green, *blue; ! 277: char s[32]; ! 278: int r, g, b; ! 279: ! 280: snprintf(s, sizeof(s), "%s", str); ! 281: ! 282: if ((green = strchr(str, ',')) == NULL) ! 283: return -1; ! 284: *green++ = '\0'; ! 285: if ((blue = strchr(green, ',')) == NULL) ! 286: return -1; ! 287: *blue++= '\0'; ! 288: if ((r = atoi(s)) < 0 || r > 15 || ! 289: (g = atoi(green)) < 0 || g > 15 || ! 290: (b = atoi(blue)) < 0 || b > 15) ! 291: return -1; ! 292: if (uip_setcolourbits(r, g, b)) ! 293: return -1; ! 294: return 0; ! 295: } ! 296: ! 297: /*** ui_drawbox - plot a box ***/ ! 298: ! 299: void ui_drawbox(uint16 colour, uint16 x, uint16 y, uint16 width, ! 300: uint16 height) ! 301: { ! 302: uint16 *p, *q; ! 303: unsigned int i; ! 304: ! 305: p = (uint16 *)(ui_uipinfo.screenmem_w+y*ui_uipinfo.linewidth+x*2); ! 306: q = (uint16 *)((uint8 *)p+(height-1)*ui_uipinfo.linewidth); ! 307: for (i = 0; i < width; i++) ! 308: *p++ = *q++ = colour; ! 309: p = (uint16 *)(ui_uipinfo.screenmem_w+y*ui_uipinfo.linewidth+x*2); ! 310: for (i = 0; i < height; i++) { ! 311: p[0] = colour; ! 312: p[width-1] = colour; ! 313: p = (uint16 *)((uint8 *)p+ui_uipinfo.linewidth); ! 314: } ! 315: } ! 316: ! 317: /*** ui_unpackfont - unpack the font file ***/ ! 318: ! 319: int ui_unpackfont(void) ! 320: { ! 321: unsigned int c, y, x; ! 322: unsigned char packed; ! 323: uint16 *cdata; ! 324: ! 325: if ((ui_font = malloc(128*6*10*2)) == NULL) /* 128 chars, 6x, 10y, 16bit */ ! 326: return -1; ! 327: for (c = 0; c < 128; c++) { /* 128 characters */ ! 328: cdata = ui_font+c*6*10; ! 329: for (y = 0; y < 10; y++) { /* 10 pixels height */ ! 330: packed = generator_font[c*10+y]; ! 331: for (x = 0; x < 6; x++) { /* 6 pixels width */ ! 332: *cdata++ = (packed & 1<<(7-x)) ? 0xffff : 0; ! 333: } ! 334: } ! 335: } ! 336: return 0; ! 337: } ! 338: ! 339: /*** ui_plotint2 - plot a 2-char wide integer ***/ ! 340: ! 341: uint16 ui_plotint2(uint8 num, uint16 xpos, uint16 ypos) ! 342: { ! 343: char buf[3]; ! 344: ! 345: buf[0] = '0' + (num / 10) % 10; ! 346: buf[1] = '0' + (num % 10); ! 347: buf[2] = '\0'; ! 348: return ui_plotstring(buf, xpos, ypos); ! 349: } ! 350: ! 351: /*** ui_plotstring - plot a string ***/ ! 352: ! 353: uint16 ui_plotstring(const char *text, uint16 xpos, uint16 ypos) ! 354: { ! 355: const unsigned char *p; ! 356: const uint16 *cdata; ! 357: unsigned int x,y; ! 358: uint16 *scr; ! 359: ! 360: for (p = text; *p; p++) { ! 361: if (*p > 128) ! 362: cdata = ui_font+'.'*6*10; ! 363: else ! 364: cdata = ui_font+(*p)*6*10; ! 365: for (y = 0; y < 10; y++) { ! 366: scr = (uint16 *)(ui_uipinfo.screenmem_w+(ypos+y)*ui_uipinfo.linewidth ! 367: +xpos*2); ! 368: for (x = 0; x < 6; x++) ! 369: *scr++ = *cdata++; ! 370: } ! 371: xpos+= 6; ! 372: } ! 373: return xpos; ! 374: } ! 375: ! 376: /*** ui_plotsprite - plot a sprite ***/ ! 377: ! 378: void ui_plotsprite_acorn(uint16 *logo, uint16 width, uint16 height, ! 379: uint16 x, uint16 y) ! 380: { ! 381: uint16 a, b; ! 382: uint16 *p, *q; ! 383: uint16 word; ! 384: uint8 red, green, blue; ! 385: ! 386: for (b = 0; b < height; b++) { ! 387: p = (uint16 *)(ui_uipinfo.screenmem_w+(y+b)*ui_uipinfo.linewidth+x*2); ! 388: for (a = 0; a < width; a++) { ! 389: word = (((uint8 *)logo)[1]<<8) | ((uint8 *)logo)[0]; ! 390: green = (word>>5) & 0x1f; ! 391: red = word & 0x1f; ! 392: blue = (word>>10) & 0x1f; ! 393: *p++ = red<<ui_uipinfo.redshift | green<<ui_uipinfo.greenshift | ! 394: blue<<ui_uipinfo.blueshift; ! 395: logo++; ! 396: } ! 397: } ! 398: } ! 399: ! 400: /*** ui_setupscreen - plot borders and stuff ***/ ! 401: ! 402: void ui_setupscreen(void) ! 403: { ! 404: uint16 grey = 24<<ui_uipinfo.redshift | 24<<ui_uipinfo.greenshift | ! 405: 24<<ui_uipinfo.blueshift; ! 406: uint16 red = 24<<ui_uipinfo.redshift; ! 407: ! 408: if (!ui_info) { ! 409: if (!ui_fullscreen) { ! 410: ui_drawbox(red, 140, 100, 360, 280); ! 411: ui_drawbox(grey, 141, 101, 358, 278); ! 412: } ! 413: return; ! 414: } ! 415: if (ui_fullscreen) { ! 416: ui_plotstring(":", 622, 470); ! 417: return; ! 418: } ! 419: ui_drawbox(red, 140, 100, 360, 280); ! 420: ui_drawbox(grey, 141, 101, 358, 278); ! 421: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 80); ! 422: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 360); ! 423: ui_drawbox(red, 0, 415, 640, 1); ! 424: ui_drawbox(grey, 0, 416, 640, 1); ! 425: ui_drawbox(red, 0, 65, 640, 1); ! 426: ui_drawbox(grey, 0, 66, 640, 1); ! 427: ; ! 428: /* draw marker for 320x224 box */ ! 429: // ui_drawbox(grey, 160, 128, 320, 224); ! 430: /* draw marker for 320x240 box */ ! 431: // ui_drawbox(grey, 160, 120, 320, 240); ! 432: /* draw marker for 256x224 box */ ! 433: // ui_drawbox(grey, 192, 128, 256, 224); ! 434: /* draw marker for 256x240 box */ ! 435: // ui_drawbox(grey, 192, 120, 256, 240); ! 436: ; ! 437: ui_plotstring("Generator is (c) James Ponder 1997-2001, " ! 438: "all rights reserved.", 0, 0); ! 439: ui_plotstring(VERSTRING, 640-(strlen(VERSTRING)*6), 0); ! 440: ; ! 441: ui_plotstring("[A] A button", 0, 420); ! 442: ui_plotstring("[S] B button", 0, 430); ! 443: ui_plotstring("[D] C button", 0, 440); ! 444: ui_plotstring("[RETURN] Start", 0, 450); ! 445: ui_plotstring("[ARROWS] D-pad", 0, 460); ! 446: ui_plotstring("[ESCAPE] QUIT", 0, 470); ! 447: ; ! 448: ui_plotstring("FPS: 00", 120, 420); ! 449: ui_plotstring("Skip: 00", 120, 430); ! 450: ui_plotstring(":", 622, 470); ! 451: ; ! 452: ui_plotstring("[F1] License", 0, 20); ! 453: ui_plotstring("[F2] Load/Save state", 0, 30); ! 454: ui_plotstring("[F3] -", 0, 40); ! 455: ui_plotstring("[F4] Save image", 0, 50); ! 456: ; ! 457: ui_plotstring("[F5] Toggle info:", 216, 20); ! 458: ui_plotstring("[F6] Toggle video:", 216, 30); ! 459: ui_plotstring("[F7] Toggle country:", 216, 40); ! 460: ui_plotstring("[F8] Toggle plotter:", 216, 50); ! 461: ; ! 462: ui_plotstring("[F9] Toggle vsync:", 432, 20); ! 463: ui_plotstring("[F10] Full screen", 432, 30); ! 464: ui_plotstring("[F11] -", 432, 40); ! 465: ui_plotstring("[F12] Reset", 432, 50); ! 466: ; ! 467: ui_plotsettings(); ! 468: ; ! 469: sprintf(bigbuffer, "%s %X %s", gen_cartinfo.version, ! 470: gen_cartinfo.checksum, gen_cartinfo.country); ! 471: ui_plotstring(bigbuffer, 216, 420); ! 472: ui_plotstring(gen_cartinfo.name_domestic, 216, 430); ! 473: ui_plotstring(gen_cartinfo.name_overseas, 216, 440); ! 474: } ! 475: ! 476: void ui_plotsettings(void) ! 477: { ! 478: ui_plotstring(ui_info ? "On " : "Off", 216+126, 20); ! 479: ui_plotstring(vdp_pal ? "Pal " : "NTSC", 216+126, 30); ! 480: ui_plotstring(vdp_overseas ? "USA/Europe" : "Japan ", 216+126, 40); ! 481: ui_plotstring(ui_vdpsimple ? "Cell (fast) " : "Raster (slow)", 216+126, 50); ! 482: ui_plotstring(ui_vsync ? "On " : "Off", 216+342, 20); ! 483: } ! 484: ! 485: /*** ui_loop - main UI loop ***/ ! 486: ! 487: int ui_loop(void) ! 488: { ! 489: char *p; ! 490: int f; ! 491: ! 492: if (ui_initload) { ! 493: p = gen_loadimage(ui_initload); ! 494: if (p) { ! 495: LOG_CRITICAL(("Failed to load ROM image: %s", p)); ! 496: return 1; ! 497: } ! 498: if (ui_saverom) { ! 499: snprintf(bigbuffer, sizeof(bigbuffer)-1, "%s (%X-%s)", ! 500: gen_cartinfo.name_overseas, gen_cartinfo.checksum, ! 501: gen_cartinfo.country); ! 502: if ((f = open(bigbuffer, O_CREAT | O_EXCL | O_WRONLY, 0777)) == -1 || ! 503: write(f, cpu68k_rom, cpu68k_romlen) == -1 || close(f) == -1) { ! 504: fprintf(stderr, "Failed to write file: %s\n", strerror(errno)); ! 505: } ! 506: printf("Successfully wrote: %s\n", bigbuffer); ! 507: gen_quit = 1; ! 508: return 0; ! 509: } ! 510: ui_state = 2; ! 511: } else { ! 512: LOG_CRITICAL(("You must specify a ROM to load")); ! 513: return 1; ! 514: } ! 515: if (uip_vgamode()) { ! 516: LOG_CRITICAL(("Failed to start VGA mode")); ! 517: return 1; ! 518: } ! 519: gen_quit = 0; ! 520: while(!uip_checkkeyboard()) { ! 521: switch(ui_state) { ! 522: case 0: /* stopped */ ! 523: break; ! 524: case 1: /* paused */ ! 525: break; ! 526: case 2: /* playing */ ! 527: if (ui_fkeys & 1<<1) ! 528: ui_licensescreen(); ! 529: if (ui_fkeys & 1<<2) ! 530: ui_statescreen(); ! 531: if (ui_fkeys & 1<<4) ! 532: ui_imagescreen(); ! 533: if (ui_fkeys & 1<<5) { ! 534: ui_info^= 1; ! 535: ui_clearnext = 2; ! 536: } ! 537: if (ui_fkeys & 1<<6) { ! 538: vdp_pal^= 1; ! 539: vdp_setupvideo(); ! 540: ui_clearnext = 2; ! 541: } ! 542: if (ui_fkeys & 1<<7) { ! 543: vdp_overseas^= 1; ! 544: ui_clearnext = 2; ! 545: } ! 546: if (ui_fkeys & 1<<8) { ! 547: ui_vdpsimple^= 1; ! 548: ui_clearnext = 2; ! 549: } ! 550: if (ui_fkeys & 1<<9) { ! 551: ui_vsync^= 1; ! 552: ui_clearnext = 2; ! 553: } ! 554: if (ui_fkeys & 1<<10) { ! 555: ui_fullscreen^= 1; ! 556: ui_clearnext = 2; ! 557: } ! 558: if (ui_fkeys & 1<<12) ! 559: ui_resetscreen(); ! 560: ui_fkeys = 0; ! 561: ui_newframe(); ! 562: event_doframe(); ! 563: break; ! 564: } ! 565: } ! 566: return 0; ! 567: } ! 568: ! 569: void ui_newframe(void) ! 570: { ! 571: static int hmode = 0; ! 572: static int skipcount = 0; ! 573: static char frameplots[60]; /* 60 for NTSC, 50 for PAL */ ! 574: static unsigned int frameplots_i = 0; ! 575: char buf[8]; ! 576: unsigned int i; ! 577: int fps; ! 578: time_t t = time(NULL); ! 579: struct tm *tm_p = localtime(&t); ! 580: ! 581: /* we store whether we plotted the previous field as this is important ! 582: for doing weave interlacing - we don't want to weave two distant fields */ ! 583: ui_plotprevfield = ui_plotfield; ! 584: ! 585: if (frameplots_i > vdp_framerate) ! 586: frameplots_i = 0; ! 587: if (((vdp_reg[12] >> 1) & 3) && vdp_oddframe) { ! 588: /* interlace mode, and we're about to do an odd field - we always leave ! 589: ui_plotfield alone so we do fields in pairs */ ! 590: } else { ! 591: ui_plotfield = 0; ! 592: if (ui_frameskip == 0) { ! 593: if (sound_feedback != -1) ! 594: ui_plotfield = 1; ! 595: } else { ! 596: if (cpu68k_frames % ui_frameskip == 0) ! 597: ui_plotfield = 1; ! 598: } ! 599: } ! 600: if (!ui_plotfield) { ! 601: skipcount++; ! 602: frameplots[frameplots_i++] = 0; ! 603: return; ! 604: } ! 605: if (hmode != (vdp_reg[12]&1)) ! 606: ui_clearnext = 2; ! 607: if (ui_clearnext) { ! 608: /* horizontal size has changed, so clear whole screen and setup ! 609: borders etc again */ ! 610: ui_clearnext--; ! 611: hmode = vdp_reg[12] & 1; ! 612: memset(uip_whichbank() ? ui_screen1 : ui_screen0, 0, ! 613: sizeof(ui_screen[0])); ! 614: uip_clearscreen(); ! 615: ui_setupscreen(); ! 616: } ! 617: /* count the frames we've plotted in the last vdp_framerate real frames */ ! 618: fps = 0; ! 619: for (i = 0; i < vdp_framerate; i++) { ! 620: if (frameplots[i]) ! 621: fps++; ! 622: } ! 623: frameplots[frameplots_i++] = 1; ! 624: if (!ui_info) ! 625: return; ! 626: if (ui_fullscreen) { ! 627: ui_plotint2(fps, 0, 470); ! 628: } else { ! 629: ui_plotint2(fps, 156, 420); ! 630: ui_plotint2(skipcount+1, 156, 430); ! 631: skipcount = 0; ! 632: } ! 633: ui_plotint2(tm_p->tm_hour, 610, 470); ! 634: ui_plotint2(tm_p->tm_min, 628, 470); ! 635: /* ! 636: if (!ui_fullscreen) { ! 637: int y, i, s; ! 638: for (i = 0; i < 8; i++) { ! 639: for (s = 0; s < 4; s++) { ! 640: ui_plotstring((sound_keys[i] & (1<<s)) ? "*" : ".", ! 641: 510+(5*s), 200+10*i); ! 642: } ! 643: } ! 644: } ! 645: */ ! 646: } ! 647: ! 648: /* ui_checkpalcache goes through the CRAM memory in the Genesis and ! 649: converts it to the ui_palcache table. The Genesis has 64 colours, ! 650: but we store three versions of the colour table into ui_palcache - a ! 651: normal, hilighted and dim version. The vdp_cramf buffer has 64 ! 652: entries and is set to 1 when the game writes to CRAM, this means this ! 653: code skips entries that have not changed, unless 'flag' is set to 1 in ! 654: which case this updates all entries regardless. */ ! 655: ! 656: void ui_checkpalcache(int flag) ! 657: { ! 658: uint32 pal; ! 659: unsigned int col; ! 660: uint8 *p; ! 661: ! 662: /* this code requires that there be at least 4 bits per colour, that ! 663: is, three bits that come from the console's palette, and one more bit ! 664: when we do a dim or bright colour, i.e. this code works with 12bpp ! 665: upwards */ ! 666: ! 667: /* the flag forces it to do the update despite the vdp_cramf buffer */ ! 668: ! 669: for (col = 0; col < 64; col++) { /* the CRAM has 64 colours */ ! 670: if (!flag && !vdp_cramf[col]) ! 671: continue; ! 672: vdp_cramf[col] = 0; ! 673: p = (uint8 *)vdp_cram+2*col; /* point p to the two-byte CRAM entry */ ! 674: ui_palcache[col] = /* normal */ ! 675: (p[0]&0xE)<<(ui_uipinfo.blueshift+1) | ! 676: (p[1]&0xE)<<(ui_uipinfo.redshift+1) | ! 677: ((p[1]&0xE0)>>4)<<(ui_uipinfo.greenshift+1); ! 678: ui_palcache[col+64] = /* hilight */ ! 679: (p[0]&0xE)<<ui_uipinfo.blueshift | ! 680: (p[1]&0xE)<<ui_uipinfo.redshift | ! 681: ((p[1]&0xE0)>>4)<<ui_uipinfo.greenshift | ! 682: (16 << ui_uipinfo.blueshift) | (16 << ui_uipinfo.redshift) | ! 683: (16 << ui_uipinfo.greenshift); ! 684: ui_palcache[col+128] = /* shadow */ ! 685: (p[0]&0xE)<<ui_uipinfo.blueshift | ! 686: (p[1]&0xE)<<ui_uipinfo.redshift | ! 687: ((p[1]&0xE0)>>4)<<ui_uipinfo.greenshift; ! 688: } ! 689: } ! 690: ! 691: /*** ui_convertdata - convert genesis data to 16 bit colour */ ! 692: ! 693: void ui_convertdata(uint8 *indata, uint16 *outdata, unsigned int pixels) ! 694: { ! 695: unsigned int ui; ! 696: uint32 outdata1; ! 697: uint32 outdata2; ! 698: uint32 indata_val; ! 699: ! 700: ui_checkpalcache(0); ! 701: /* not scaled, 16bpp - we do 4 pixels at a time */ ! 702: for (ui = 0; ui < pixels>>2; ui++) { ! 703: indata_val = ((uint32 *)indata)[ui]; /* 4 bytes of in data */ ! 704: outdata1 = (ui_palcache[indata_val & 0xff] | ! 705: ui_palcache[(indata_val>>8) & 0xff]<<16); ! 706: outdata2 = (ui_palcache[(indata_val>>16) & 0xff] | ! 707: ui_palcache[(indata_val>>24) & 0xff]<<16); ! 708: #ifdef WORDS_BIGENDIAN ! 709: ((uint32 *)outdata)[(ui<<1)] = outdata2; ! 710: ((uint32 *)outdata)[(ui<<1)+1] = outdata1; ! 711: #else ! 712: ((uint32 *)outdata)[(ui<<1)] = outdata1; ! 713: ((uint32 *)outdata)[(ui<<1)+1] = outdata2; ! 714: #endif ! 715: } ! 716: } ! 717: ! 718: /*** ui_render_x1 - copy to screen with delta changes ***/ ! 719: ! 720: void ui_render_x1(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 721: unsigned int linewidth, unsigned int pixels) ! 722: { ! 723: unsigned int ui; ! 724: uint32 inval; ! 725: ! 726: if (0==1) { ! 727: memcpy(screen, linedata, pixels*2); ! 728: } else { ! 729: for (ui = 0; ui < pixels>>1; ui++) { ! 730: inval = ((uint32 *)linedata)[ui]; /* two words of input data */ ! 731: if (inval != ((uint32 *)olddata)[ui]) { ! 732: ((uint32 *)screen)[ui] = inval; ! 733: } ! 734: } ! 735: } ! 736: } ! 737: ! 738: /*** ui_render_x2 - blow up screen image by two */ ! 739: ! 740: void ui_render_x2(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 741: unsigned int linewidth, unsigned int pixels) ! 742: { ! 743: unsigned int ui; ! 744: uint32 inval, outval, mask; ! 745: uint8 *screen2 = screen + linewidth; ! 746: ! 747: for (ui = 0; ui < pixels>>1; ui++) { ! 748: inval = ((uint32 *)linedata)[ui]; /* two words of input data */ ! 749: mask = inval ^ ((uint32 *)olddata)[ui]; /* check for changed data */ ! 750: if (mask & 0xffff) { ! 751: outval = inval & 0xffff; ! 752: outval|= outval<<16; ! 753: #ifdef WORDS_BIGENDIAN ! 754: ((uint32 *)screen)[(ui<<1)+1] = outval; /* write first two words */ ! 755: ((uint32 *)screen2)[(ui<<1)+1] = outval; ! 756: #else ! 757: ((uint32 *)screen)[(ui<<1)] = outval; /* write first two words */ ! 758: ((uint32 *)screen2)[(ui<<1)] = outval; ! 759: #endif ! 760: } ! 761: if (mask & 0xffff0000) { ! 762: outval = inval & 0xffff0000; ! 763: outval|= outval>>16; ! 764: #ifdef WORDS_BIGENDIAN ! 765: ((uint32 *)screen)[(ui<<1)] = outval; /* write second two words */ ! 766: ((uint32 *)screen2)[(ui<<1)] = outval; ! 767: #else ! 768: ((uint32 *)screen)[(ui<<1)+1] = outval; /* write second two words */ ! 769: ((uint32 *)screen2)[(ui<<1)+1] = outval; ! 770: #endif ! 771: } ! 772: } ! 773: } ! 774: ! 775: /*** ui_render_x2h - blow up by two in horizontal direction only */ ! 776: ! 777: void ui_render_x2h(uint16 *linedata, uint16 *olddata, uint8 *screen, ! 778: unsigned int linewidth, unsigned int pixels) ! 779: { ! 780: unsigned int ui; ! 781: uint32 inval, outval, mask; ! 782: ! 783: mask = 0xffffffff; ! 784: for (ui = 0; ui < pixels>>1; ui++) { ! 785: inval = ((uint32 *)linedata)[ui]; /* two words of input data */ ! 786: if (olddata) ! 787: mask = inval ^ ((uint32 *)olddata)[ui]; /* check for changed data */ ! 788: if (mask & 0xffff) { ! 789: outval = inval & 0xffff; ! 790: outval|= outval<<16; ! 791: #ifdef WORDS_BIGENDIAN ! 792: ((uint32 *)screen)[(ui<<1)+1] = outval; /* write first two words */ ! 793: #else ! 794: ((uint32 *)screen)[(ui<<1)] = outval; /* write first two words */ ! 795: #endif ! 796: } ! 797: if (mask & 0xffff0000) { ! 798: outval = inval & 0xffff0000; ! 799: outval|= outval>>16; ! 800: #ifdef WORDS_BIGENDIAN ! 801: ((uint32 *)screen)[(ui<<1)] = outval; /* write second two words */ ! 802: #else ! 803: ((uint32 *)screen)[(ui<<1)+1] = outval; /* write second two words */ ! 804: #endif ! 805: } ! 806: } ! 807: } ! 808: ! 809: /*** ui_irender_weavefilter - take even and odd fields, filter and plot ***/ ! 810: ! 811: void ui_irender_weavefilter(uint16 *evendata, uint16 *odddata, uint8 *screen, ! 812: unsigned int linewidth, unsigned int pixels) ! 813: { ! 814: unsigned int ui; ! 815: uint32 evenval, oddval, e_r, e_g, e_b, o_r, o_g, o_b; ! 816: uint32 outval, w1, w2; ! 817: ! 818: for (ui = 0; ui < pixels>>1; ui++) { ! 819: evenval = ((uint32 *)evendata)[ui]; /* two words of input data */ ! 820: oddval = ((uint32 *)odddata)[ui]; /* two words of input data */ ! 821: e_r = (evenval >> ui_uipinfo.redshift) & 0x001f001f; ! 822: e_g = (evenval >> ui_uipinfo.greenshift) & 0x001f001f; ! 823: e_b = (evenval >> ui_uipinfo.blueshift) & 0x001f001f; ! 824: o_r = (oddval >> ui_uipinfo.redshift) & 0x001f001f; ! 825: o_g = (oddval >> ui_uipinfo.greenshift) & 0x001f001f; ! 826: o_b = (oddval >> ui_uipinfo.blueshift) & 0x001f001f; ! 827: outval = (((e_r+o_r)>>1) & 0x001f001f) << ui_uipinfo.redshift | ! 828: (((e_g+o_g)>>1) & 0x001f001f) << ui_uipinfo.greenshift | ! 829: (((e_b+o_b)>>1) & 0x001f001f) << ui_uipinfo.blueshift; ! 830: w1 = (outval & 0xffff); ! 831: w1|= w1<<16; ! 832: w2 = outval & 0xffff0000; ! 833: w2|= w2>>16; ! 834: #ifdef WORDS_BIGENDIAN ! 835: ((uint32 *)screen)[(ui<<1)] = w2; ! 836: ((uint32 *)screen)[(ui<<1)+1] = w1; ! 837: LOG_CRITICAL(("this code hasn't been checked")); ! 838: #else ! 839: ((uint32 *)screen)[(ui<<1)] = w1; ! 840: ((uint32 *)screen)[(ui<<1)+1] = w2; ! 841: #endif ! 842: } ! 843: } ! 844: ! 845: /*** ui_line - it is time to render a line ***/ ! 846: ! 847: void ui_line(unsigned int line) ! 848: { ! 849: static uint8 gfx[320]; ! 850: unsigned int yoffset = (vdp_reg[1] & 1<<3) ? 0 : 8; ! 851: unsigned int width = (vdp_reg[12] & 1) ? 320 : 256; ! 852: ! 853: if (ui_plotfield && !ui_vdpsimple) { ! 854: /* we are plotting this frame, and we're not doing a simple plot at ! 855: the end of it all */ ! 856: if (((vdp_reg[12]>>1) & 3) == 3) ! 857: vdp_renderline(line, gfx, vdp_oddframe); /* interlace */ ! 858: else ! 859: vdp_renderline(line, gfx, 0); ! 860: ui_convertdata(gfx, ui_newscreen+line*320, width); ! 861: } ! 862: } ! 863: ! 864: /*** ui_endfield - end of field reached ***/ ! 865: ! 866: void ui_endfield(void) ! 867: { ! 868: static int counter = 0; ! 869: unsigned int line; ! 870: unsigned int width = (vdp_reg[12] & 1) ? 320 : 256; ! 871: uint8 gfx[(320+16)*(240+16)]; ! 872: ! 873: if (ui_plotfield) { ! 874: if (ui_vdpsimple) { ! 875: /* cell mode - entire frame done here */ ! 876: vdp_renderframe(gfx+(8*(320+16))+8, 320+16); /* plot frame */ ! 877: for (line = 0; line < vdp_vislines; line++) { ! 878: ui_convertdata(gfx+8+(line+8)*(320+16), ! 879: ui_newscreen+line*320, width); ! 880: } ! 881: } ! 882: ui_rendertoscreen(); /* plot ui_newscreen to screen */ ! 883: } ! 884: if (ui_frameskip == 0) { ! 885: /* dynamic frame skipping */ ! 886: counter++; ! 887: if (sound_feedback >= 0) { ! 888: ui_actualskip = counter; ! 889: counter = 0; ! 890: } ! 891: } else { ! 892: ui_actualskip = ui_frameskip; ! 893: } ! 894: } ! 895: ! 896: void ui_rendertoscreen(void) ! 897: { ! 898: uint16 **oldscreenpp = uip_whichbank() ? &ui_screen1 : &ui_screen0; ! 899: uint16 *scrtmp; ! 900: uint16 *newlinedata, *oldlinedata; ! 901: unsigned int line; ! 902: unsigned int nominalwidth = (vdp_reg[12] & 1) ? 320 : 256; ! 903: unsigned int yoffset = (vdp_reg[1] & 1<<3) ? 0 : 8; ! 904: unsigned int xoffset = (vdp_reg[12] & 1) ? 0 : 32; ! 905: uint8 *screen; ! 906: uint16 *evenscreen; /* interlace: lines 0,2,etc. */ ! 907: uint16 *oddscreen; /* lines 1,3,etc. */ ! 908: ! 909: for (line = 0; line < vdp_vislines; line++) { ! 910: newlinedata = ui_newscreen+line*320; ! 911: oldlinedata = *oldscreenpp+line*320; ! 912: if (ui_fullscreen) { ! 913: screen = (ui_uipinfo.screenmem_w+xoffset*4+ ! 914: ui_uipinfo.linewidth*2*(line+yoffset)); ! 915: switch ((vdp_reg[12] >> 1) & 3) { /* interlace mode */ ! 916: case 0: ! 917: case 1: ! 918: case 2: ! 919: ui_render_x2h(newlinedata, oldlinedata, screen, ! 920: ui_uipinfo.linewidth, nominalwidth); ! 921: break; ! 922: case 3: ! 923: /* work out which buffer contains the odd and even fields */ ! 924: if (vdp_oddframe) { ! 925: oddscreen = ui_newscreen; ! 926: evenscreen = uip_whichbank() ? ui_screen0 : ui_screen1; ! 927: } else { ! 928: evenscreen = ui_newscreen; ! 929: oddscreen = uip_whichbank() ? ui_screen0 : ui_screen1; ! 930: } ! 931: switch (ui_interlace) { ! 932: case DEINTERLACE_BOB: ! 933: ui_render_x2(newlinedata, oldlinedata, screen, ! 934: ui_uipinfo.linewidth, nominalwidth); ! 935: break; ! 936: case DEINTERLACE_WEAVE: ! 937: ui_render_x2h(evenscreen+line*320, NULL, screen, ! 938: ui_uipinfo.linewidth, nominalwidth); ! 939: ui_render_x2h(oddscreen+line*320, NULL, ! 940: screen+ui_uipinfo.linewidth, ! 941: ui_uipinfo.linewidth, nominalwidth); ! 942: break; ! 943: case DEINTERLACE_WEAVEFILTER: ! 944: ui_irender_weavefilter(evenscreen+line*320, /* line */ ! 945: oddscreen+line*320, /* line+1 */ ! 946: screen, ! 947: ui_uipinfo.linewidth, nominalwidth); ! 948: ui_irender_weavefilter(oddscreen+line*320, /* line+1 */ ! 949: evenscreen+line*320+320, /* line+2 */ ! 950: screen+ui_uipinfo.linewidth, ! 951: ui_uipinfo.linewidth, nominalwidth); ! 952: break; ! 953: } ! 954: break; ! 955: } ! 956: } else { ! 957: screen = (ui_uipinfo.screenmem_w+320+xoffset*2+ ! 958: ui_uipinfo.linewidth*(120+line+yoffset)); ! 959: ui_render_x1(newlinedata, oldlinedata, screen, ! 960: ui_uipinfo.linewidth, nominalwidth); ! 961: } ! 962: } ! 963: uip_displaybank(-1); ! 964: if (ui_vsync) ! 965: uip_vsync(); ! 966: /* swap ui_screenX and ui_newscreen pointers */ ! 967: scrtmp = *oldscreenpp; ! 968: *oldscreenpp = ui_newscreen; ! 969: ui_newscreen = scrtmp; ! 970: } ! 971: ! 972: void ui_basicbits(void) ! 973: { ! 974: uint16 grey = 24<<ui_uipinfo.redshift | 24<<ui_uipinfo.greenshift | ! 975: 24<<ui_uipinfo.blueshift; ! 976: uint16 red = 24<<ui_uipinfo.redshift; ! 977: ! 978: ui_plotstring("Generator is (c) James Ponder 1997-2001, " ! 979: "all rights reserved.", 0, 0); ! 980: ui_plotstring(VERSTRING, 640-(strlen(VERSTRING)*6), 0); ! 981: ui_drawbox(red, 140, 100, 360, 280); ! 982: ui_drawbox(grey, 141, 101, 358, 278); ! 983: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 80); ! 984: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 360); ! 985: } ! 986: ! 987: void ui_licensescreen(void) ! 988: { ! 989: char c; ! 990: ! 991: sound_stop(); ! 992: uip_singlebank(); ! 993: uip_clearscreen(); ! 994: ui_basicbits(); ! 995: /* #01234567890123456789012345678901234567890123456789012 */ ! 996: ui_plotstring("Generator - Sega Genesis (Mega Drive) emulator", 160, 120); ! 997: ui_plotstring("Copyright (C) 1997-2001 James Ponder", 160, 130); ! 998: ui_plotstring("YM2612 chip emulation by Tatsuyuki Satoh", 160, 150); ! 999: ui_plotstring("Multi-Z80 CPU emulator by Neil Bradley", 160, 160); ! 1000: ui_plotstring(" Portable C version written by Edward Massey", 160, 170); ! 1001: ui_plotstring("This program is free software; you can redistribute", 160, ! 1002: 190); ! 1003: ui_plotstring("it and/or modify it under the terms of the GNU", 160, 200); ! 1004: ui_plotstring("General Public License version 2 as published by", 160, 210); ! 1005: ui_plotstring("the Free Software Foundation.", 160, 220); ! 1006: ui_plotstring("http://www.squish.net/generator/", 160, 240); ! 1007: ui_plotstring("[0] Return to game", 160, 280); ! 1008: while((c = uip_getchar()) != '0') { ! 1009: } ! 1010: uip_doublebank(); ! 1011: ui_clearnext = 2; ! 1012: sound_start(); ! 1013: } ! 1014: ! 1015: void ui_resetscreen(void) ! 1016: { ! 1017: sound_stop(); ! 1018: uip_singlebank(); ! 1019: uip_clearscreen(); ! 1020: ui_basicbits(); ! 1021: ui_resetscreen_main(); ! 1022: uip_doublebank(); ! 1023: ui_clearnext = 2; ! 1024: sound_final(); ! 1025: } ! 1026: ! 1027: void ui_resetscreen_main(void) ! 1028: { ! 1029: char c; ! 1030: ! 1031: for (;;) { ! 1032: uip_clearmiddle(); ! 1033: ui_plotstring("Reset menu", 160, 120); ! 1034: ui_plotstring("----------", 160, 130); ! 1035: ui_plotstring("[1] Soft reset", 160, 140); ! 1036: ui_plotstring("[2] Hard reset", 160, 150); ! 1037: ui_plotstring("[0] Return to game", 160, 170); ! 1038: ; ! 1039: switch((c = uip_getchar())) { ! 1040: case '0': ! 1041: return; ! 1042: case '1': ! 1043: gen_softreset(); ! 1044: return; ! 1045: case '2': ! 1046: gen_reset(); ! 1047: return; ! 1048: } ! 1049: } ! 1050: } ! 1051: ! 1052: void ui_statescreen(void) ! 1053: { ! 1054: sound_stop(); ! 1055: uip_singlebank(); ! 1056: uip_clearscreen(); ! 1057: ui_basicbits(); ! 1058: ui_statescreen_main(); ! 1059: uip_doublebank(); ! 1060: ui_clearnext = 2; ! 1061: sound_start(); ! 1062: } ! 1063: ! 1064: void ui_statescreen_main(void) ! 1065: { ! 1066: char c; ! 1067: ! 1068: for (;;) { ! 1069: uip_clearmiddle(); ! 1070: ui_plotstring("Load / Save state menu", 160, 120); ! 1071: ui_plotstring("----------------------", 160, 130); ! 1072: ui_plotstring("[1] Load state", 160, 140); ! 1073: ui_plotstring("[2] Save state", 160, 150); ! 1074: ui_plotstring("[0] Return to game", 160, 170); ! 1075: ; ! 1076: switch((c = uip_getchar())) { ! 1077: case '0': ! 1078: return; ! 1079: case '1': ! 1080: if (ui_statescreen_loadsavestate(0)) ! 1081: return; ! 1082: break; ! 1083: case '2': ! 1084: if (ui_statescreen_loadsavestate(1)) ! 1085: return; ! 1086: break; ! 1087: } ! 1088: } ! 1089: } ! 1090: ! 1091: int ui_statescreen_loadsavestate(int save) ! 1092: { ! 1093: char c; ! 1094: time_t t; ! 1095: char buf[64]; ! 1096: int i, y; ! 1097: ! 1098: for (;;) { ! 1099: uip_clearmiddle(); ! 1100: if (save) ! 1101: ui_plotstring("Save state", 160, 120); ! 1102: else ! 1103: ui_plotstring("Load state", 160, 120); ! 1104: ui_plotstring("----------", 160, 130); ! 1105: for (i = 1; i <= 9; i++) { ! 1106: y = 140 + 10 * i; ! 1107: snprintf(buf, sizeof(buf), "[%d]", i); ! 1108: ui_plotstring(buf, 160, y); ! 1109: if ((t = state_date(i)) == 0) { ! 1110: ui_plotstring("empty slot", 160+4*6, y); ! 1111: } else { ! 1112: strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&t)); ! 1113: ui_plotstring(buf, 160+4*6, y); ! 1114: } ! 1115: } ! 1116: ui_plotstring("[0] ...back", 160, 140+10*11); ! 1117: if ((c = uip_getchar()) == '0') ! 1118: return 0; ! 1119: if (c >= '1' && c <= '9') { ! 1120: /* this is a function call! */ ! 1121: if ((save ? state_save : state_load)(c - '0') == 0) ! 1122: return 1; ! 1123: uip_clearmiddle(); ! 1124: if (save) ! 1125: ui_plotstring("Failed to save file.", 160, 120); ! 1126: else ! 1127: ui_plotstring("Failed to load file.", 160, 120); ! 1128: ui_plotstring("Press any key to continue", 160, 140); ! 1129: uip_getchar(); ! 1130: } ! 1131: } ! 1132: } ! 1133: ! 1134: void ui_imagescreen(void) ! 1135: { ! 1136: sound_stop(); ! 1137: uip_singlebank(); ! 1138: uip_clearscreen(); ! 1139: ui_basicbits(); ! 1140: ui_imagescreen_main(); ! 1141: uip_doublebank(); ! 1142: ui_clearnext = 2; ! 1143: sound_start(); ! 1144: } ! 1145: ! 1146: void ui_imagescreen_main(void) ! 1147: { ! 1148: char c; ! 1149: char filename[256]; ! 1150: char buf[256]; ! 1151: int xsize, ysize; ! 1152: ! 1153: for (;;) { ! 1154: uip_clearmiddle(); ! 1155: ui_plotstring("Save screen shot menu", 160, 120); ! 1156: ui_plotstring("---------------------", 160, 130); ! 1157: ui_plotstring("[1] Save svga screen (640x480)", 160, 140); ! 1158: ui_plotstring("[2] Save game screen", 160, 150); ! 1159: ui_plotstring("[0] Return to game", 160, 170); ! 1160: ; ! 1161: c = uip_getchar(); ! 1162: if (c == '0') { ! 1163: return; ! 1164: } else if (c == '1' || c == '2') { ! 1165: if (ui_saveimage(c == '1' ? "svga" : "game", filename, 256, ! 1166: &xsize, &ysize)) { ! 1167: uip_clearmiddle(); ! 1168: ui_plotstring("Failed to save image.", 160, 120); ! 1169: ui_plotstring("Press any key to continue", 160, 140); ! 1170: uip_getchar(); ! 1171: } else { ! 1172: uip_clearmiddle(); ! 1173: snprintf(buf, sizeof(buf), "Successfully saved %s", filename); ! 1174: ui_plotstring(buf, 160, 120); ! 1175: snprintf(buf, sizeof(buf), "(%d x %d 24 bit raw image)", xsize, ysize); ! 1176: ui_plotstring(buf, 160, 130); ! 1177: ui_plotstring("Press any key to continue", 160, 150); ! 1178: uip_getchar(); ! 1179: } ! 1180: } ! 1181: } ! 1182: } ! 1183: ! 1184: int ui_saveimage(const char *type, char *filename, int buflen, ! 1185: int *xsize, int *ysize) ! 1186: { ! 1187: int i, y; ! 1188: int fd = 0; ! 1189: char out[3]; ! 1190: int count; ! 1191: ! 1192: for (i = 1; i <= 9; i++) { ! 1193: snprintf(filename, buflen, "%s.ss%d", gen_leafname, i); ! 1194: if ((fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0644)) != -1) ! 1195: break; ! 1196: } ! 1197: if (i < 1 || i > 9) { ! 1198: *filename = '\0'; ! 1199: LOG_CRITICAL(("Error - there are already 9 saved images")); ! 1200: return -1; ! 1201: } ! 1202: if (!strcasecmp(type, "svga")) { ! 1203: uint8 *scr; ! 1204: uint16 *line; ! 1205: /* get the bank that we're not writing/reading to now */ ! 1206: scr = (ui_uipinfo.screenmem_w == ui_uipinfo.screenmem0) ? ! 1207: ui_uipinfo.screenmem1 : ui_uipinfo.screenmem0; ! 1208: for (y = 0; y < 480; y++) { ! 1209: line = (uint16 *)(scr + y * ui_uipinfo.linewidth); ! 1210: for (i = 0; i < 640; i++) { ! 1211: out[0] = ((line[i]>>ui_uipinfo.redshift) & 0x1f) << 3; ! 1212: out[1] = ((line[i]>>ui_uipinfo.greenshift) & 0x1f) << 3; ! 1213: out[2] = ((line[i]>>ui_uipinfo.blueshift) & 0x1f) << 3; ! 1214: count = write(fd, out, 3); ! 1215: if (count == -1) { ! 1216: LOG_CRITICAL(("Error whilst writing to output image file: %s", ! 1217: strerror(errno))); ! 1218: close(fd); ! 1219: return -1; ! 1220: } else if (count != 3) { ! 1221: LOG_CRITICAL(("Short write - wrote 3 bytes, got %d", count)); ! 1222: close(fd); ! 1223: return -1; ! 1224: } ! 1225: } ! 1226: } ! 1227: *xsize = 640; ! 1228: *ysize = 480; ! 1229: } else if (!strcasecmp(type, "game")) { ! 1230: uint16 data; ! 1231: uint16 *scr = uip_whichbank() ? ui_screen0 : ui_screen1; ! 1232: *xsize = (vdp_reg[12] & 1) ? 320 : 256; ! 1233: *ysize = vdp_vislines; ! 1234: for (y = 0; y < *ysize; y++) { ! 1235: for (i = 0; i < *xsize; i++) { ! 1236: data = scr[320*y+i]; ! 1237: out[0] = ((data>>ui_uipinfo.redshift) & 0x1f) << 3; ! 1238: out[1] = ((data>>ui_uipinfo.greenshift) & 0x1f) << 3; ! 1239: out[2] = ((data>>ui_uipinfo.blueshift) & 0x1f) << 3; ! 1240: count = write(fd, out, 3); ! 1241: if (count == -1) { ! 1242: LOG_CRITICAL(("Error whilst writing to output image file: %s", ! 1243: strerror(errno))); ! 1244: close(fd); ! 1245: return -1; ! 1246: } else if (count != 3) { ! 1247: LOG_CRITICAL(("Short write - wrote 3 bytes, got %d", count)); ! 1248: close(fd); ! 1249: return -1; ! 1250: } ! 1251: } ! 1252: } ! 1253: } else { ! 1254: LOG_CRITICAL(("Invalid image type '%s' passed to image save routine", ! 1255: type)); ! 1256: close(fd); ! 1257: return -1; ! 1258: } ! 1259: if (close(fd)) { ! 1260: LOG_CRITICAL(("Close returned error whilst writing image")); ! 1261: return -1; ! 1262: } ! 1263: return 0; ! 1264: } ! 1265: ! 1266: /*** logging functions ***/ ! 1267: ! 1268: /* logging is done this way because this was the best I could come up with ! 1269: whilst battling with macros that can only take fixed numbers of arguments */ ! 1270: ! 1271: #ifdef ALLEGRO ! 1272: #define LOG_FUNC(name,level,txt) void ui_log_ ## name ## (const char *text, ...) \ ! 1273: { \ ! 1274: va_list ap; \ ! 1275: char *ll = ui_loglines[ui_logline]; \ ! 1276: char *p = bigbuffer; \ ! 1277: if (gen_loglevel >= level) { \ ! 1278: p+= sprintf(p, "%d ", ui_logcount++); \ ! 1279: p+= sprintf(p, txt); \ ! 1280: va_start(ap, text); \ ! 1281: vsprintf(p, text, ap); \ ! 1282: va_end(ap); \ ! 1283: strncpy(ll, bigbuffer, UI_LOGLINESIZE); \ ! 1284: if (++ui_logline >= UI_LOGLINES) \ ! 1285: ui_logline = 0; \ ! 1286: } \ ! 1287: } ! 1288: #else ! 1289: #define LOG_FUNC(name,level,txt) void ui_log_ ## name ## (const char *text, ...) \ ! 1290: { \ ! 1291: va_list ap; \ ! 1292: if (gen_loglevel >= level) { \ ! 1293: printf("[%s] ", txt); \ ! 1294: va_start(ap, text); \ ! 1295: vprintf(text, ap); \ ! 1296: va_end(ap); \ ! 1297: putchar(10); \ ! 1298: } \ ! 1299: } ! 1300: #endif ! 1301: ! 1302: LOG_FUNC(debug3, 7, "DEBG "); ! 1303: LOG_FUNC(debug2, 6, "DEBG "); ! 1304: LOG_FUNC(debug1, 5, "DEBG "); ! 1305: LOG_FUNC(user, 4, "USER "); ! 1306: LOG_FUNC(verbose, 3, "---- "); ! 1307: LOG_FUNC(normal, 2, "---- "); ! 1308: LOG_FUNC(critical, 1, "CRIT "); ! 1309: LOG_FUNC(request, 0, "---- "); /* this generates a warning, such is life */ ! 1310: ! 1311: /*** ui_err - log error message and quit ***/ ! 1312: ! 1313: void ui_err(const char *text, ...) ! 1314: { ! 1315: va_list ap; ! 1316: ! 1317: printf("ERROR: "); ! 1318: ! 1319: va_start(ap, text); ! 1320: vfprintf(stderr, text, ap); ! 1321: va_end(ap); ! 1322: putc(10, stderr); ! 1323: exit(0); /* don't exit(1) because windows makes an error then! */ ! 1324: } ! 1325: ! 1326: /*** ui_setinfo - there is new cart information ***/ ! 1327: ! 1328: char *ui_setinfo(t_cartinfo *cartinfo) ! 1329: { ! 1330: return NULL; ! 1331: } ! 1332: ! 1333: /*** ui_topbit - given an integer return the top most bit set ***/ ! 1334: ! 1335: int ui_topbit(unsigned long int bits) ! 1336: { ! 1337: long int bit = 31; ! 1338: unsigned long int mask = 1<<31; ! 1339: ! 1340: for (; bit >= 0; bit--, mask>>= 1) { ! 1341: if (bits & mask) ! 1342: return bit; ! 1343: } ! 1344: return -1; ! 1345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.