![[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 / src|
Return to ui-console.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src |
1.1 root 1: /*****************************************************************************/
2: /* Generator - Sega Genesis emulation - (c) James Ponder 1997-2000 */
3: /*****************************************************************************/
4: /* */
5: /* ui-console - generic 640x480 console emulation */
6: /* */
7: /*****************************************************************************/
8:
9: #include <stdlib.h>
10: #include <stdio.h>
11: #include <stdarg.h>
12: #include <time.h>
13: #include <string.h>
14:
15: #include "generator.h"
16:
17: #include "cpu68k.h"
18: #include "cpuz80.h"
19: #include "ui.h"
20: #include "vdp.h"
21: #include "reg68k.h"
22: #include "gensound.h"
23: #include "mem68k.h"
24: #include "logo.h"
25: #include "font.h"
26: #include "uip.h"
27: #include "ui-console.h"
28:
29: #define UI_LOGLINESIZE 128
30: #define UI_LOGLINES 64
31:
32: uint8 ui_vdpsimple = 0; /* 0=raster, 1=cell based plotter */
33: uint8 ui_clearnext = 0; /* flag indicating redraw required */
34: uint8 ui_info = 1; /* does the user want info onscreen or not */
35: uint8 ui_vsync = 0; /* does the user want us to wait for vsync */
36:
37: /*** forward reference declarations ***/
38:
39: void ui_endframe(void);
40: void ui_exithandler(void);
41: void ui_printlog(void);
42: void ui_newframe(void);
43: void ui_convertdata(uint8 *indata, uint8 *outdata, unsigned int pixels);
44: void ui_plotsprite_acorn(uint16 *logo, uint16 width, uint16 height,
45: uint16 x, uint16 y);
46: int ui_unpackfont(void);
47: uint16 ui_plotstring(const char *text, uint16 xpos, uint16 ypos);
48: uint16 ui_plotint2(uint8 num, uint16 xpos, uint16 ypos);
49: void ui_plotsettings(void);
50: void ui_drawbox(uint16 colour, uint16 x, uint16 y, uint16 width,
51: uint16 height);
52:
53: /*** static variables ***/
54:
55: static uint8 ui_vga = 0; /* flag for whether in VGA more or not */
56: static uint8 ui_frameskip = 0; /* 0 for dynamic */
57: static uint8 ui_actualskip = 0; /* the last skip we did (1..) */
58: static uint8 ui_state = 0; /* 0=stop, 1=paused, 2=play */
59: static uint32 ui_palcache[192];
60: static char *ui_initload = NULL; /* filename to load on init */
61: static char ui_loglines[UI_LOGLINES][UI_LOGLINESIZE];
62: static uint32 ui_logline = 0;
63: static uint8 ui_plotframe; /* flag indicating plotting this frame */
64: static uint16 *ui_font; /* unpacked font */
65: static uint8 bigbuffer[8192]; /* stupid no-vsnprintf platforms */
66: static uint16 ui_logcount = 0; /* log counter */
67: static t_uipinfo ui_uipinfo; /* uipinfo filled in by uip 'sub-system' */
68:
69: /*** Program entry point ***/
70:
71: int ui_init(int argc, char *argv[])
72: {
73: int i;
74:
75: for(i = 0; i < UI_LOGLINES; i++) {
76: ui_loglines[i][0] = '\0';
77: }
78: if (ui_unpackfont() == -1) {
79: fprintf(stderr, "Failed to unpack font, out of memory?\n");
80: return 1;
81: }
82: if (argc == 2) {
83: if ((ui_initload = malloc(strlen(argv[1])+1)) == NULL) {
84: fprintf(stderr, "Out of memory\n");
85: return 1;
86: }
87: strcpy(ui_initload, argv[1]);
88: }
89: if (atexit(ui_exithandler) == -1) {
90: LOG_CRITICAL(("Failed to set exit handler"));
91: return 1;
92: }
93: if (uip_init(&ui_uipinfo)) {
94: LOG_CRITICAL(("Failed to initialise platform dependent UI"));
95: return 1;
96: }
97: return 0;
98: }
99:
100: void ui_printlog(void)
101: {
102: unsigned int i;
103: char *p;
104:
105: printf("**** Last lines logged:\n");
106: for (i = ui_logline; i < (UI_LOGLINES+ui_logline); i++) {
107: p = ui_loglines[(i < UI_LOGLINES) ? i : (i-UI_LOGLINES)];
108: if (*p)
109: printf("%s\n", p);
110: }
111: printf("**** END\n");
112: }
113:
114: void ui_exithandler(void)
115: {
116: if (ui_vga)
117: uip_textmode();
118: ui_vga = 0;
119: ui_printlog();
120: }
121:
122: void ui_final(void)
123: {
124: if (ui_vga)
125: uip_textmode();
126: ui_vga = 0;
127: ui_printlog();
128: }
129:
130: /*** ui_drawbox - plot a box ***/
131:
132: void ui_drawbox(uint16 colour, uint16 x, uint16 y, uint16 width,
133: uint16 height)
134: {
135: uint16 *p, *q;
136: unsigned int i;
137:
138: p = (uint16 *)(ui_uipinfo.screenmem_w+y*ui_uipinfo.linewidth+x*2);
139: q = (uint16 *)((uint8 *)p+(height-1)*ui_uipinfo.linewidth);
140: for (i = 0; i < width; i++)
141: *p++ = *q++ = colour;
142: p = (uint16 *)(ui_uipinfo.screenmem_w+y*ui_uipinfo.linewidth+x*2);
143: for (i = 0; i < height; i++) {
144: p[0] = colour;
145: p[width-1] = colour;
146: p = (uint16 *)((uint8 *)p+ui_uipinfo.linewidth);
147: }
148: }
149:
150: /*** ui_unpackfont - unpack the font file ***/
151:
152: int ui_unpackfont(void)
153: {
154: unsigned int c, y, x;
155: unsigned char packed;
156: uint16 *cdata;
157:
158: if ((ui_font = malloc(128*6*10*2)) == NULL) /* 128 chars, 6x, 10y, 16bit */
159: return -1;
160: for (c = 0; c < 128; c++) { /* 128 characters */
161: cdata = ui_font+c*6*10;
162: for (y = 0; y < 10; y++) { /* 10 pixels height */
163: packed = generator_font[c*10+y];
164: for (x = 0; x < 6; x++) { /* 6 pixels width */
165: *cdata++ = (packed & 1<<(7-x)) ? 0xffff : 0;
166: }
167: }
168: }
169: return 0;
170: }
171:
172: /*** ui_plotint2 - plot a 2-char wide integer ***/
173:
174: uint16 ui_plotint2(uint8 num, uint16 xpos, uint16 ypos)
175: {
176: char buf[3];
177:
178: buf[0] = '0' + (num / 10) % 10;
179: buf[1] = '0' + (num % 10);
180: buf[2] = '\0';
181: return ui_plotstring(buf, xpos, ypos);
182: }
183:
184: /*** ui_plotstring - plot a string ***/
185:
186: uint16 ui_plotstring(const char *text, uint16 xpos, uint16 ypos)
187: {
188: const unsigned char *p;
189: const uint16 *cdata;
190: unsigned int x,y;
191: uint16 *scr;
192:
193: for (p = text; *p; p++) {
194: if (*p > 128)
195: cdata = ui_font+'.'*6*10;
196: else
197: cdata = ui_font+(*p)*6*10;
198: for (y = 0; y < 10; y++) {
199: scr = (uint16 *)(ui_uipinfo.screenmem_w+(ypos+y)*ui_uipinfo.linewidth
200: +xpos*2);
201: for (x = 0; x < 6; x++)
202: *scr++ = *cdata++;
203: }
204: xpos+= 6;
205: }
206: return xpos;
207: }
208:
209: /*** ui_plotsprite - plot a sprite ***/
210:
211: void ui_plotsprite_acorn(uint16 *logo, uint16 width, uint16 height,
212: uint16 x, uint16 y)
213: {
214: uint16 a, b;
215: uint16 *p, *q;
216: uint16 word;
217: uint8 red, green, blue;
218:
219: for (b = 0; b < height; b++) {
220: p = (uint16 *)(ui_uipinfo.screenmem_w+(y+b)*ui_uipinfo.linewidth+x*2);
221: for (a = 0; a < width; a++) {
222: word = (((uint8 *)logo)[1]<<8) | ((uint8 *)logo)[0];
223: green = (word>>5) & 0x1f;
224: red = word & 0x1f;
225: blue = (word>>10) & 0x1f;
226: *p++ = red<<ui_uipinfo.redshift | green<<ui_uipinfo.greenshift |
227: blue<<ui_uipinfo.blueshift;
228: logo++;
229: }
230: }
231: }
232:
233: /*** ui_setupscreen - plot borders and stuff ***/
234:
235: void ui_setupscreen(void)
236: {
237: uint16 grey = 24<<ui_uipinfo.redshift | 24<<ui_uipinfo.greenshift |
238: 24<<ui_uipinfo.blueshift;
239: uint16 red = 24<<ui_uipinfo.redshift;
240:
241: ui_drawbox(red, 140, 100, 360, 280);
242: ui_drawbox(grey, 141, 101, 358, 278);
243: if (!ui_info)
244: return;
245: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 80);
246: ui_plotsprite_acorn((uint16 *)logo, 282, 40, 179, 360);
247: ui_drawbox(red, 0, 415, 640, 1);
248: ui_drawbox(grey, 0, 416, 640, 1);
249: ui_drawbox(red, 0, 65, 640, 1);
250: ui_drawbox(grey, 0, 66, 640, 1);
251: ;
252: /* draw marker for 320x224 box */
253: // ui_drawbox(grey, 160, 128, 320, 224);
254: /* draw marker for 320x240 box */
255: // ui_drawbox(grey, 160, 120, 320, 240);
256: /* draw marker for 256x224 box */
257: // ui_drawbox(grey, 192, 128, 256, 224);
258: /* draw marker for 256x240 box */
259: // ui_drawbox(grey, 192, 120, 256, 240);
260: ;
261: ui_plotstring("Generator is (c) James Ponder 1997-2000, "
262: "all rights reserved.", 0, 0);
263: ui_plotstring(VERSTRING, 640-(strlen(VERSTRING)*6), 0);
264: ;
265: ui_plotstring("[A] A button", 0, 420);
266: ui_plotstring("[S] B button", 0, 430);
267: ui_plotstring("[D] C button", 0, 440);
268: ui_plotstring("[RETURN] Start", 0, 450);
269: ui_plotstring("[ARROWS] D-pad", 0, 460);
270: ui_plotstring("[ESCAPE] QUIT", 0, 470);
271: ;
272: ui_plotstring("FPS: 00", 120, 420);
273: ui_plotstring("Skip: 00", 120, 430);
274: ui_plotstring(":", 622, 470);
275: ;
276: ui_plotstring("[F5] Toggle info:", 0, 20);
277: ui_plotstring("[F6] Toggle video:", 0, 30);
278: ui_plotstring("[F7] Toggle country:", 0, 40);
279: ui_plotstring("[F8] Toggle plotter:", 0, 50);
280: ui_plotstring("[F9] Toggle vsync:", 216, 20);
281: ui_plotstring("[F12] Restart game", 216, 50);
282: ;
283: ui_plotstring("[1] B lo:", 64*6, 20);
284: ui_plotstring("[2] B hi:", 64*6, 30);
285: ui_plotstring("[3] A lo:", 64*6, 40);
286: ui_plotstring("[4] A hi:", 64*6, 50);
287: ui_plotstring("[5] W lo:", 78*6, 20);
288: ui_plotstring("[6] W hi:", 78*6, 30);
289: ui_plotstring("[7] H: ", 78*6, 40);
290: ui_plotstring("[8] S lo:", 92*6, 20);
291: ui_plotstring("[9] S hi:", 92*6, 30);
292: ;
293: ui_plotsettings();
294: ;
295: sprintf(bigbuffer, "%s %X %s", gen_cartinfo.version,
296: gen_cartinfo.checksum, gen_cartinfo.country);
297: ui_plotstring(bigbuffer, 216, 420);
298: ui_plotstring(gen_cartinfo.name_domestic, 216, 430);
299: ui_plotstring(gen_cartinfo.name_overseas, 216, 440);
300: }
301:
302: void ui_plotsettings(void)
303: {
304: ui_plotstring(ui_info ? "On " : "Off", 126, 20);
305: ui_plotstring(vdp_pal ? "Pal " : "NTSC", 126, 30);
306: ui_plotstring(vdp_overseas ? "USA/Europe" : "Japan ", 126, 40);
307: ui_plotstring(ui_vdpsimple ? "Cell (fast) " : "Raster (slow)", 126, 50);
308: ui_plotstring(ui_vsync ? "On " : "Off", 342, 20);
309: ;
310: ui_plotstring(vdp_layerB ? "On " : "Off", (64+10)*6, 20);
311: ui_plotstring(vdp_layerBp ? "On " : "Off", (64+10)*6, 30);
312: ui_plotstring(vdp_layerA ? "On " : "Off", (64+10)*6, 40);
313: ui_plotstring(vdp_layerAp ? "On " : "Off", (64+10)*6, 50);
314: ui_plotstring(vdp_layerW ? "On " : "Off", (78+10)*6, 20);
315: ui_plotstring(vdp_layerWp ? "On " : "Off", (78+10)*6, 30);
316: ui_plotstring(vdp_layerH ? "On " : "Off", (78+10)*6, 40);
317: ui_plotstring(vdp_layerS ? "On " : "Off", (92+10)*6, 20);
318: ui_plotstring(vdp_layerSp ? "On " : "Off", (92+10)*6, 30);
319: }
320:
321: /*** ui_loop - main UI loop ***/
322:
323: int ui_loop(void)
324: {
325: char *p;
326:
327: if (ui_initload) {
328: p = gen_loadimage(ui_initload);
329: if (p) {
330: LOG_CRITICAL(("Failed to load ROM image: %s", p));
331: return 1;
332: }
333: ui_state = 2;
334: } else {
335: LOG_CRITICAL(("You must specify a ROM to load"));
336: return 1;
337: }
338: if (uip_vgamode()) {
339: LOG_CRITICAL(("Failed to start VGA mode"));
340: return 1;
341: }
342: gen_quit = 0;
343: while(!uip_checkkeyboard()) {
344: switch(ui_state) {
345: case 0: /* stopped */
346: break;
347: case 1: /* paused */
348: break;
349: case 2: /* playing */
350: ui_newframe();
351: reg68k_framestep();
352: break;
353: }
354: }
355: return 0;
356: }
357:
358: void ui_newframe(void)
359: {
360: static int hmode = 0;
361: static int skipcount = 0;
362: static char frameplots[60]; /* 60 for NTSC, 50 for PAL */
363: static unsigned int frameplots_i = 0;
364: char buf[8];
365: unsigned int i;
366: int fps;
367: time_t t = time(NULL);
368: struct tm *tm_p = localtime(&t);
369:
370: if (frameplots_i > vdp_framerate)
371: frameplots_i = 0;
372: ui_plotframe = 0;
373: if (ui_frameskip == 0) {
374: if (sound_feedback != -1)
375: ui_plotframe = 1;
376: } else {
377: if (cpu68k_frames % ui_frameskip == 0)
378: ui_plotframe = 1;
379: }
380: if (!ui_plotframe) {
381: skipcount++;
382: frameplots[frameplots_i++] = 0;
383: return;
384: }
385: if (hmode != (vdp_reg[12]&1))
386: ui_clearnext = 2;
387: if (ui_clearnext) {
388: /* horizontal size has changed, so clear whole screen and setup
389: borders etc again */
390: ui_clearnext--;
391: hmode = vdp_reg[12]&1;
392: uip_clearscreen();
393: ui_setupscreen();
394: }
395: /* count the frames we've plotted in the last vdp_framerate real frames */
396: fps = 0;
397: for (i = 0; i < vdp_framerate; i++) {
398: if (frameplots[i])
399: fps++;
400: }
401: frameplots[frameplots_i++] = 1;
402: if (!ui_info)
403: return;
404: ui_plotint2(fps, 156, 420);
405: ui_plotint2(skipcount+1, 156, 430);
406: skipcount = 0;
407: ui_plotint2(tm_p->tm_hour, 610, 470);
408: ui_plotint2(tm_p->tm_min, 628, 470);
409: }
410:
411: void ui_checkpalcache(int flag)
412: {
413: uint32 pal;
414: unsigned int col;
415: uint8 *p;
416:
417: /* this code requires that there be at least 4 bits per colour, that
418: is, three bits that come from the console's palette, and one more bit
419: when we do a dim or bright colour, i.e. this code works with 12bpp
420: upwards */
421:
422: /* this code assumes 5 bits per colour in it's calculations */
423:
424: /* the flag forces it to do the check despite the vdp_cramf buffer */
425:
426: for (col = 0; col < 64; col++) {
427: if (!flag && !vdp_cramf[col])
428: continue;
429: vdp_cramf[col] = 0;
430: p = (uint8 *)vdp_cram+2*col;
431: ui_palcache[col] = /* normal */
432: (p[0]&0xE)<<(ui_uipinfo.blueshift+1) |
433: (p[1]&0xE)<<(ui_uipinfo.redshift+1) |
434: ((p[1]&0xE0)>>4)<<(ui_uipinfo.greenshift+1);
435: ui_palcache[col+64] = /* hilight */
436: (p[0]&0xE)<<ui_uipinfo.blueshift |
437: (p[1]&0xE)<<ui_uipinfo.redshift |
438: ((p[1]&0xE0)>>4)<<ui_uipinfo.greenshift |
439: (16 << ui_uipinfo.blueshift) | (16 << ui_uipinfo.redshift) |
440: (16 << ui_uipinfo.greenshift);
441: ui_palcache[col+128] = /* shadow */
442: (p[0]&0xE)<<ui_uipinfo.blueshift |
443: (p[1]&0xE)<<ui_uipinfo.redshift |
444: ((p[1]&0xE0)>>4)<<ui_uipinfo.greenshift;
445: }
446: }
447:
448: /*** ui_convertdata - convert genesis data to 16 bit colour */
449:
450: void ui_convertdata(uint8 *indata, uint8 *outdata, unsigned int pixels)
451: {
452: unsigned int ui;
453: uint32 data;
454:
455: ui_checkpalcache(0);
456: /* not scaled, 16bpp */
457: for (ui = 0; ui < pixels; ui++) {
458: data = ui_palcache[indata[ui]];
459: ((uint16 *)outdata)[ui] = data; /* already in local endian */
460: }
461: }
462:
463: /*** ui_line - it is time to render a line ***/
464:
465: void ui_line(unsigned int line)
466: {
467: static uint8 gfx[320];
468: uint16 *scr;
469:
470: if (ui_plotframe && !ui_vdpsimple) {
471: if (((vdp_reg[12]>>1) & 3) == 3)
472: vdp_renderline_interlace2(line*2+vdp_oddframe, (uint8 *)gfx);
473: else
474: vdp_renderline(line, (uint8 *)gfx);
475: ui_convertdata(gfx, (ui_uipinfo.screenmem_w+320+((vdp_reg[12]&1)?0:64)+
476: ui_uipinfo.linewidth*(120+line+
477: ((vdp_reg[1]&1<<3)?0:8))),
478: (vdp_reg[12]&1)?320:256);
479: }
480: }
481:
482: /*** ui_endfield - end of field reached ***/
483:
484: void ui_endfield(void)
485: {
486: ui_endframe();
487: }
488:
489: /*** ui_endframe - end of frame reached ***/
490:
491: void ui_endframe(void)
492: {
493: static uint8 gfx[(320+16)*(240+16)];
494: static int counter = 0;
495: unsigned int line;
496: uint16 *scr;
497:
498: if (ui_plotframe) {
499: if (ui_vdpsimple) {
500: /* cell mode - entire frame done here */
501: vdp_renderframe(gfx+(8*(320+16))+8, 320+16); /* plot frame */
502: for (line = 0; line < vdp_vislines; line++) {
503: ui_convertdata(gfx+8+(line+8)*(320+16),
504: (ui_uipinfo.screenmem_w+320+((vdp_reg[12]&1)?0:64)+
505: ui_uipinfo.linewidth*(120+line+
506: ((vdp_reg[1]&1<<3)?0:8))),
507: (vdp_reg[12]&1)?320:256);
508: }
509: }
510: uip_displaybank(-1);
511: if (ui_vsync)
512: uip_vsync();
513: }
514: if (ui_frameskip == 0) {
515: counter++;
516: if (sound_feedback >= 0) {
517: ui_actualskip = counter;
518: counter = 0;
519: }
520: } else {
521: ui_actualskip = ui_frameskip;
522: }
523: }
524:
525: /*** logging functions ***/
526:
527: /* logging is done this way because this was the best I could come up with
528: whilst battling with macros that can only take fixed numbers of arguments */
529:
530: #define LOG_FUNC(name,level,txt) void ui_log_ ## name ## (const char *text, ...) \
531: { \
532: va_list ap; \
533: char *ll = ui_loglines[ui_logline]; \
534: char *p = bigbuffer; \
535: if (gen_loglevel >= level) { \
536: p+= sprintf(p, "%d ", ui_logcount++); \
537: p+= sprintf(p, txt); \
538: va_start(ap, text); \
539: vsprintf(p, text, ap); \
540: va_end(ap); \
541: strncpy(ll, bigbuffer, UI_LOGLINESIZE); \
542: if (++ui_logline >= UI_LOGLINES) \
543: ui_logline = 0; \
544: } \
545: }
546:
547: LOG_FUNC(debug3, 7, "DEBG ");
548: LOG_FUNC(debug2, 6, "DEBG ");
549: LOG_FUNC(debug1, 5, "DEBG ");
550: LOG_FUNC(user, 4, "USER ");
551: LOG_FUNC(verbose, 3, "---- ");
552: LOG_FUNC(normal, 2, "---- ");
553: LOG_FUNC(critical, 1, "CRIT ");
554: LOG_FUNC(request, 0, "---- ");
555:
556: /*** ui_err - log error message and quit ***/
557:
558: void ui_err(const char *text, ...)
559: {
560: va_list ap;
561: char *ll = ui_loglines[ui_logline];
562: char *p = bigbuffer;
563:
564: p+= sprintf(p, "ERROR: ");
565: va_start(ap, text);
566: vsprintf(p, text, ap);
567: va_end(ap);
568: strncpy(ll, bigbuffer, UI_LOGLINESIZE);
569: if (++ui_logline >= UI_LOGLINES)
570: ui_logline = 0;
571: ui_printlog();
572: exit(0); /* don't exit(1) because windows makes an error then! */
573: }
574:
575: /*** ui_setinfo - there is new cart information ***/
576:
577: char *ui_setinfo(t_cartinfo *cartinfo)
578: {
579: return NULL;
580: }
581:
582: /*** ui_topbit - given an integer return the top most bit set ***/
583:
584: int ui_topbit(unsigned long int bits)
585: {
586: long int bit = 31;
587: unsigned long int mask = 1<<31;
588:
589: for (; bit >= 0; bit--, mask>>= 1) {
590: if (bits & mask)
591: return bit;
592: }
593: return -1;
594: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.