win32.cpp

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

        {
            jie.dwSize = sizeof (jie);
            jie.dwFlags = JOY_RETURNALL;
            
            if (joyGetPosEx (JOYSTICKID1+C, &jie) != JOYERR_NOERROR)
            {
                Joystick[C].Attached = false;
                continue;
            }
            
            CheckAxis (jie.dwXpos, 
                       Joystick[C].Caps.wXmin, Joystick[C].Caps.wXmax,
                       Joystick[C].Left, Joystick[C].Right);
            CheckAxis (jie.dwYpos,
                       Joystick[C].Caps.wYmin, Joystick[C].Caps.wYmax,
                       Joystick[C].Up, Joystick[C].Down);
            CheckAxis (jie.dwZpos,
                       Joystick[C].Caps.wZmin, Joystick[C].Caps.wZmax,
                       Joystick[C].ZUp, Joystick[C].ZDown);
            CheckAxis (jie.dwRpos,
                       Joystick[C].Caps.wRmin, Joystick[C].Caps.wRmax,
                       Joystick[C].RUp, Joystick[C].RDown);
            CheckAxis (jie.dwUpos,
                       Joystick[C].Caps.wUmin, Joystick[C].Caps.wUmax,
                       Joystick[C].UUp, Joystick[C].UDown);
            CheckAxis (jie.dwVpos,
                       Joystick[C].Caps.wVmin, Joystick[C].Caps.wVmax,
                       Joystick[C].VUp, Joystick[C].VDown);

            switch (jie.dwPOV)
            {
                case JOY_POVBACKWARD:
                    Joystick[C].PovDown = true;
                    Joystick[C].PovUp = false;
                    Joystick[C].PovLeft = false;
                    Joystick[C].PovRight = false;
                    break;
                    
                case JOY_POVFORWARD:
                    Joystick[C].PovDown = false;
                    Joystick[C].PovUp = true;
                    Joystick[C].PovLeft = false;
                    Joystick[C].PovRight = false;
                    break;
                    
                case JOY_POVLEFT:
                    Joystick[C].PovDown = false;
                    Joystick[C].PovUp = false;
                    Joystick[C].PovLeft = true;
                    Joystick[C].PovRight = false;
                    break;
                    
                case JOY_POVRIGHT:
                    Joystick[C].PovDown = false;
                    Joystick[C].PovUp = false;
                    Joystick[C].PovLeft = false;
                    Joystick[C].PovRight = true;
                    break;
                    
                default:
                    Joystick[C].PovDown = false;
                    Joystick[C].PovUp = false;
                    Joystick[C].PovLeft = false;
                    Joystick[C].PovRight = false;
                    break;
            }
            
            for (int B = 0; B < 32; B ++)
                Joystick[C].Button[B] = (jie.dwButtons & (1 << B)) != 0;
        }
    }

    for (int J = 0; J < 5; J++)
    {
        if (Joypad [J].Enabled)
        {
            PadState[0]  = 0;
            PadState[0] |= !S9xGetState (Joypad[J].R)      ?  16 : 0;
            PadState[0] |= !S9xGetState (Joypad[J].L)      ?  32 : 0;
            PadState[0] |= !S9xGetState (Joypad[J].X)      ?  64 : 0;
            PadState[0] |= !S9xGetState (Joypad[J].A)      ? 128 : 0;
    
            PadState[1]  = 0;
            PadState[1] |= !S9xGetState (Joypad[J].Right)  ?   1 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Right_Up)  ? 1 + 8 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Right_Down)? 1 + 4 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Left)   ?   2 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Left_Up)?   2 + 8 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Left_Down)?  2 + 4 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Down)   ?   4 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Up)     ?   8 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Start)  ?  16 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Select) ?  32 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].Y)      ?  64 : 0;
            PadState[1] |= !S9xGetState (Joypad[J].B)      ? 128 : 0;
            joypads [J] = PadState [0] | (PadState [1] << 8) | 0x80000000;
        }
        else
            joypads [J] = 0;
    }
}

PALETTEENTRY S9xPaletteEntry[256];
void S9xSetPalette( void)
{
    LPDIRECTDRAWPALETTE lpDDTemp;
    uint16 Brightness = IPPU.MaxBrightness * 140;

    // Only update the palette structures if needed
    if( GUI.ScreenDepth == 8)
    {
        if (Settings.SixteenBit)
        {
            for (int i = 0; i < 256; i++)
            {
                S9xPaletteEntry[i].peRed   = FixedColours [i].red;
                S9xPaletteEntry[i].peGreen = FixedColours [i].green;
                S9xPaletteEntry[i].peBlue  = FixedColours [i].blue;
            }
        }
        else
        {
            for (int i = 0; i < 256; i ++)
            {	
                S9xPaletteEntry[i].peRed   = (((PPU.CGDATA [i] >>  0) & 0x1F) * Brightness) >> 8;
                S9xPaletteEntry[i].peGreen = (((PPU.CGDATA [i] >>  5) & 0x1F) * Brightness) >> 8;
                S9xPaletteEntry[i].peBlue  = (((PPU.CGDATA [i] >> 10) & 0x1F) * Brightness) >> 8;
            }
        }

        DirectX.lpDDSPrimary2->GetPalette (&lpDDTemp);
        if (lpDDTemp != DirectX.lpDDPalette)
            DirectX.lpDDSPrimary2->SetPalette (DirectX.lpDDPalette);
        DirectX.lpDDPalette->SetEntries (0, 0, 256, S9xPaletteEntry);
    }
}

bool LockSurface2 (LPDIRECTDRAWSURFACE2 lpDDSurface, SSurface *lpSurface)
{
    DDSURFACEDESC ddsd;
    HRESULT hResult;
    int retry;

    ddsd.dwSize = sizeof( ddsd);

    retry = 0;
    while( true)
    {
        hResult = lpDDSurface -> Lock( NULL, &ddsd, DDLOCK_WAIT, NULL);

        if( hResult == DD_OK)
        {
            lpSurface -> Width = ddsd.dwWidth;
            lpSurface -> Height = ddsd.dwHeight;
            lpSurface -> Pitch = ddsd.lPitch;
            lpSurface -> Surface = (unsigned char *)ddsd.lpSurface;
            return true;
        }

        if( hResult == DDERR_SURFACELOST)
        {
            retry++;
            if( retry > 5)
            {	return false;	}

            hResult = lpDDSurface -> Restore();
            GUI.ScreenCleared = true;
            if (hResult != DD_OK)
            {	return false;	}

            continue;
        }

        if( hResult != DDERR_WASSTILLDRAWING)
            return false;
    }
}

BYTE ScreenBuffer [512*478*2];
BYTE SubScreenBuffer [512*478*2];
BYTE ZBuffer [512*478];
BYTE SubZBuffer [512*478];
static bool8 locked_surface = FALSE;
static SSurface Dst;

bool8 S9xInitUpdate( void)
{
    GFX.SubScreen = SubScreenBuffer;
    GFX.ZBuffer = ZBuffer;
    GFX.SubZBuffer = SubZBuffer;

    if (GUI.Scale <= 1 && 
        (GUI.Stretch || !GUI.FullScreen) &&
        !GUI.NeedDepthConvert &&
        !GUI.DoubleBuffered &&
        ((DirectX.lpDDSOffScreen2 && 
          LockSurface2 (DirectX.lpDDSOffScreen2, &Dst))))
    {
        GFX.RealPitch = GFX.Pitch = Dst.Pitch;
        GFX.Screen = Dst.Surface;
        DirectX.lpDDSOffScreen2->Unlock (Dst.Surface);
        locked_surface = TRUE;
    }
    else
    {
        locked_surface = FALSE;
        GFX.RealPitch = GFX.Pitch = 512 * 2;
        GFX.Screen = ScreenBuffer;
    }
    GFX.Delta = (GFX.SubScreen - GFX.Screen) >> 1;
    if (Settings.SixteenBit)
    {
        GFX.PPL = GFX.Pitch >> 1;
        GFX.PPLx2 = GFX.Pitch;
    }
    else
    {
        GFX.PPL = GFX.Pitch;
        GFX.PPLx2 = GFX.Pitch * 2;
    }
    GFX.Pitchx2 = GFX.Pitch * 2;
    return (TRUE);
}

bool8 S9xDeinitUpdate( int Width, int Height, bool8 sixteen_bit)
{
    SSurface Src;
    LPDIRECTDRAWSURFACE2 lpDDSurface2 = NULL;
    bool PrimarySurfaceLockFailed = false;
    RECT srcRect;

#if 0
HRESULT Render3DEnvironment ();

Render3DEnvironment ();
return true;
#endif

    Src.Width = Width;
    Src.Height = Height;
    Src.Pitch = GFX.Pitch;
    Src.Surface = ScreenBuffer;

    if (locked_surface)
    {
        lpDDSurface2 = DirectX.lpDDSOffScreen2;
        PrimarySurfaceLockFailed = true;
    }
    else
    {
        if (DirectX.lpDDSBack2 == NULL)
            lpDDSurface2 = DirectX.lpDDSPrimary2;
        else 
            lpDDSurface2 = DirectX.lpDDSBack2;
    }

    if (!locked_surface && !VOODOO_MODE && !OPENGL_MODE)
    {
        if (GUI.Stretch || GUI.Scale == 1 || !GUI.FullScreen ||
            GUI.DoubleBuffered ||
            !LockSurface2 (lpDDSurface2, &Dst))
        {
            lpDDSurface2 = DirectX.lpDDSOffScreen2;
            if (!LockSurface2 (lpDDSurface2, &Dst))
                return false;
            
            PrimarySurfaceLockFailed = true;
        }
    }

    if (!locked_surface)
    {
        SelectRenderMethod ();
        if (GUI.NeedDepthConvert)
        {
            if (GUI.Scale <= 1)
            {
                srcRect.left = srcRect.top = 0;
                srcRect.right = Width;
                srcRect.bottom = Height;
                ConvertDepth (&Src, &Dst, &srcRect);
            }
            else
            {
                SSurface tmp;
                BYTE buf [512 * 478 * 4];

                tmp.Surface = buf;
                tmp.Pitch = 512 * 4;
                tmp.Width = 512;
                tmp.Height = 478;
                RenderMethod (Src, tmp, &srcRect);
                ConvertDepth (&tmp, &Dst, &srcRect);
            }
        }
        else
            RenderMethod (Src, Dst, &srcRect);
    }
    else
    {
        srcRect.top    = 0;
        srcRect.bottom = Height;
        srcRect.left   = 0;
        srcRect.right  = Width;
    }

    if (!VOODOO_MODE && !OPENGL_MODE)
    {
        if( PrimarySurfaceLockFailed)
        {
            POINT p;

            if (GUI.Stretch)
            {
                GetClientRect (GUI.hWnd, &dstRect);
                p.x = p.y = 0;
                ClientToScreen (GUI.hWnd, &p);
                dstRect.right = (dstRect.right - dstRect.left) + p.x;
                dstRect.bottom = (dstRect.bottom - dstRect.top) + p.y;
                dstRect.top = p.y;
                dstRect.left = p.x;
            }
            else
            {
                GetClientRect (GUI.hWnd, &dstRect);
                int width = srcRect.right - srcRect.left;
                int height = srcRect.bottom - srcRect.top;

                if (GUI.Scale == 1)
                {
                    width = 512;
                    if (height < 240)
                        height *= 2;
                }
                p.x = ((dstRect.right - dstRect.left) - width) >> 1;
                p.y = ((dstRect.bottom - dstRect.top) - height) >> 1;
                ClientToScreen (GUI.hWnd, &p);

                dstRect.top = p.y;
                dstRect.left = p.x;
                dstRect.bottom = dstRect.top + height;
                dstRect.right  = dstRect.left + width;
            }
        }
        else
            dstRect = srcRect;
	
        lpDDSurface2->Unlock( Dst.Surface);	
        if (PrimarySurfaceLockFailed)
        {
            if( DirectX.lpDDSBack2 == NULL)
                lpDDSurface2 = DirectX.lpDDSPrimary2;
            else 
                lpDDSurface2 = DirectX.lpDDSBack2;
            
            if (lpDDSurface2->Blt (&dstRect, DirectX.lpDDSOffScreen2, &srcRect, DDBLT_WAIT, NULL) != DD_OK)
                return false;
        }
        DirectX.lpDDSPrimary2 -> Flip( NULL, DDFLIP_WAIT);
    }
    else
        dstRect = srcRect;

    return true;
}

void InitSnes9X( void)
{
#ifdef DEBUGGER
    extern FILE *trace;

    trace = fopen( "SNES9X.TRC", "wt");
    freopen( "SNES9X.OUT", "wt", stdout);
    freopen( "SNES9X.ERR", "wt", stderr);

//    CPU.Flags |= TRACE_FLAG;
//    APU.Flags |= TRACE_FLAG;
#endif

#ifdef GENERATE_OFFSETS_H
    offsets_h = fopen ("offsets.h", "wt");
    generate_offsets_h (0, NULL);
    fclose (offsets_h);
#endif

    Memory.Init();

    GFX.Pitch = 512 * 2;
    GFX.RealPitch = 512 * 2;
    GFX.Screen = ScreenBuffer;
    GFX.SubScreen = SubScreenBuffer;
    GFX.Delta = (GFX.SubScreen - GFX.Screen) >> 1;

    S9xSetWinPixelFormat ();
    S9xGraphicsInit();

    S9xInitAPU();
    S9xInitSound (7, true, _blocksize);

    so.playback_rate = Settings.SoundPlaybackRate;
    so.stereo = Settings.Stereo;
    so.sixteen_bit = Settings.SixteenBitSound;
    so.buffer_size = _blocksize;

    // Sound options
    Settings.SoundBufferSize = Settings.SoundBufferSize;

#ifdef USE_GLIDE
    Settings.GlideEnable = FALSE;
#endif

    for (int C = 0; C != 16; C ++)
        Joystick[C].Attached = joyGetDevCaps (JOYSTICKID1+C, &Joystick[C].Caps,
                                              sizeof( JOYCAPS)) == JOYERR_NOERROR;
}

int ffs (uint32 mask)
{
    int m = 0;
    if (mask)
    {
        while (!(mask & (1 << m)))
            m++;

        return (m);
    }

    return (0);
}

void S9xSetWinPixelFormat ()
{
    extern int Init_2xSaI (uint32 BitFormat);

    S9xSetRenderPixelFormat (RGB565);
    Init_2xSaI (565);
    GUI.NeedDepthConvert = FALSE;

    if (VOODOO_MODE)
    {
        GUI.ScreenDepth = 16;
        GUI.RedShift = 0;
        GUI.GreenShift = 5;
        GUI.BlueShift = 11;
        Settings.SixteenBit = TRUE;