rw_win.h File Reference

#include <windows.h>
#include <ddraw.h>

Go to the source code of this file.

Classes
struct	swwstate_t

Functions
qboolean	DIB_Init (unsigned char **ppbuffer, int *ppitch)
void	DIB_Shutdown (void)
void	DIB_SetPalette (const unsigned char *palette)
qboolean	DDRAW_Init (unsigned char **ppbuffer, int *ppitch)
void	DDRAW_Shutdown (void)
void	DDRAW_SetPalette (const unsigned char *palette)

Variables
swwstate_t	sww_state

Function Documentation

DDRAW_Init()

qboolean DDRAW_Init	(	unsigned char **	ppbuffer,
		int *	ppitch
	)

Definition at line 42 of file rw_ddraw.c.

{
    HRESULT ddrval;
    DDSURFACEDESC ddsd;
    DDSCAPS ddscaps;
    PALETTEENTRY palentries[256];
    int i;
    extern cvar_t *sw_allow_modex;
 
    HRESULT (WINAPI *QDirectDrawCreate)( GUID FAR *lpGUID, LPDIRECTDRAW FAR * lplpDDRAW, IUnknown FAR * pUnkOuter );
 
ri.Con_Printf( PRINT_ALL, "Initializing DirectDraw\n");
 
 
    for ( i = 0; i < 256; i++ )
    {
        palentries[i].peRed     = ( d_8to24table[i] >> 0  ) & 0xff;
        palentries[i].peGreen   = ( d_8to24table[i] >> 8  ) & 0xff;
        palentries[i].peBlue    = ( d_8to24table[i] >> 16 ) & 0xff;
    }
 
    /*
    ** load DLL and fetch pointer to entry point
    */
    if ( !sww_state.hinstDDRAW )
    {
        ri.Con_Printf( PRINT_ALL, "...loading DDRAW.DLL: ");
        if ( ( sww_state.hinstDDRAW = LoadLibrary( "ddraw.dll" ) ) == NULL )
        {
            ri.Con_Printf( PRINT_ALL, "failed\n" );
            goto fail;
        }
        ri.Con_Printf( PRINT_ALL, "ok\n" );
    }
 
    if ( ( QDirectDrawCreate = ( HRESULT (WINAPI *)( GUID FAR *, LPDIRECTDRAW FAR *, IUnknown FAR * ) ) GetProcAddress( sww_state.hinstDDRAW, "DirectDrawCreate" ) ) == NULL )
    {
        ri.Con_Printf( PRINT_ALL, "*** DirectDrawCreate == NULL ***\n" );
        goto fail;
    }
 
    /*
    ** create the direct draw object
    */
    ri.Con_Printf( PRINT_ALL, "...creating DirectDraw object: ");
    if ( ( ddrval = QDirectDrawCreate( NULL, &sww_state.lpDirectDraw, NULL ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    /*
    ** see if linear modes exist first
    */
    sww_state.modex = false;
 
    ri.Con_Printf( PRINT_ALL, "...setting exclusive mode: ");
    if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->SetCooperativeLevel( sww_state.lpDirectDraw, 
                                                                         sww_state.hWnd,
                                                                         DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n",DDrawError (ddrval) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    /*
    ** try changing the display mode normally
    */
    ri.Con_Printf( PRINT_ALL, "...finding display mode\n" );
    ri.Con_Printf( PRINT_ALL, "...setting linear mode: " );
    if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->SetDisplayMode( sww_state.lpDirectDraw, vid.width, vid.height, 8 ) ) == DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "ok\n" );
    }
    /*
    ** if no linear mode found, go for modex if we're trying 320x240
    */
    else if ( ( sw_mode->value == 0 ) && sw_allow_modex->value )
    {
        ri.Con_Printf( PRINT_ALL, "failed\n" );
        ri.Con_Printf( PRINT_ALL, "...attempting ModeX 320x240: ");
 
        /*
        ** reset to normal cooperative level
        */
        sww_state.lpDirectDraw->lpVtbl->SetCooperativeLevel( sww_state.lpDirectDraw, 
                                                             sww_state.hWnd,
                                                             DDSCL_NORMAL );
 
        /*                                                           
        ** set exclusive mode
        */
        if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->SetCooperativeLevel( sww_state.lpDirectDraw, 
                                                                             sww_state.hWnd,
                                                                             DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_NOWINDOWCHANGES | DDSCL_ALLOWMODEX ) ) != DD_OK )
        {
            ri.Con_Printf( PRINT_ALL, "failed SCL - %s\n",DDrawError (ddrval) );
            goto fail;
        }
 
        /*
        ** change our display mode
        */
        if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->SetDisplayMode( sww_state.lpDirectDraw, vid.width, vid.height, 8 ) ) != DD_OK )
        {
            ri.Con_Printf( PRINT_ALL, "failed SDM - %s\n", DDrawError( ddrval ) );
            goto fail;
        }
        ri.Con_Printf( PRINT_ALL, "ok\n" );
 
        sww_state.modex = true;
    }
    else
    {
        ri.Con_Printf( PRINT_ALL, "failed\n" );
        goto fail;
    }
 
    /*
    ** create our front buffer
    */
    memset( &ddsd, 0, sizeof( ddsd ) );
    ddsd.dwSize = sizeof( ddsd );
    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
    ddsd.dwBackBufferCount = 1;
 
    ri.Con_Printf( PRINT_ALL, "...creating front buffer: ");
    if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->CreateSurface( sww_state.lpDirectDraw, &ddsd, &sww_state.lpddsFrontBuffer, NULL ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    /*
    ** see if we're a ModeX mode
    */
    sww_state.lpddsFrontBuffer->lpVtbl->GetCaps( sww_state.lpddsFrontBuffer, &ddscaps );
    if ( ddscaps.dwCaps & DDSCAPS_MODEX )
        ri.Con_Printf( PRINT_ALL, "...using ModeX\n" );
 
    /*
    ** create our back buffer
    */
    ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
 
    ri.Con_Printf( PRINT_ALL, "...creating back buffer: " );
    if ( ( ddrval = sww_state.lpddsFrontBuffer->lpVtbl->GetAttachedSurface( sww_state.lpddsFrontBuffer, &ddsd.ddsCaps, &sww_state.lpddsBackBuffer ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    /*
    ** create our rendering buffer
    */
    memset( &ddsd, 0, sizeof( ddsd ) );
    ddsd.dwSize = sizeof( ddsd );
    ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
    ddsd.dwHeight = vid.height;
    ddsd.dwWidth = vid.width;
    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
 
    ri.Con_Printf( PRINT_ALL, "...creating offscreen buffer: " );
    if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->CreateSurface( sww_state.lpDirectDraw, &ddsd, &sww_state.lpddsOffScreenBuffer, NULL ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    /*
    ** create our DIRECTDRAWPALETTE
    */
    ri.Con_Printf( PRINT_ALL, "...creating palette: " );
    if ( ( ddrval = sww_state.lpDirectDraw->lpVtbl->CreatePalette( sww_state.lpDirectDraw,
                                                        DDPCAPS_8BIT | DDPCAPS_ALLOW256,
                                                        palentries,
                                                        &sww_state.lpddpPalette,
                                                        NULL ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    ri.Con_Printf( PRINT_ALL, "...setting palette: " );
    if ( ( ddrval = sww_state.lpddsFrontBuffer->lpVtbl->SetPalette( sww_state.lpddsFrontBuffer,
                                                         sww_state.lpddpPalette ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
    ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    DDRAW_SetPalette( ( const unsigned char * ) sw_state.currentpalette );
 
    /*
    ** lock the back buffer
    */
    memset( &ddsd, 0, sizeof( ddsd ) );
    ddsd.dwSize = sizeof( ddsd );
    
ri.Con_Printf( PRINT_ALL, "...locking backbuffer: " );
    if ( ( ddrval = sww_state.lpddsOffScreenBuffer->lpVtbl->Lock( sww_state.lpddsOffScreenBuffer, NULL, &ddsd, DDLOCK_WAIT, NULL ) ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "failed - %s\n", DDrawError( ddrval ) );
        goto fail;
    }
ri.Con_Printf( PRINT_ALL, "ok\n" );
 
    *ppbuffer = ddsd.lpSurface;
    *ppitch   = ddsd.lPitch;
 
    for ( i = 0; i < vid.height; i++ )
    {
        memset( *ppbuffer + i * *ppitch, 0, *ppitch );
    }
 
    sww_state.palettized = true;
 
    return true;
fail:
    ri.Con_Printf( PRINT_ALL, "*** DDraw init failure ***\n" );
 
    DDRAW_Shutdown();
    return false;
}

DDRAW_SetPalette()

void DDRAW_SetPalette

(

const unsigned char *

palette

)

Definition at line 288 of file rw_ddraw.c.

{
    PALETTEENTRY palentries[256];
    int i;
 
    if (!sww_state.lpddpPalette)
        return;
 
    for ( i = 0; i < 256; i++, pal += 4 )
    {
        palentries[i].peRed   = pal[0];
        palentries[i].peGreen = pal[1];
        palentries[i].peBlue  = pal[2];
        palentries[i].peFlags = PC_RESERVED | PC_NOCOLLAPSE;
    }
 
    if ( sww_state.lpddpPalette->lpVtbl->SetEntries( sww_state.lpddpPalette,
                                                0,
                                                0,
                                                256,
                                                palentries ) != DD_OK )
    {
        ri.Con_Printf( PRINT_ALL, "DDRAW_SetPalette() - SetEntries failed\n" );
    }
}

Referenced by DDRAW_Init().

DDRAW_Shutdown()

void DDRAW_Shutdown

(

void

)

Definition at line 317 of file rw_ddraw.c.

{
    if ( sww_state.lpddsOffScreenBuffer )
    {
        ri.Con_Printf( PRINT_ALL, "...releasing offscreen buffer\n");
        sww_state.lpddsOffScreenBuffer->lpVtbl->Unlock( sww_state.lpddsOffScreenBuffer, vid.buffer );
        sww_state.lpddsOffScreenBuffer->lpVtbl->Release( sww_state.lpddsOffScreenBuffer );
        sww_state.lpddsOffScreenBuffer = NULL;
    }
 
    if ( sww_state.lpddsBackBuffer )
    {
        ri.Con_Printf( PRINT_ALL, "...releasing back buffer\n");
        sww_state.lpddsBackBuffer->lpVtbl->Release( sww_state.lpddsBackBuffer );
        sww_state.lpddsBackBuffer = NULL;
    }
 
    if ( sww_state.lpddsFrontBuffer )
    {
        ri.Con_Printf( PRINT_ALL, "...releasing front buffer\n");
        sww_state.lpddsFrontBuffer->lpVtbl->Release( sww_state.lpddsFrontBuffer );
        sww_state.lpddsFrontBuffer = NULL;
    }
 
    if (sww_state.lpddpPalette)
    {
        ri.Con_Printf( PRINT_ALL, "...releasing palette\n");
        sww_state.lpddpPalette->lpVtbl->Release ( sww_state.lpddpPalette );
        sww_state.lpddpPalette = NULL;
    }
 
    if ( sww_state.lpDirectDraw )
    {
        ri.Con_Printf( PRINT_ALL, "...restoring display mode\n");
        sww_state.lpDirectDraw->lpVtbl->RestoreDisplayMode( sww_state.lpDirectDraw );
        ri.Con_Printf( PRINT_ALL, "...restoring normal coop mode\n");
        sww_state.lpDirectDraw->lpVtbl->SetCooperativeLevel( sww_state.lpDirectDraw, sww_state.hWnd, DDSCL_NORMAL );
        ri.Con_Printf( PRINT_ALL, "...releasing lpDirectDraw\n");
        sww_state.lpDirectDraw->lpVtbl->Release( sww_state.lpDirectDraw );
        sww_state.lpDirectDraw = NULL;
    }
 
    if ( sww_state.hinstDDRAW )
    {
        ri.Con_Printf( PRINT_ALL, "...freeing library\n");
        FreeLibrary( sww_state.hinstDDRAW );
        sww_state.hinstDDRAW = NULL;
    }
}

Referenced by DDRAW_Init().

DIB_Init()

qboolean DIB_Init	(	unsigned char **	ppbuffer,
		int *	ppitch
	)

Definition at line 88 of file rw_dib.c.

{
    dibinfo_t   dibheader;
    BITMAPINFO *pbmiDIB = ( BITMAPINFO * ) &dibheader;
    DEVMODE gdevmode;  //qb: for fullscreen
    int i;
 
    memset( &dibheader, 0, sizeof( dibheader ) );
 
    /*
    ** grab a DC
    */
    if ( !sww_state.hDC )
    {
        if ( ( sww_state.hDC = GetDC( sww_state.hWnd ) ) == NULL )
            return false;
    }
 
    /*
    ** figure out if we're running in an 8-bit display mode
    */
    if ( GetDeviceCaps( sww_state.hDC, RASTERCAPS ) & RC_PALETTE )
    {
        sww_state.palettized = true;
 
        // save system colors
        if ( !s_systemcolors_saved )
        {
            DIB_SaveSystemColors();
            s_systemcolors_saved = true;
        }
    }
    else
    {
        sww_state.palettized = false;
    }
 
    vid.width = (int)(vid.width / 4) * 4; //qb: multiple of 4 required for DIB
 
    /*
    ** fill in the BITMAPINFO struct
    */
    pbmiDIB->bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
    pbmiDIB->bmiHeader.biWidth         = vid.width;
    pbmiDIB->bmiHeader.biHeight        = vid.height;
    pbmiDIB->bmiHeader.biPlanes        = 1;
    pbmiDIB->bmiHeader.biBitCount      = 8;
    pbmiDIB->bmiHeader.biCompression   = BI_RGB;
    pbmiDIB->bmiHeader.biSizeImage     = 0;
    pbmiDIB->bmiHeader.biXPelsPerMeter = 0;
    pbmiDIB->bmiHeader.biYPelsPerMeter = 0;
    pbmiDIB->bmiHeader.biClrUsed       = 256;
    pbmiDIB->bmiHeader.biClrImportant  = 256;
 
    /*
    ** fill in the palette
    */
    for ( i = 0; i < 256; i++ )
    {
        dibheader.acolors[i].rgbRed   = ( d_8to24table[i] >> 0 )  & 0xff;
        dibheader.acolors[i].rgbGreen = ( d_8to24table[i] >> 8 )  & 0xff;
        dibheader.acolors[i].rgbBlue  = ( d_8to24table[i] >> 16 ) & 0xff;
    }
 
    /*
    ** create the DIB section
    */
    sww_state.hDIBSection = CreateDIBSection( sww_state.hDC,
                                             pbmiDIB,
                                             DIB_RGB_COLORS,
                                             &sww_state.pDIBBase,
                                             NULL,
                                             0 );
 
    if ( sww_state.hDIBSection == NULL )
    {
        ri.Con_Printf( PRINT_ALL, "DIB_Init() - CreateDIBSection failed\n" );
        goto fail;
    }
 
    if ( pbmiDIB->bmiHeader.biHeight > 0 )
    {
        // bottom up
        *ppbuffer   = sww_state.pDIBBase + ( vid.height - 1 ) * vid.width;
        *ppitch     = -vid.width;
    }
    else
    {
        // top down
        *ppbuffer   = sww_state.pDIBBase;
        *ppitch     = vid.width;
    }
 
    MONITORINFOEX monInfo;
    memset(&monInfo, 0, sizeof(MONITORINFOEX));
    monInfo.cbSize = sizeof(MONITORINFOEX);
    GetMonitorInfo( MonitorFromWindow(sww_state.hWnd, MONITOR_DEFAULTTOPRIMARY), (LPMONITORINFO)&monInfo );
 
    ChangeDisplaySettingsEx(monInfo.szDevice, NULL, NULL, 0, NULL);
 
    if (vid_fullscreen->value) //qb: fullscreen dib
    {
 
        RECT        WindowRect;
        DWORD       WindowStyle, ExWindowStyle;
 
        WindowRect.top = monInfo.rcMonitor.top;
        WindowRect.left = monInfo.rcMonitor.left;
 
        WindowRect.right = vid.width;
        WindowRect.bottom = vid.height;
        memset(&gdevmode, 0, sizeof(gdevmode));
        gdevmode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
        gdevmode.dmPelsWidth = vid.width;
        gdevmode.dmPelsHeight = vid.height;
        gdevmode.dmSize = sizeof (gdevmode);
 
        if ( ChangeDisplaySettingsEx( monInfo.szDevice, &gdevmode, NULL, CDS_FULLSCREEN, NULL ) != DISP_CHANGE_SUCCESSFUL )
        {
            //ri.Sys_Error(ERR_FATAL, "Couldn't set fullscreen DIB mode");
            goto fail; //qb: don't panic
        }
 
        GetMonitorInfo( MonitorFromWindow(sww_state.hWnd, MONITOR_DEFAULTTOPRIMARY), (LPMONITORINFO)&monInfo );
        if (!SetWindowPos(sww_state.hWnd,
            NULL,
            monInfo.rcMonitor.left, monInfo.rcMonitor.top,
            WindowRect.right,
            WindowRect.bottom,
            SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOOWNERZORDER | SWP_NOREPOSITION | SWP_NOZORDER))
        {
            //ri.Sys_Error(ERR_FATAL, "Couldn't resize DIB window");
            goto fail; //qb: don't panic
        }
 
        WindowStyle = WS_POPUP | WS_SYSMENU | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
        ExWindowStyle = 0;
 
        AdjustWindowRectEx(&WindowRect, WindowStyle, FALSE, 0);
 
        SetWindowLong(sww_state.hWnd, GWL_STYLE, WindowStyle | WS_VISIBLE);
        SetWindowLong(sww_state.hWnd, GWL_EXSTYLE, ExWindowStyle);
    }
 
    /*
    ** clear the DIB memory buffer
    */
    memset(sww_state.pDIBBase, 0x00, vid.width * vid.height);  //qb: do black, was 0xff
 
    if ( ( sww_state.hdcDIBSection = CreateCompatibleDC( sww_state.hDC ) ) == NULL )
    {
        ri.Con_Printf( PRINT_ALL, "DIB_Init() - CreateCompatibleDC failed\n" );
        goto fail;
    }
    if ( ( previously_selected_GDI_obj = SelectObject( sww_state.hdcDIBSection, sww_state.hDIBSection ) ) == NULL )
    {
        ri.Con_Printf( PRINT_ALL, "DIB_Init() - SelectObject failed\n" );
        goto fail;
    }
 
    return true;
 
fail:
    DIB_Shutdown();
    return false;
    
}

Referenced by SWimp_InitGraphics().

DIB_SetPalette()

void DIB_SetPalette

(

const unsigned char *

palette

)

Definition at line 269 of file rw_dib.c.

{
    const unsigned char *pal = _pal;
    LOGPALETTE      *pLogPal = ( LOGPALETTE * ) &s_ipal;
    RGBQUAD         colors[256];
    int             i;
    int             ret;
    HDC             hDC = sww_state.hDC;
 
    /*
    ** set the DIB color table
    */
    if ( sww_state.hdcDIBSection )
    {
        for ( i = 0; i < 256; i++, pal += 4 )
        {
            colors[i].rgbRed   = pal[0];
            colors[i].rgbGreen = pal[1];
            colors[i].rgbBlue  = pal[2];
            colors[i].rgbReserved = 0;
        }
 
        colors[0].rgbRed = 0;
        colors[0].rgbGreen = 0;
        colors[0].rgbBlue = 0;
 
        colors[255].rgbRed = 0xff;
        colors[255].rgbGreen = 0xff;
        colors[255].rgbBlue = 0xff;
 
        if ( SetDIBColorTable( sww_state.hdcDIBSection, 0, 256, colors ) == 0 )
        {
            ri.Con_Printf( PRINT_ALL, "DIB_SetPalette() - SetDIBColorTable failed\n" );
        }
    }
 
    /*
    ** for 8-bit color desktop modes we set up the palette for maximum
    ** speed by going into an identity palette mode.
    */
    if ( sww_state.palettized )
    {
        int i;
        HPALETTE hpalOld;
 
        if ( SetSystemPaletteUse( hDC, SYSPAL_NOSTATIC ) == SYSPAL_ERROR )
        {
            ri.Sys_Error( ERR_FATAL, "DIB_SetPalette() - SetSystemPaletteUse() failed\n" );
        }
 
        /*
        ** destroy our old palette
        */
        if ( sww_state.hPal )
        {
            DeleteObject( sww_state.hPal );
            sww_state.hPal = 0;
        }
 
        /*
        ** take up all physical palette entries to flush out anything that's currently
        ** in the palette
        */
        pLogPal->palVersion     = 0x300;
        pLogPal->palNumEntries  = 256;
 
        for ( i = 0, pal = _pal; i < 256; i++, pal += 4 )
        {
            pLogPal->palPalEntry[i].peRed   = pal[0];
            pLogPal->palPalEntry[i].peGreen = pal[1];
            pLogPal->palPalEntry[i].peBlue  = pal[2];
            pLogPal->palPalEntry[i].peFlags = PC_RESERVED | PC_NOCOLLAPSE;
        }
        pLogPal->palPalEntry[0].peRed       = 0;
        pLogPal->palPalEntry[0].peGreen     = 0;
        pLogPal->palPalEntry[0].peBlue      = 0;
        pLogPal->palPalEntry[0].peFlags     = 0;
        pLogPal->palPalEntry[255].peRed     = 0xff;
        pLogPal->palPalEntry[255].peGreen   = 0xff;
        pLogPal->palPalEntry[255].peBlue    = 0xff;
        pLogPal->palPalEntry[255].peFlags   = 0;
 
        if ( ( sww_state.hPal = CreatePalette( pLogPal ) ) == NULL )
        {
            ri.Sys_Error( ERR_FATAL, "DIB_SetPalette() - CreatePalette failed(%x)\n", GetLastError() );
        }
 
        if ( ( hpalOld = SelectPalette( hDC, sww_state.hPal, FALSE ) ) == NULL )
        {
            ri.Sys_Error( ERR_FATAL, "DIB_SetPalette() - SelectPalette failed(%x)\n",GetLastError() );
        }
 
        if ( sww_state.hpalOld == NULL )
            sww_state.hpalOld = hpalOld;
 
        if ( ( ret = RealizePalette( hDC ) ) != pLogPal->palNumEntries ) 
        {
            ri.Sys_Error( ERR_FATAL, "DIB_SetPalette() - RealizePalette set %d entries\n", ret );
        }
    }
}

Referenced by SWimp_SetPalette().

DIB_Shutdown()

void DIB_Shutdown

(

void

)

Definition at line 374 of file rw_dib.c.

{
    if ( sww_state.palettized && s_systemcolors_saved )
        DIB_RestoreSystemColors();
 
    if ( sww_state.hPal )
    {
        DeleteObject( sww_state.hPal );
        sww_state.hPal = 0;
    }
 
    if ( sww_state.hpalOld )
    {
        SelectPalette( sww_state.hDC, sww_state.hpalOld, FALSE );
        RealizePalette( sww_state.hDC );
        sww_state.hpalOld = NULL;
    }
 
    if ( sww_state.hdcDIBSection )
    {
        SelectObject( sww_state.hdcDIBSection, previously_selected_GDI_obj );
        DeleteDC( sww_state.hdcDIBSection );
        sww_state.hdcDIBSection = NULL;
    }
 
    if ( sww_state.hDIBSection )
    {
        DeleteObject( sww_state.hDIBSection );
        sww_state.hDIBSection = NULL;
        sww_state.pDIBBase = NULL;
    }
 
    if ( sww_state.hDC )
    {
        ReleaseDC( sww_state.hWnd, sww_state.hDC );
        sww_state.hDC = 0;
    }
}

Referenced by DIB_Init(), and SWimp_Shutdown().

Variable Documentation

sww_state

swwstate_t sww_state

Definition at line 38 of file rw_imp.c.

Referenced by DDRAW_Init(), DDRAW_SetPalette(), DDRAW_Shutdown(), DIB_Init(), DIB_RestoreSystemColors(), DIB_SetPalette(), DIB_Shutdown(), SWimp_AppActivate(), SWimp_EndFrame(), SWimp_Init(), SWimp_SetMode(), SWimp_Shutdown(), and VID_CreateWindow().