svga.cpp

著名SFC模拟器Snes9x的源代码。

    PROCESS_KEY(SCANCODE_COMMA,		    joypads [0], SNES_Y_MASK)
    PROCESS_KEY(SCANCODE_R,		    joypads [0], SNES_Y_MASK)

    PROCESS_KEY(SCANCODE_D,		    joypads [0], SNES_A_MASK)
    PROCESS_KEY(SCANCODE_PERIOD,	    joypads [0], SNES_A_MASK)
    PROCESS_KEY(SCANCODE_T,		    joypads [0], SNES_A_MASK)

    PROCESS_KEY(SCANCODE_C,		    joypads [0], SNES_B_MASK)
    PROCESS_KEY(SCANCODE_SLASH,		    joypads [0], SNES_B_MASK)
    PROCESS_KEY(SCANCODE_Y,		    joypads [0], SNES_B_MASK)
    
    // Joypad 2:
    PROCESS_KEY(SCANCODE_CURSORRIGHT,	    joypads [1], SNES_RIGHT_MASK)
    PROCESS_KEY(SCANCODE_CURSORLEFT,	    joypads [1], SNES_LEFT_MASK)
    PROCESS_KEY(SCANCODE_CURSORDOWN,	    joypads [1], SNES_DOWN_MASK)
    PROCESS_KEY(SCANCODE_CURSORUP,	    joypads [1], SNES_UP_MASK)
    PROCESS_KEY(SCANCODE_KEYPADENTER,	    joypads [1], SNES_START_MASK)
    PROCESS_KEY(SCANCODE_KEYPADPLUS,	    joypads [1], SNES_SELECT_MASK)
    PROCESS_KEY(SCANCODE_INSERT,	    joypads [1], SNES_TL_MASK)
    PROCESS_KEY(SCANCODE_REMOVE,	    joypads [1], SNES_TR_MASK)
    PROCESS_KEY(SCANCODE_HOME,		    joypads [1], SNES_X_MASK)
    PROCESS_KEY(SCANCODE_END,		    joypads [1], SNES_Y_MASK)
    PROCESS_KEY(SCANCODE_PAGEUP,	    joypads [1], SNES_A_MASK)
    PROCESS_KEY(SCANCODE_PAGEDOWN,	    joypads [1], SNES_B_MASK)
    
    if (KEY_PRESS (SCANCODE_1))
	PPU.BG_Forced ^= 1;
    if (KEY_PRESS (SCANCODE_2))
	PPU.BG_Forced ^= 2;
    if (KEY_PRESS (SCANCODE_3))
	PPU.BG_Forced ^= 4;
    if (KEY_PRESS (SCANCODE_4))
	PPU.BG_Forced ^= 8;
    if (KEY_PRESS (SCANCODE_5))
	PPU.BG_Forced ^= 16;
    if (KEY_PRESS (SCANCODE_0))
	Settings.DisableHDMA = !Settings.DisableHDMA;
    if (KEY_PRESS (SCANCODE_8))
	Settings.BGLayering = !Settings.BGLayering;
    if (KEY_PRESS (SCANCODE_6))
	Settings.SwapJoypads = !Settings.SwapJoypads;
    if (KEY_PRESS (SCANCODE_BACKSPACE))
	Settings.DisableGraphicWindows = !Settings.DisableGraphicWindows;
    if (KEY_PRESS(SCANCODE_F1))
	fn = 1;
    if (KEY_PRESS(SCANCODE_F2))
	fn = 2;
    if (KEY_PRESS(SCANCODE_F3))
	fn = 3;
    if (KEY_PRESS(SCANCODE_F4))
	fn = 4;
    if (KEY_PRESS(SCANCODE_F5))
	fn = 5;
    if (KEY_PRESS(SCANCODE_F6))
	fn = 6;
    if (KEY_PRESS(SCANCODE_F7))
	fn = 7;
    if (KEY_PRESS(SCANCODE_F8))
	fn = 8;
    if (KEY_PRESS(SCANCODE_F9))
	fn = 9;
    if (KEY_PRESS(SCANCODE_F10))
	fn = 10;
    if (KEY_PRESS(SCANCODE_F11))
	fn = 11;
    if (KEY_PRESS(SCANCODE_F12))
	fn = 12;
	
    if (fn > 0)
    {
	if (!KEY_DOWN(SCANCODE_LEFTALT) && !KEY_DOWN(SCANCODE_LEFTSHIFT) &&
	    !KEY_DOWN(SCANCODE_CONTROL) && !KEY_DOWN(SCANCODE_LEFTCONTROL))
	{
	    if (fn == 11)
	    {
		S9xLoadSnapshot (S9xChooseFilename (TRUE));
	    }
	    else if (fn == 12)
	    {
		Snapshot (S9xChooseFilename (FALSE));
	    }
	    else
	    {
		char def [PATH_MAX];
		char filename [PATH_MAX];
		char drive [_MAX_DRIVE];
		char dir [_MAX_DIR];
		char ext [_MAX_EXT];

		_splitpath (Memory.ROMFilename, drive, dir, def, ext);
		sprintf (filename, "%s%s%s.%03d",
			 S9xGetSnapshotDirectory (), SLASH_STR, def,
			 fn - 1);
		S9xLoadSnapshot (filename);
	    }
	}
	else if (KEY_DOWN(SCANCODE_LEFTALT) || KEY_DOWN(SCANCODE_LEFTCONTROL) ||
		 KEY_DOWN(SCANCODE_CONTROL))
	{
	    if (fn >= 4)
		S9xToggleSoundChannel (fn - 4);
#ifdef DEBUGGER
	    else if (fn == 1)
		CPU.Flags |= DEBUG_MODE_FLAG;
#endif
	    else if (fn == 2)
		S9xLoadSnapshot (S9xChooseFilename (TRUE));
	    else if (fn == 3)
		Snapshot (S9xChooseFilename (FALSE));
	}
	else
	{
	    char def [PATH_MAX];
	    char filename [PATH_MAX];
	    char drive [_MAX_DRIVE];
	    char dir [_MAX_DIR];
	    char ext [_MAX_EXT];

	    _splitpath (Memory.ROMFilename, drive, dir, def, ext);
	    sprintf (filename, "%s%s%s.%03d",
		     S9xGetSnapshotDirectory (), SLASH_STR, def,
		     fn - 1);
	    Snapshot (filename);
	}
    }
    if (KEY_PRESS (SCANCODE_BREAK) || KEY_PRESS (SCANCODE_BREAK_ALTERNATIVE) ||
	KEY_PRESS (SCANCODE_SCROLLLOCK))
	Settings.Paused ^= 1;

    if (KEY_PRESS (SCANCODE_MINUS))
    {
	if (KEY_PRESS(SCANCODE_LEFTSHIFT) || KEY_PRESS(SCANCODE_RIGHTSHIFT))
	{
	    if (Settings.FrameTime >= 1000)
		Settings.FrameTime -= 1000;
	}
	else
	{
	    if (Settings.SkipFrames <= 1)
		Settings.SkipFrames = AUTO_FRAMERATE;
	    else
	    if (Settings.SkipFrames != AUTO_FRAMERATE)
		Settings.SkipFrames--;
	}
    }

    if (KEY_PRESS (SCANCODE_EQUAL))
    {
	if (KEY_PRESS(SCANCODE_LEFTSHIFT) || KEY_PRESS(SCANCODE_RIGHTSHIFT))
	    Settings.FrameTime += 1000;
	else
	{
	    if (Settings.SkipFrames == AUTO_FRAMERATE)
		Settings.SkipFrames = 1;
	    else
	    if (Settings.SkipFrames < 10)
		Settings.SkipFrames++;
	}
    }
	
    memcpy (prev_keystate, keystate, sizeof (prev_keystate));
}

void S9xSetTitle (const char * /*title*/)
{
}

void S9xPutImage (int width, int height)
{
    int y_buff;
    int y_start;
    int y_end;
    int x_start = (screen_width - width) >> 1;
    if (screen_height >= height)
    {
	y_start = (screen_height - height) >> 1;
	y_end = y_start + height;
	y_buff = 0;
    }
    else
    {
	y_start = 0;
	y_end = screen_height;
	y_buff = (height - screen_height) >> 1;
    }
	
    if (planar)
	vga_copytoplanar256 (GFX.Screen + y_buff * GFX.Pitch,
			     IMAGE_WIDTH,
			     y_start * screen_pitch + x_start / 4,
			     screen_pitch, width, y_end - y_start);
    else
    {
	if (screen_pitch == width && screen_height >= height)
	{
#if 0
	    memcpy (vga_getgraphmem () + screen_pitch * y_start,
		    GFX.Screen, width * height);
#else
	    register uint32 *s = (uint32 *) (vga_getgraphmem () + screen_pitch * y_start);
	    register uint32 *o = (uint32 *) DeltaScreen;
	    register uint32 *n = (uint32 *) GFX.Screen;
	    uint32 *end = (uint32 *) (GFX.Screen + width * height);
	    do
	    {
		if (*n != *o)
		    *o = *s = *n;

		o++;
		s++;
		n++;
	    } while (n < end);
#endif
	}
	else
	{
	    if (stretch && screen_width != width)
	    {
		register uint32 x_error;
		register uint32 x_fraction;
		uint32 y_error = 0;
		uint32 y_fraction;
		int yy = 0;
		
		x_fraction = (SNES_WIDTH * 0x10000) / width;
		y_fraction = (SNES_HEIGHT_EXTENDED * 0x10000) / height;
		
		for (int y = 0; y < height; y++)
		{
		    register uint8 *d = (uint8 *) vga_getgraphmem () + y * screen_pitch;
		    register uint8 *s = GFX.Screen + yy * GFX.Pitch;
		    y_error += y_fraction;
		    while (y_error >= 0x10000)
		    {
			yy++;
			y_error -= 0x10000;
		    }
		    x_error = 0;
		    for (register int x = 0; x < width; x++)
		    {
			*d++ = *s;
			x_error += x_fraction;

			while (x_error >= 0x10000)
			{
			    s++;
			    x_error -= 0x10000;
			}
		    }
		}
	    }
	    else
	    {
#if 0
		uint8 *s = GFX.Screen + GFX.Pitch * y_buff;
		uint8 *p = vga_getgraphmem () + screen_pitch * y_start +
			  x_start;
		for (int y = y_start; y < y_end; y++, s += GFX.Pitch, p += screen_pitch)
		    memcpy (p, s, width);
#else
		gl_putbox (0, 0, width * 2, height * 2, GFX.Screen);
#endif
	    }
	}
    }
}

const char *S9xSelectFilename (const char *def, const char *dir1,
			    const char *ext1, const char *title)
{
    static char path [PATH_MAX];
    char buffer [PATH_MAX];
    
    S9xTextMode ();
    printf ("\n%s (default: %s): ", title, def);
    fflush (stdout);
    if (fgets (buffer, sizeof (buffer) - 1, stdin))
    {
	char *p = buffer;
	while (isspace (*p) || *p == '\n')
	    p++;
	if (!*p)
	{
	    strcpy (buffer, def);
	    p = buffer;
	}

	char *q = strrchr (p, '\n');
	if (q)
	    *q = 0;

	char fname [PATH_MAX];
	char drive [_MAX_DRIVE];
	char dir [_MAX_DIR];
	char ext [_MAX_EXT];

	_splitpath (p, drive, dir, fname, ext);
	_makepath (path, drive, *dir ? dir : dir1, fname, *ext ? ext : ext1);
	S9xGraphicsMode ();
	return (path);
    }
    S9xGraphicsMode ();
    return (NULL);
}

void outReg(Register r)
{
    switch (r.port)
    {
	/* First handle special cases: */

	case ATTRCON_ADDR:
	    /* reset read/write flip-flop */
	    inb (STATUS_ADDR);
	    /* ensure VGA output is enabled */
	    outb (r.index | 0x20, ATTRCON_ADDR);
	    outb (r.value, ATTRCON_ADDR);
	    break;

	case MISC_ADDR:
	case VGAENABLE_ADDR:
	    /*	directly to the port */
	    outb (r.value, r.port);
	    break;

	case SEQ_ADDR:
	case GRACON_ADDR:
	case CRTC_ADDR:
	default:
	    /*	index to port			   */
	    outb (r.index, r.port);
	    /*	value to port+1 		   */
	    outb (r.value, r.port + 1);
	    break;
    }
}

/*
    readyVgaRegs() does the initialization to make the VGA ready to
    accept any combination of configuration register settings.

    This involves enabling writes to index 0 to 7 of the CRT controller
    (port 0x3d4), by clearing the most significant bit (bit 7) of index
    0x11.
*/

void readyVgaRegs (void)
{
    int v;

    outb (0x11, 0x3d4);
    v = inb (0x3d5) & 0x7f;
    outb (0x11, 0x3d4);
    outb (v, 0x3d5);
}
/*
	outRegArray sets n registers according to the array pointed to by r.
	First, indexes 0-7 of the CRT controller are enabled for writing.
*/

void outRegArray (Register *r, int n)
{
    readyVgaRegs ();
    while (n--)
	outReg (*r++);
}

void S9xParseDisplayArg (char **argv, int &ind, int)
{
    if ((strcmp (argv [ind], "-m") == 0 ||
	 strcasecmp (argv [ind], "-mode") == 0) && argv [ind + 1])
    {
	mode = atoi (argv [++ind]);
	if (mode >= (int) (sizeof (modes) / sizeof (modes [0])))
	    mode = 0;
    }
    else
    if (strcasecmp (argv [ind], "-scale") == 0 ||
	strcasecmp (argv [ind], "-sc") == 0)
	stretch = TRUE;
    else
    if (strcasecmp (argv [ind], "-y") == 0 ||
	strcasecmp (argv [ind], "-interpolation") == 0)
    {
	interpolation = TRUE;
	Settings.SixteenBit = TRUE;
	Settings.SupportHiRes = TRUE;
	Settings.Transparency = TRUE;
    }
    else
	S9xUsage ();
}

void S9xExtraUsage ()
{
    printf ("\
-m  num     Screen mode:\n\
            0 - 320x240 (modex, slower), 1 - 320x200 (faster but clipped)\n\
            2 - 256x256 (faster but non-standard), 3 - 640x480, 4 - 800x600\n");
    printf ("\
-scale      Scale SNES screen to fit S-VGA screen\n");
}

bool8 S9xReadMousePosition (int /* which1 */, int &/* x */, int & /* y */,
			    uint32 & /* buttons */)
{
    return (FALSE);
}

bool8 S9xReadSuperScopePosition (int & /* x */, int & /* y */, 
				 uint32 & /* buttons */)
{
    return (FALSE);
}

void S9xMessage (int /* type */, int /* number */, const char *message)
{
    fprintf (stderr, "%s\n", message);
}
#endif