![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bebox.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae|
Return to bebox.cpp CVS log | Up to [UNIX Amiga Emulator] / uae |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * BeBox port specific stuff
5: *
6: * (c) 1996 Christian Bauer
7: */
8:
9: #include <AppKit.h>
10: #include <InterfaceKit.h>
11: #include <KernelKit.h>
12:
13: #include <stdio.h>
14: #include <stdlib.h>
15: #include <string.h>
16: #define __STDC__ 1
17: #define __GNU_LIBRARY__
18: #include <getopt.h>
19: #undef __GNU_LIBRARY__
20: #undef __STDC__
21:
22: #ifndef __bebox__
23: #error Compiling bebox.cpp, but __bebox__ unset.
24: #endif
25:
26: extern "C" {
27: #include "sysconfig.h"
28: #include "sysdeps.h"
29: #include "config.h"
30: #include "options.h"
31: #include "memory.h"
32: #include "custom.h"
33: #include "newcpu.h"
34: #include "disk.h"
35: #include "debug.h"
36: #include "xwin.h"
37: #include "os.h"
38: #include "filesys.h"
39: #include "keybuf.h"
40: #include "keyboard.h"
41: }
42:
43:
44: class UAEWindow;
45: class BitmapView;
46: class Emulator;
47:
48:
49: /*
50: * The BeOS application object
51: */
52:
53: class UAE : public BApplication {
54: public:
55: UAE();
56: virtual void ArgvReceived(int argc, char **argv);
57: virtual void ReadyToRun(void);
58: virtual bool QuitRequested(void);
59: virtual void AboutRequested(void);
60:
61: private:
62: BBitmap *the_bitmap;
63: UAEWindow *main_window;
64: Emulator *the_emulator;
65: };
66:
67:
68: /*
69: * The window in which the Amiga graphics are displayed, handles I/O
70: */
71:
72: class UAEWindow : public BWindow {
73: public:
74: UAEWindow(BRect frame, BBitmap *bitmap);
75: virtual bool QuitRequested(void);
76: virtual void WindowActivated(bool active);
77:
78: private:
79: BitmapView *main_view;
80: };
81:
82:
83: /*
84: * A simple view class for blitting a bitmap on the screen
85: */
86:
87: class BitmapView : public BView {
88: public:
89: BitmapView(BRect frame, BBitmap *bitmap);
90: virtual void Draw(BRect update);
91: void Draw(BRect from, BRect to);
92:
93: private:
94: BBitmap *the_bitmap;
95: };
96:
97:
98: /*
99: * For running the emulation in its own thread
100: */
101:
102: class Emulator {
103: public:
104: Emulator() {thread_running = FALSE;}
105: void Run(void);
106: void Quit(void);
107:
108: private:
109: static long thread_invoc(Emulator *obj);
110: void thread_func(void);
111:
112: thread_id the_thread;
113: bool thread_running;
114: };
115:
116:
117: // Keyboard and mouse
118: int buttonstate[3];
119: int newmousecounters;
120: int lastmx, lastmy;
121:
122: key_info old_key_info;
123: bool inwindow;
124: bool window_open;
125:
126: // Color map and bitmap
127: xcolnr xcolors[4096];
128: struct vidbuf_description gfxvidinfo;
129:
130: int vsize, hsize, hpixels;
131:
132: BitmapView *bitmap_view;
133: UAEWindow *bitmap_window;
134:
135:
136: // Array for converting Be keycodes to Amiga keycodes
137: int keycode2amiga[128] = {
138: -1, AK_ESC, AK_F1, AK_F2, AK_F3, AK_F4, AK_F5, AK_F6,
139: AK_F7, AK_F8, AK_F9, AK_F10, AK_LALT, AK_mousestuff, AK_RALT, -1,
140:
141: -1, AK_BACKQUOTE, AK_1, AK_2, AK_3, AK_4, AK_5, AK_6,
142: AK_7, AK_8, AK_9, AK_0, AK_MINUS, AK_EQUAL, AK_BS, AK_HELP,
143:
144: AK_NPLPAREN, AK_RAMI, AK_NPLPAREN, AK_NPDIV, AK_NPMUL, AK_NPSUB, AK_TAB, AK_Q,
145: AK_W, AK_E, AK_R, AK_T, AK_Y, AK_U, AK_I, AK_O,
146:
147: AK_P, AK_LBRACKET, AK_RBRACKET, AK_BACKSLASH, AK_DEL, AK_NPRPAREN, AK_LAMI, AK_NP7,
148: AK_NP8, AK_NP9, AK_NPADD, AK_CAPSLOCK, AK_A, AK_S, AK_D, AK_F,
149:
150: AK_G, AK_H, AK_J, AK_K, AK_L, AK_SEMICOLON, AK_QUOTE, AK_RET,
151: AK_NP4, AK_NP5, AK_NP6, AK_LSH, AK_Z, AK_X, AK_C, AK_V,
152:
153: AK_B, AK_N, AK_M, AK_COMMA, AK_PERIOD, AK_SLASH, AK_RSH, AK_UP,
154: AK_NP1, AK_NP2, AK_NP3, AK_ENT, AK_CTRL, AK_LAMI, AK_SPC, AK_RAMI,
155:
156: AK_RALT, AK_LF, AK_DN, AK_RT, AK_NP0, AK_NPDEL, AK_LALT, AK_RALT,
157: AK_LTGT, -1, -1, -1, -1, -1, -1, -1,
158:
159: -1, -1, -1, -1, -1, -1, -1, -1,
160: -1, -1, -1, -1, -1, -1, -1, -1
161: };
162:
163:
164: /*
165: * Create application object and start it
166: */
167:
168: main()
169: {
170: UAE *the_app;
171:
172: the_app = new UAE();
173: the_app->Run();
174: delete the_app;
175:
176: return 0;
177: }
178:
179:
180: /*
181: * UAE Constructor: Initialize member variables
182: */
183:
184: UAE::UAE() : BApplication('UAEm')
185: {
186: the_bitmap = NULL;
187: the_emulator = NULL;
188: main_window = NULL;
189: window_open = FALSE;
190: }
191:
192:
193: /*
194: * Parse command line options
195: */
196:
197: void usage(void)
198: {
199: printf("UAE - The Un*x Amiga emulator\n");
200: printf("Summary of command-line options:\n");
201: printf(" -h : Print help\n");
202: printf(" -m VOLNAME:mount_point : mount file system at <mount point> as AmigaDOS\n"
203: " volume VOLNAME:\n");
204: printf(" -M VOLNAME:mount_point : like -m, but mount read-only\n");
205: printf(" -a : Don't mount the harddisk file automatically.\n"
206: " Useful only for testing.\n");
207: printf(" -s : Emulate 1MB slow memory at 0xC00000\n");
208: printf(" -F n : Emulate n MB fast memory at 0x200000\n");
209: printf(" -f n : Set the frame rate to 1/n\n");
210: printf(" -d : Draw the screen with the right aspect\n");
211: printf(" -D : Start up the built-in debugger\n");
212: printf(" -[0123] file : Use file instead of df[0123].adf as disk image file\n");
213: printf(" -r file : Use file as ROM image instead of kick.rom\n");
214: printf(" -p filename : Use filename to save printer output (may be LPT1: ?)\n");
215: printf(" -J : Fake joystick emulation with the numeric pad.\n");
216: printf(" -g : Turn on gfx-lib replacement.\n");
217: printf(" -d mode : Select resolution with the mode parameter.\n");
218: printf(" -H mode : Set the number of colors with the mode parameter.\n");
219: printf("\n");
220: printf("Valid resolutions: 0 (320x200); 1 (320x240); 2 (320x400); 3 (800x600);\n"
221: " 4 (800x600, correct aspect)\n"
222: "Valid color modes: 0 (256 colors); 1 (32768 colors); 2 (65536 colors)\n"
223: "UAE may choose to ignore the color mode/resolution setting.\n");
224: }
225:
226: void UAE::ArgvReceived(int argc, char **argv)
227: {
228: int c;
229:
230: while(((c = getopt(argc, argv, "Df:gd:hF:asJm:M:0:1:2:3:r:H:p:")) != EOF)) switch(c) {
231: case 'h': usage(); exit(0);
232:
233: case '0': strncpy(df0, optarg, 255); df0[255] = 0; break;
234: case '1': strncpy(df1, optarg, 255); df1[255] = 0; break;
235: case '2': strncpy(df2, optarg, 255); df2[255] = 0; break;
236: case '3': strncpy(df3, optarg, 255); df3[255] = 0; break;
237: case 'r': strncpy(romfile, optarg, 255); romfile[255] = 0; break;
238: case 'p': strncpy(prtname, optarg, 255); prtname[255] = 0; break;
239: case 'm':
240: case 'M':
241: {
242: /* mount file system (repeatable)
243: * syntax: [-m | -M] VOLNAME:/mount_point
244: * example: -M CDROM:/cdrom -m UNIXFS:./disk
245: */
246: static int mount_seen = 0;
247: char buf[256];
248: char *s2;
249: int readonly = (c == 'M');
250:
251: if (mount_seen)
252: fprintf(stderr, "warning: multiple mounts confuse Kickstart 1.3\n");
253: mount_seen = 1;
254: strncpy(buf, optarg, 255); buf[255] = 0;
255: s2 = strchr(buf, ':');
256: if(s2) {
257: *s2++ = '\0';
258: add_filesys_unit(buf, s2, readonly);
259: } else {
260: fprintf(stderr, "Usage: [-m | -M] VOLNAME:/mount_point\n");
261: }
262: }
263: break;
264:
265: case 'f': framerate = atoi(optarg); break;
266: case 'D': use_debugger = 1; break;
267: case 'J': fake_joystick = 1; break;
268: case 'a': automount_uaedev = 0; break;
269: case 's': use_slow_mem = 1; break;
270: case 'g': use_gfxlib = 1; break;
271:
272: case 'F':
273: fastmem_size = atoi(optarg) * 0x100000;
274: if (fastmem_size != 0x100000 && fastmem_size != 0x200000
275: && fastmem_size != 0x400000 && fastmem_size != 0x800000)
276: {
277: fastmem_size = 0;
278: fprintf(stderr, "Unsupported fastmem size!\n");
279: }
280:
281: break;
282:
283: case 'd':
284: screen_res = atoi(optarg);
285: if (screen_res >= 0 && screen_res <= 4) {
286: } else {
287: fprintf(stderr, "Bad video mode selected. Using default.\n");
288: screen_res = 3;
289: }
290: dont_want_aspect = screen_res != 4;
291: use_lores = screen_res < 3;
292: break;
293:
294: case 'H':
295: color_mode = atoi(optarg);
296: if (color_mode < 0 || color_mode > 2) {
297: fprintf(stderr, "Bad color mode selected. Using default.\n");
298: color_mode = 0;
299: }
300: break;
301: }
302: }
303:
304:
305: /*
306: * Arguments processed, create and start emulation
307: */
308:
309: void UAE::ReadyToRun(void)
310: {
311: vsize = dont_want_aspect ? numscrlines : numscrlines*2;
312: hsize = use_lores ? 400 : 800;
313: hpixels = use_lores ? 320 : 796;
314:
315: // Allocate bitmap
316: the_bitmap = new BBitmap(BRect(0, 0, hsize-1, vsize-1), B_COLOR_8_BIT);
317:
318: // Set up vidinfo
319: gfxvidinfo.bufmem = (char *)the_bitmap->Bits();
320: gfxvidinfo.rowbytes = the_bitmap->BytesPerRow();
321: gfxvidinfo.pixbytes = 1;
322: gfxvidinfo.maxblocklines = 100;
323:
324: // Open window
325: main_window = new UAEWindow(BRect(0, 0, hpixels-1, vsize-1), the_bitmap);
326:
327: // Initialize mouse and keyboard variables
328: buttonstate[0] = buttonstate[1] = buttonstate[2] = FALSE;
329: lastmx = lastmy = 0;
330: newmousecounters = FALSE;
331: inwindow = TRUE;
332:
333: // Start emulation
334: the_emulator = new Emulator;
335: the_emulator->Run();
336: }
337:
338:
339: /*
340: * Quit requested (either by menu or by closing the window)
341: */
342:
343: bool UAE::QuitRequested(void)
344: {
345: if (BApplication::QuitRequested()) {
346:
347: // Stop emulation
348: if (the_emulator) {
349: the_emulator->Quit();
350: delete the_emulator;
351: }
352:
353: // Deallocate bitmap
354: if (the_bitmap)
355: delete the_bitmap;
356:
357: return TRUE;
358: }
359: return FALSE;
360: }
361:
362:
363: /*
364: * Display "about" window
365: */
366:
367: void UAE::AboutRequested(void)
368: {
369: char str[256];
370:
371: sprintf(str, "UAE V0.5.3 by Bernd Schmidt\nBeBox port by Christian Bauer");
372: BAlert *the_alert = new BAlert("", str, "OK");
373: the_alert->Go();
374: }
375:
376:
377: /*
378: * UAE Window constructor
379: */
380:
381: UAEWindow::UAEWindow(BRect frame, BBitmap *bitmap) : BWindow(frame, "UAE", B_TITLED_WINDOW, B_NOT_RESIZABLE)
382: {
383: int r, g, b, i;
384:
385: // Move window to right position
386: MoveTo(80, 60);
387:
388: // Create bitmap view
389: Lock();
390: main_view = new BitmapView(frame, bitmap);
391: AddChild(main_view);
392: main_view->GetKeys(&old_key_info, FALSE);
393: Unlock();
394:
395: bitmap_view = main_view;
396: bitmap_window = this;
397:
398: // Initialize xcolors
399: i = 0;
400: for (r=0; r<16; r++) {
401: for (g=0; g<16; g++) {
402: for (b=0; b<16; b++)
403: xcolors[i++] = index_for_color(r<<4 | r, g<<4 | g, b<<4 | b);
404: }
405: }
406:
407: // Show window
408: Show();
409: window_open = TRUE;
410: }
411:
412:
413: /*
414: * Closing the window quits UAE
415: */
416:
417: bool UAEWindow::QuitRequested(void)
418: {
419: window_open = FALSE;
420: be_app->PostMessage(B_QUIT_REQUESTED);
421: return TRUE;
422: }
423:
424:
425: /*
426: * Window was (de)activated
427: */
428:
429: void UAEWindow::WindowActivated(bool active)
430: {
431: inwindow = active;
432: }
433:
434:
435: /*
436: * Bitmap view constructor
437: */
438:
439: BitmapView::BitmapView(BRect frame, BBitmap *bitmap) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW)
440: {
441: the_bitmap = bitmap;
442: }
443:
444:
445: /*
446: * Blit the bitmap
447: */
448:
449: void BitmapView::Draw(BRect update)
450: {
451: DrawBitmap(the_bitmap, update, update);
452: }
453:
454: void BitmapView::Draw(BRect from, BRect to)
455: {
456: DrawBitmap(the_bitmap, from, to);
457: }
458:
459:
460: /*
461: * Start main emulation thread
462: */
463:
464: void Emulator::Run(void)
465: {
466: // Initialize everything
467: produce_sound = FALSE;
468: init_joystick();
469: keybuf_init ();
470: memory_init();
471: custom_init();
472: DISK_init();
473: init_m68k();
474: MC68000_reset();
475:
476: // Start the emulation thread
477: the_thread = spawn_thread(thread_invoc, "UAE 68000", B_NORMAL_PRIORITY, this);
478: resume_thread(the_thread);
479: thread_running = TRUE;
480: }
481:
482:
483: /*
484: * Stop main emulation thread
485: */
486:
487: void Emulator::Quit(void)
488: {
489: // Kill the thread if it is running
490: if (thread_running) {
491: kill_thread(the_thread);
492: thread_running = FALSE;
493: }
494:
495: close_joystick();
496: }
497:
498:
499: /*
500: * The thread's main function
501: */
502:
503: long Emulator::thread_invoc(Emulator *obj)
504: {
505: obj->thread_func();
506: return 0;
507: }
508:
509: void Emulator::thread_func(void)
510: {
511: // This jumps to MC68000_run() and executes the main loop
512: debug();
513: thread_running = FALSE;
514: }
515:
516:
517: /*
518: * Redraw a line
519: */
520:
521: void flush_line(int y)
522: {
523: if (window_open) {
524: bitmap_window->Lock();
525: bitmap_view->Draw(BRect(0, y, hpixels-1, y));
526: bitmap_window->Unlock();
527: }
528: }
529:
530:
531: /*
532: * Redraw a block
533: */
534:
535: void flush_block(int ystart, int ystop)
536: {
537: int xs = use_lores ? prev_max_diwstop - 328 : 0;
538:
539: if (window_open) {
540: bitmap_window->Lock();
541: bitmap_view->Draw(BRect(xs, ystart, hpixels+xs-1, ystop), BRect(0, ystart, hpixels-1, ystop));
542: bitmap_window->Unlock();
543: }
544: }
545:
546:
547: /*
548: * Redraw the screen
549: */
550:
551: void flush_screen(int ystart, int ystop)
552: {
553: }
554:
555:
556: /*
557: * Poll mouse and keyboard
558: */
559:
560: void handle_events(void)
561: {
562: key_info the_key_info;
563: int be_code, be_byte, be_bit, amiga_code;
564: BPoint mouse_point;
565: ulong mouse_buttons;
566:
567: // Keyboard
568: if (window_open && inwindow) {
569: bitmap_window->Lock();
570: bitmap_view->GetKeys(&the_key_info, FALSE);
571: bitmap_window->Unlock();
572:
573: for (be_code=0; be_code<0x80; be_code++) {
574: be_byte = be_code >> 3;
575: be_bit = 1 << (~be_code & 7);
576:
577: // Key state changed?
578: if ((the_key_info.key_states[be_byte] & be_bit)
579: != (old_key_info.key_states[be_byte] & be_bit)) {
580:
581: amiga_code = keycode2amiga[be_code];
582: if (the_key_info.key_states[be_byte] & be_bit) {
583:
584: // Key pressed
585: if (amiga_code == AK_mousestuff)
586: togglemouse();
587: else
588: record_key(amiga_code << 1);
589: } else {
590:
591: // Key released
592: record_key((amiga_code << 1) | 1);
593: }
594: }
595: }
596: old_key_info = the_key_info;
597:
598: // "Affengriff"
599: if ((the_key_info.key_states[0x5c >> 3] & (1 << (~0x5c & 7)))
600: && (the_key_info.key_states[0x5d >> 3] & (1 << (~0x5d & 7)))
601: && (the_key_info.key_states[0x5f >> 3] & (1 << (~0x5f & 7))))
602: MC68000_reset();
603:
604: // Scroll lock toggles inhibit_frame
605: inhibit_frame = the_key_info.key_states[0x0f >> 3] & (1 << (~0x0f & 7));
606: }
607:
608: // Mouse
609: if (window_open && inwindow) {
610: bitmap_window->Lock();
611: bitmap_view->GetMouse(&mouse_point, &mouse_buttons, FALSE);
612: bitmap_window->Unlock();
613: lastmx = mouse_point.x;
614: lastmy = mouse_point.y;
615:
616: buttonstate[0] = mouse_buttons & B_PRIMARY_MOUSE_BUTTON;
617: buttonstate[1] = mouse_buttons & B_TERTIARY_MOUSE_BUTTON;
618: buttonstate[2] = mouse_buttons & B_SECONDARY_MOUSE_BUTTON;
619: }
620: }
621:
622:
623: int debuggable(void)
624: {
625: return TRUE;
626: }
627:
628: int needmousehack(void)
629: {
630: return TRUE;
631: }
632:
633: void LED(int on)
634: {
635: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.