void gfx_set_picasso_state (int on) { printf("gfx_set_picasso_state %d\n", on); if (on == screen_is_picasso) return; viewport_shutdown(); screen_is_picasso = on; if (on) { bm_format = pixel_p96_to_glgfx(picasso_vidinfo.rgbformat); bm_width = picasso_vidinfo.width; bm_height = picasso_vidinfo.height; viewport_setup(); } else { bm_format = glgfx_pixel_format_a4r4g4b4; bm_format = glgfx_pixel_format_a8b8g8r8; bm_width = gfxvidinfo.width; bm_height = gfxvidinfo.height; viewport_setup(); reset_drawing(); } if (on) { DX_SetPalette(0, 256); } }
void doflashscreen (void) { #if 0 flashscreen = 10; init_colors (); picasso_refresh (); reset_drawing (); flush_screen (gfxvidinfo.outbuffer, 0, 0); #endif }
MainWindow::MainWindow() { drawingarea = new DrawingArea(); QPalette p; p.setColor(QPalette::Background, Qt::white); drawingarea -> setPalette(p); drawingarea -> setBackgroundRole(QPalette::Base); p.setColor(QPalette::Background, Qt::white); drawingarea -> setPalette(p); drawingarea -> setAutoFillBackground(true); drawingarea -> setMouseTracking(1); drawingarea -> setCursor(Qt::CrossCursor); drawingarea -> on_mouse = false; drawingarea -> setMouseTracking(1); drawingarea -> setWindowFlags(Qt::Window); drawingarea -> aviable_complete_polygon = false; buttonReset = new QPushButton; buttonReset ->setText("Reset"); buttonComplete = new QPushButton; buttonComplete ->setText("Complete"); statusBar = new QLabel("status"); this ->setUpdatesEnabled(true); QGridLayout *mainLayout = new QGridLayout; mainLayout->setColumnStretch(0, 1); mainLayout->setColumnStretch(3, 1); mainLayout->addWidget( drawingarea, 0, 0, 1, 4); mainLayout->addWidget(statusBar, 1, 0, 1, 3); mainLayout->addWidget(buttonComplete,1, 1, 1, 1); mainLayout->addWidget(buttonReset, 1, 2, 1, 1); setLayout(mainLayout); int width = drawingarea->width(); s = QString::number(width); buttonReset->setEnabled(false); buttonComplete->setEnabled(false); connect(this -> drawingarea, SIGNAL(releaseMouse()), this, SLOT(grabMouse()),Qt::DirectConnection); connect(this -> drawingarea, SIGNAL(have_points(int)), this, SLOT(setPointsnumber(int)),Qt::DirectConnection); connect(this->buttonReset, SIGNAL(clicked()), this ->drawingarea, SLOT(reset_drawing()), Qt::DirectConnection ); connect(this->buttonReset, SIGNAL(clicked()), this, SLOT(reseting())); connect(this->buttonComplete, SIGNAL(clicked()), this ->drawingarea, SLOT(complete_drawing()), Qt::DirectConnection); connect(this ->drawingarea, SIGNAL(have_been_reseting(QString)),this->statusBar, SLOT(setText(QString)),Qt::AutoConnection); connect(this->drawingarea, SIGNAL(send_polygon_size(QString)), this->statusBar, SLOT(setText(QString )),Qt::DirectConnection); connect(this->drawingarea,SIGNAL(update_status_finish(QString)),this->statusBar,SLOT(update()),Qt::DirectConnection); connect(this->drawingarea,SIGNAL(update_status_finish(QString)),this->statusBar,SLOT(setText(QString)),Qt::DirectConnection); connect(this->drawingarea,SIGNAL(update_status(QString)),this->statusBar,SLOT(setText(QString)),Qt::DirectConnection); connect(this->drawingarea,SIGNAL(enableCompleteDrawing(bool)),this->buttonComplete,SLOT(setEnabled(bool)),Qt::DirectConnection); connect(this->drawingarea, SIGNAL(leaveEvent(QMouseEvent)),this,SLOT(showNormal()),Qt::DirectConnection ); connect(this,SIGNAL(grabMouse()),this->drawingarea,SLOT(changeOnMouse()),Qt::DirectConnection); connect(this->drawingarea, SIGNAL(HoverLeave(QPoint&,QPoint)), this -> drawingarea, SLOT(changeOnMouse()), Qt::DirectConnection); connect(this,SIGNAL(enterEvent_()),this->drawingarea, SLOT(changeOnMouse()),Qt::DirectConnection); connect(this -> drawingarea, SIGNAL(fail_to_add_peak(QString)), this->statusBar, SLOT(setText(QString)),Qt::DirectConnection); }
void hsyncstuff (void) //only generate Interrupts when //writebuffer is complete flushed //check state of lwin rwin { //static int keycheck = 0; #if 0 // DISABLED -- OLD AHI VERSION? #ifdef AHI { //begin ahi_sound static int count; if (ahi_on) { count++; //15625/count freebuffer check if(count > ahi_pollrate) { ahi_updatesound (1); count = 0; } } } //end ahi_sound #endif #endif #if 0 // DISABLED FOR NOW #ifdef PARALLEL_PORT keycheck++; if(keycheck >= 1000) { if (prtopen) flushprtbuf (); { if (flashscreen > 0) { flashscreen--; if (flashscreen == 0) { init_colors (); reset_drawing (); picasso_refresh (); flush_screen (gfxvidinfo.outbuffer, 0, 0); } } } keycheck = 0; } if (currprefs.parallel_autoflush_time && !currprefs.parallel_postscript_detection) { parflush++; if (parflush / ((currprefs.ntscmode ? MAXVPOS_NTSC : MAXVPOS_PAL) * MAXHPOS_PAL / maxhpos) >= currprefs.parallel_autoflush_time * 50) { flushprinter (); parflush = 0; } } #endif #endif }
/* A key thing here is to populate the struct gfxvidinfo; most of it is done * in the subinit functions. * * We try hardware accelerated graphics via Graphics3D, If Chrome doesn't * support it on the given adapter/driver/OS combination, we fall back to * Graphics2D, which is generally speaking slower. */ int32_t graphics_init(void) { /* Set up the common parts of the gfxvidinfo struct here. The subinit * functions for 2D and 3D initialize the remaining values appropriately. */ /* TODO(cstefansen): Generalize resolution. For now we force 720x568. */ gfxvidinfo.width = currprefs.gfx_size_fs.width = 720; gfxvidinfo.height = currprefs.gfx_size_fs.height = 568; gfxvidinfo.emergmem = 0; gfxvidinfo.linemem = 0; gfxvidinfo.maxblocklines = MAXBLOCKLINES_MAX; gfxvidinfo.lockscr = pepper_lockscr; gfxvidinfo.unlockscr = pepper_unlockscr; gfxvidinfo.flush_line = pepper_flush_line; gfxvidinfo.flush_block = pepper_flush_block; gfxvidinfo.flush_clear_screen = pepper_flush_clear_screen; /* Try 3D graphics. */ using_3d = 1; if (!graphics_3d_subinit(&Rmask, &Gmask, &Bmask, &Amask)) { DEBUG_LOG("Could not initialize hardware accelerated graphics " "(Graphics3D).\n"); using_3d = 0; /* Try 2D graphics. */ if (!graphics_2d_subinit(&Rmask, &Gmask, &Bmask, &Amask)) { DEBUG_LOG("Could not initialize 2D graphics (Graphics2D).\n"); return 0; } } reset_drawing(); init_colors(); DEBUG_LOG("Screen height : %d\n", gfxvidinfo.height); DEBUG_LOG("Screen width : %d\n", gfxvidinfo.width); DEBUG_LOG("Using Graphics3D?: %d\n", using_3d); DEBUG_LOG("Bytes per pixel : %d\n", gfxvidinfo.pixbytes); DEBUG_LOG("Bytes per line : %d\n", gfxvidinfo.rowbytes); DEBUG_LOG("Buffer address : %p\n", gfxvidinfo.bufmem); return 1; }
void Screen_SetFullUpdate(void) { reset_drawing(); }
static void graphics_subinit (void) { XSetWindowAttributes wattr; XClassHint classhint; XWMHints *hints; unsigned long valuemask; dgamode = screen_is_picasso ? currprefs.gfx_pfullscreen : currprefs.gfx_afullscreen; dgamode = dgamode && dgaavail; wattr.background_pixel = /*black.pixel*/0; wattr.backing_store = Always; wattr.backing_planes = bitdepth; wattr.border_pixmap = None; wattr.border_pixel = /*black.pixel*/0; wattr.colormap = cmap; valuemask = (CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWBackingPlanes | CWColormap); if (dgamode) { wattr.event_mask = DGA_EVENTMASK; wattr.override_redirect = 1; valuemask |= CWOverrideRedirect; } else wattr.event_mask = EVENTMASK; XSync (display, 0); delete_win = XInternAtom(display, "WM_DELETE_WINDOW", False); mywin = XCreateWindow (display, rootwin, 0, 0, current_width, current_height, 0, bitdepth, InputOutput, vis, valuemask, &wattr); XSetWMProtocols (display, mywin, &delete_win, 1); XSync (display, 0); XStoreName (display, mywin, PACKAGE_NAME); XSetIconName (display, mywin, PACKAGE_NAME); /* set class hint */ classhint.res_name = (char *)"UAE"; classhint.res_class = (char *)"UAEScreen"; XSetClassHint(display, mywin, &classhint); hints = XAllocWMHints(); /* Set window group leader to self to become an application * that can be hidden by e.g. WindowMaker. * Would be more useful if we could find out what the * (optional) GTK+ window ID is :-/ */ hints->window_group = mywin; hints->flags = WindowGroupHint; XSetWMHints(display, mywin, hints); XMapRaised (display, mywin); XSync (display, 0); mygc = XCreateGC (display, mywin, 0, 0); if (dgamode) { #ifdef USE_DGA_EXTENSION enter_dga_mode (); /*setuid(getuid());*/ picasso_vidinfo.rowbytes = fb_width * picasso_vidinfo.pixbytes; #endif } else { get_image (current_width, current_height, &ami_dinfo); if (screen_is_picasso) { get_image (current_width, current_height, &pic_dinfo); picasso_vidinfo.rowbytes = pic_dinfo.ximg->bytes_per_line; } } picasso_vidinfo.extra_mem = 1; gfxvidinfo.flush_screen = x11_flush_screen; gfxvidinfo.lockscr = x11_lock; gfxvidinfo.unlockscr = x11_unlock; if (need_dither) { gfxvidinfo.maxblocklines = 0; gfxvidinfo.rowbytes = gfxvidinfo.pixbytes * currprefs.gfx_width_win; gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes); gfxvidinfo.flush_line = x11_flush_line_dither; } else if (! dgamode) { gfxvidinfo.emergmem = 0; gfxvidinfo.linemem = 0; gfxvidinfo.bufmem = (uae_u8 *)ami_dinfo.image_mem; gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line; if (currprefs.x11_use_low_bandwidth) { write_log ("Doing low-bandwidth output.\n"); gfxvidinfo.maxblocklines = 0; gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line; gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes); if (shmavail && currprefs.x11_use_mitshm) { switch (gfxvidinfo.pixbytes) { case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit_mitshm; break; case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit_mitshm; break; default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit_mitshm; break; } } else { switch (gfxvidinfo.pixbytes) { case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit; break; case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit; break; default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit; break; } } } else { gfxvidinfo.maxblocklines = MAXBLOCKLINES_MAX; if (shmavail && currprefs.x11_use_mitshm) gfxvidinfo.flush_block = x11_flush_block_mitshm; else gfxvidinfo.flush_block = x11_flush_block; } } if (visualInfo.VI_CLASS != TrueColor && ! screen_is_picasso) { int i; for (i = 0; i < 256; i++) XStoreColor (display, cmap, parsed_xcolors + i); } #ifdef USE_DGA_EXTENSION if (dgamode) { dga_colormap_installed = 0; XF86DGAInstallColormap (display, screen, cmap2); XF86DGAInstallColormap (display, screen, cmap); } #endif if (! dgamode) { if (!currprefs.hide_cursor) XDefineCursor (display, mywin, xhairCursor); else XDefineCursor (display, mywin, blankCursor); cursorOn = 1; } mousehack = !dgamode; if (screen_is_picasso) { picasso_has_invalid_lines = 0; picasso_invalid_start = picasso_vidinfo.height + 1; picasso_invalid_stop = -1; memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines); } else reset_drawing (); inwindow = 0; inputdevice_release_all_keys (); reset_hotkeys (); }
static int viewport_setup(void) { intptr_t width, height, format, rowbytes, pixbytes; intptr_t rb = 0, gb = 0, bb = 0, ab = 0; intptr_t rs = 0, gs = 0, bs = 0, as = 0; printf("creating bitmap\n"); bitmap = glgfx_bitmap_create(glgfx_bitmap_attr_width, bm_width, glgfx_bitmap_attr_height, bm_height, glgfx_bitmap_attr_format, bm_format, glgfx_tag_end); if (bitmap == NULL) { return 0; } printf("created bitmap %d %d format %08lx\n", bm_width, bm_height, bm_format); uint32_t* buffer; if ((buffer = glgfx_bitmap_lock(bitmap, false, true, glgfx_tag_end)) != NULL) { int x, y; for (y = 0; y < bm_height; y += 1) { for (x = 0; x < bm_width; x += 1) { buffer[x+y*bm_width] = glgfx_pixel_create_a8b8g8r8(y*255/bm_height, 0, x*255/bm_width, 128); } } if (glgfx_bitmap_unlock(bitmap, glgfx_tag_end)) { printf("updated bitmap\n"); } } glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_width, &width); glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_height, &height); glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_format, &format); glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_bytesperrow, &rowbytes); glgfx_pixel_getattr(format, glgfx_pixel_attr_bytesperpixel, &pixbytes); glgfx_pixel_getattr(format, glgfx_pixel_attr_redbits, &rb); glgfx_pixel_getattr(format, glgfx_pixel_attr_greenbits, &gb); glgfx_pixel_getattr(format, glgfx_pixel_attr_bluebits, &bb); glgfx_pixel_getattr(format, glgfx_pixel_attr_alphabits, &ab); glgfx_pixel_getattr(format, glgfx_pixel_attr_redshift, &rs); glgfx_pixel_getattr(format, glgfx_pixel_attr_greenshift, &gs); glgfx_pixel_getattr(format, glgfx_pixel_attr_blueshift, &bs); glgfx_pixel_getattr(format, glgfx_pixel_attr_alphashift, &as); alloc_colors64k(rb, gb, bb, rs, gs, bs, ab, as, ((1 << ab) - 1), 0 /* byte swap? */ ); // Set up callback functions gfxvidinfo.flush_line = _flush_line; gfxvidinfo.flush_block = _flush_block; gfxvidinfo.flush_screen = _flush_screen; gfxvidinfo.flush_clear_screen = _flush_clear_screen; gfxvidinfo.lockscr = _lockscr; gfxvidinfo.unlockscr = _unlockscr; #ifdef PICASSO96 if (!screen_is_picasso) { #endif gfxvidinfo.width = width; gfxvidinfo.height = height; gfxvidinfo.pixbytes = pixbytes; gfxvidinfo.rowbytes = rowbytes; gfxvidinfo.bufmem = NULL; gfxvidinfo.emergmem = malloc(rowbytes); gfxvidinfo.maxblocklines = height; // gfxvidinfo.maxblocklines = 0; gfxvidinfo.linemem = NULL; reset_drawing (); #ifdef PICASSO96 } else { picasso_has_invalid_lines = 0; picasso_invalid_start = height + 1; picasso_invalid_stop = -1; picasso_vidinfo.width = width; picasso_vidinfo.height = height; picasso_vidinfo.depth = rb + gb + bb + ab; picasso_vidinfo.pixbytes = pixbytes; picasso_vidinfo.rowbytes = rowbytes; picasso_vidinfo.extra_mem = 1; p96_buffer = malloc(width*height*pixbytes); p96_bytes_per_row = width*pixbytes; memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines); } #endif if (fullscreen) { rasinfo = glgfx_viewport_addbitmap(viewport, bitmap, glgfx_rasinfo_attr_x, 0, glgfx_rasinfo_attr_y, 0, glgfx_rasinfo_attr_width, real_width, glgfx_rasinfo_attr_height, real_height, glgfx_tag_end); } else { rasinfo = glgfx_viewport_addbitmap(viewport, bitmap, glgfx_rasinfo_attr_x, (real_width - bm_width) / 2, glgfx_rasinfo_attr_y, (real_height - bm_height) / 2, glgfx_rasinfo_attr_width, width, glgfx_rasinfo_attr_height, height, glgfx_tag_end); } if (rasinfo == NULL) { return 0; } inputdevice_release_all_keys(); reset_hotkeys(); printf("viewport_setup -> 1\n"); return 1; }
void real_main (int argc, char **argv) { FILE *hf; #ifdef USE_SDL SDL_Init (SDL_INIT_EVERYTHING | SDL_INIT_NOPARACHUTE); #endif default_prefs (&currprefs); #ifdef SYSTEM_CFGDIR scan_configs (SYSTEM_CFGDIR); #endif /* Can be overriden in graphics_setup, although there's not much of a point. Fullscreen modes are filled in by graphics_setup. */ gfx_windowed_modes = default_windowed_modes; n_windowed_modes = sizeof default_windowed_modes / sizeof *default_windowed_modes; if (! graphics_setup ()) { exit (1); } rtarea_init (); hardfile_install (); scsidev_install (); parse_cmdline_and_init_file (argc, argv); machdep_init (); init_gtod (); if (! setup_sound ()) { write_log ("Sound driver unavailable: Sound output disabled\n"); currprefs.produce_sound = 0; } inputdevice_init (); changed_prefs = currprefs; no_gui = ! currprefs.start_gui; if (! no_gui) { int err = gui_init (1); currprefs = changed_prefs; if (err == -1) { write_log ("Failed to initialize the GUI\n"); } else if (err == -2) { exit (0); } } if (sound_available && currprefs.produce_sound > 1 && ! init_audio ()) { write_log ("Sound driver unavailable: Sound output disabled\n"); currprefs.produce_sound = 0; } fixup_prefs (&currprefs); changed_prefs = currprefs; #ifdef SYSTEM_ROMDIR scan_roms (SYSTEM_ROMDIR, ROMLOC_SYSTEM); #endif scan_roms (currprefs.path_rom, ROMLOC_USER); /* Install resident module to get 8MB chipmem, if requested */ rtarea_setup (); keybuf_init (); /* Must come after init_joystick */ expansion_init (); memory_init (); filesys_install (); bsdlib_install (); emulib_install (); uaeexe_install (); native2amiga_install (); custom_init (); /* Must come after memory_init */ serial_init (); DISK_init (); reset_frame_rate_hack (); init_m68k(); /* must come after reset_frame_rate_hack (); */ gui_update (); if (graphics_init ()) { reset_drawing (); setup_brkhandler (); if (currprefs.start_debugger && debuggable ()) activate_debugger (); start_program (); } leave_program (); }
int graphics_init(bool mousecapture) { write_log("graphics_init\n"); // FIXME: perhaps modify so custom_limits defaults to -1, -1, -1, -1 set_custom_limits (-1, -1, -1, -1); if (g_amiga_video_format == AMIGA_VIDEO_FORMAT_R5G6B5) { g_red_bits = uae_bits_in_mask(R5G6B5_MASK_R); g_red_shift = uae_mask_shift(R5G6B5_MASK_R); g_green_bits = uae_bits_in_mask(R5G6B5_MASK_G); g_green_shift = uae_mask_shift(R5G6B5_MASK_G); g_blue_bits = uae_bits_in_mask(R5G6B5_MASK_B); g_blue_shift = uae_mask_shift(R5G6B5_MASK_B); g_alpha_bits = 0; g_alpha_shift = 0; } else if (g_amiga_video_format == AMIGA_VIDEO_FORMAT_R5G5B5A1) { g_red_bits = uae_bits_in_mask(R5G5B5A1_MASK_R); g_red_shift = uae_mask_shift(R5G5B5A1_MASK_R); g_green_bits = uae_bits_in_mask(R5G5B5A1_MASK_G); g_green_shift = uae_mask_shift(R5G5B5A1_MASK_G); g_blue_bits = uae_bits_in_mask(R5G5B5A1_MASK_B); g_blue_shift = uae_mask_shift(R5G5B5A1_MASK_B); g_alpha_bits = uae_bits_in_mask(R5G5B5A1_MASK_A); g_alpha_shift = uae_mask_shift(R5G5B5A1_MASK_A); } else { // RGBA or BGRA if (g_amiga_video_format == AMIGA_VIDEO_FORMAT_RGBA) { g_red_bits = uae_bits_in_mask(RGBA_MASK_R); g_red_shift = uae_mask_shift(RGBA_MASK_R); g_blue_bits = uae_bits_in_mask(RGBA_MASK_B); g_blue_shift = uae_mask_shift(RGBA_MASK_B); } else { // BGRA g_red_bits = uae_bits_in_mask(RGBA_MASK_B); g_red_shift = uae_mask_shift(RGBA_MASK_B); g_blue_bits = uae_bits_in_mask(RGBA_MASK_R); g_blue_shift = uae_mask_shift(RGBA_MASK_R); } g_green_bits = uae_bits_in_mask(RGBA_MASK_G); g_green_shift = uae_mask_shift(RGBA_MASK_G); g_alpha_bits = uae_bits_in_mask(RGBA_MASK_A); g_alpha_shift = uae_mask_shift(RGBA_MASK_A); } //g_renderdata.pixels = (unsigned char*) malloc(AMIGA_WIDTH*AMIGA_HEIGHT*4); memset(g_renderdata.line, 0, AMIGA_MAX_LINES); gfxvidinfo.maxblocklines = 0; #ifdef USE_BUFMEM g_bufmem = (unsigned char*) malloc(AMIGA_WIDTH * AMIGA_HEIGHT * g_amiga_video_bpp); gfxvidinfo.drawbuffer.bufmem = g_bufmem; memset(g_bufmem, 0, AMIGA_WIDTH * AMIGA_HEIGHT * g_amiga_video_bpp); gfxvidinfo.maxblocklines = MAXBLOCKLINES_MAX; #endif #ifdef USE_LINEMEM gfxvidinfo.drawbuffer.emergmem = 0; gfxvidinfo.drawbuffer.linemem = g_linemem; #else gfxvidinfo.drawbuffer.emergmem = 0; //g_linemem; gfxvidinfo.drawbuffer.linemem = 0; #endif gfxvidinfo.drawbuffer.pixbytes = g_amiga_video_bpp; gfxvidinfo.drawbuffer.rowbytes = AMIGA_WIDTH * g_amiga_video_bpp; gfxvidinfo.drawbuffer.height_allocated = AMIGA_HEIGHT; gfxvidinfo.drawbuffer.inheight = AMIGA_HEIGHT; gfxvidinfo.drawbuffer.outheight = AMIGA_HEIGHT; gfxvidinfo.drawbuffer.width_allocated = AMIGA_WIDTH; gfxvidinfo.drawbuffer.inwidth = AMIGA_WIDTH; gfxvidinfo.drawbuffer.outwidth = AMIGA_WIDTH; //gfxvidinfo.flush_block = libamiga_flush_block; //gfxvidinfo.flush_screen = libamiga_flush_screen; //SDL_SetColors (display, arSDLColors, 0, 256); write_log("calling reset_drawing\n"); reset_drawing (); init_colors (); //#ifdef USE_BUFMEM // init_row_map(); //#endif //write_log("FIXME: NOT USING VSYNC TRICK\n"); // Trick UAE into sending believing we are in vsync / fullscreen // so a flush command is sent for each frame update in do_flush_screen. if (currprefs.m68k_speed == -1) { write_log("currprefs.m68k_speed is -1, not allowing full sync\n"); } else { //currprefs.gfx_apmode[0].gfx_fullscreen = GFX_FULLSCREEN; currprefs.gfx_apmode[0].gfx_vsync = 1; } //currprefs.gfx_apmode[0].gfx_fullscreen = GFX_FULLSCREEN; //currprefs.gfx_apmode[0].gfx_vsync = 1; //currprefs.gfx_apmode[0].gfx_vsyncmode = 1; //currprefs.gfx_apmode[1].gfx_fullscreen = GFX_FULLSCREEN; //currprefs.gfx_apmode[1].gfx_vsync = 1; //amiga_set_option("gfx_vsync", "true"); //amiga_set_option("gfx_vsyncmode", "busywait"); return 1; }