void DDKillScreen()
{
if (_lpDDClipper) IDirectDrawClipper_Release(_lpDDClipper);
if (_lpDDPalette) IDirectDrawPalette_Release(_lpDDPalette);
if (_lpDDSBack) IDirectDrawSurface_Release(_lpDDSBack);
if (_lpDDSPrimary) {
if (!GRMODEINFO(modex)) {
DDBLTFX ddbltfx;
HRESULT ddresult;
memset(&ddbltfx, 0, sizeof(DDBLTFX));
ddbltfx.dwSize = sizeof( ddbltfx );
ddbltfx.dwFillColor = (WORD)(BM_XRGB(0,0,0));
ddresult = IDirectDrawSurface_Blt(
_lpDDSPrimary, // dest surface
NULL, // dest rect
NULL, // src surface
NULL, // src rect
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
}
IDirectDrawSurface_Release(_lpDDSPrimary);
}
_lpDDClipper = NULL;
_lpDDPalette = NULL;
_lpDDSBack = NULL;
_lpDDSPrimary = NULL;
}
void gr_palette_clear()
{
int i;
HRESULT ddresult;
Assert(_lpDDPalActive!=0);
// Zero out Palette
for (i = 0; i < 256; i++)
{
PalGDIData.ScratchPal[i].peRed =
PalGDIData.ScratchPal[i].peBlue =
PalGDIData.ScratchPal[i].peGreen = 0;
PalGDIData.ScratchPal[i].peFlags = 0;
}
if (!hPalGDI) {
ddresult = IDirectDrawPalette_SetEntries(_lpDDPalActive, 0,
0, 256,
PalGDIData.ScratchPal);
Assert(ddresult == DD_OK);
}
else {
HDC hdc;
hdc = GetDC(GetLibraryWindow());
SetPaletteEntries(hPalGDI, 0, PalGDIData.num, PalGDIData.ScratchPal);
RealizePalette(hdc);
ReleaseDC(GetLibraryWindow(), hdc);
}
gr_palette_faded_out = 1;
if (GRMODEINFO(emul)) DDClearDisplay();
}
HBITMAP win95_screen_shot()
{
HDC hdcscreen;
HDC hdccapture;
HBITMAP screen_bitmap;
HBITMAP old_bitmap;
//@@ hdcscreen = CreateDC("DISPLAY", NULL, NULL, NULL);
IDirectDrawSurface_GetDC(dd_grd_screencanv->lpdds, &hdcscreen);
hdccapture = CreateCompatibleDC(hdcscreen);
screen_bitmap = CreateCompatibleBitmap(hdcscreen, GRMODEINFO(w), GRMODEINFO(h));
if (!screen_bitmap) {
DeleteDC(hdccapture);
IDirectDrawSurface_ReleaseDC(dd_grd_screencanv->lpdds, hdcscreen);
//@@ DeleteDC(hdcscreen);
return NULL;
}
old_bitmap = SelectObject(hdccapture, screen_bitmap);
if (!old_bitmap) {
DeleteObject(screen_bitmap);
DeleteDC(hdccapture);
IDirectDrawSurface_ReleaseDC(dd_grd_screencanv->lpdds, hdcscreen);
//@@ DeleteDC(hdcscreen);
return NULL;
}
if (!BitBlt(hdccapture, 0,0,GRMODEINFO(w), GRMODEINFO(h), hdcscreen, 0, 0,
SRCCOPY)) {
SelectObject(hdccapture, old_bitmap);
DeleteObject(screen_bitmap);
DeleteDC(hdccapture);
IDirectDrawSurface_ReleaseDC(dd_grd_screencanv->lpdds, hdcscreen);
//@@ DeleteDC(hdcscreen);
return NULL;
}
screen_bitmap = SelectObject(hdccapture, old_bitmap);
DeleteDC(hdccapture);
IDirectDrawSurface_ReleaseDC(dd_grd_screencanv->lpdds, hdcscreen);
//@@ DeleteDC(hdcscreen);
return screen_bitmap;
}
void ClearBackgroundMessages (void)
{
#ifdef WINDOWS
if (bExtraClear == gameData.app.nFrameCount) //don't do extra clear on same frame
return;
#endif
#ifdef WINDOWS
if (( (gameStates.render.cockpit.nMode == CM_STATUS_BAR) || (gameStates.render.cockpit.nMode == CM_FULL_SCREEN)) && (nLastMsgYCrd != -1) && (dd_VR_render_sub_buffer [0].yoff >= 6)) {
dd_grs_canvas *canv_save = dd_grd_curcanv;
#else
if (( (gameStates.render.cockpit.nMode == CM_STATUS_BAR) || (gameStates.render.cockpit.nMode == CM_FULL_SCREEN)) && (nLastMsgYCrd != -1) && (VR_render_sub_buffer [0].cv_bitmap.bm_props.y >= 6)) {
grs_canvas *canv_save = grdCurCanv;
#endif
WINDOS (
DDGrSetCurrentCanvas (GetCurrentGameScreen ()),
GrSetCurrentCanvas (GetCurrentGameScreen ())
);
PA_DFX (pa_set_frontbuffer_current ());
PA_DFX (copy_background_rect (0, nLastMsgYCrd, grdCurCanv->cv_bitmap.bm_props.w, nLastMsgYCrd+nLastMsgHeight-1));
PA_DFX (pa_set_backbuffer_current ());
copy_background_rect (0, nLastMsgYCrd, grdCurCanv->cv_bitmap.bm_props.w, nLastMsgYCrd+nLastMsgHeight-1);
WINDOS (
DDGrSetCurrentCanvas (canv_save),
GrSetCurrentCanvas (canv_save)
);
#ifdef WINDOWS
if (bExtraClear || !GRMODEINFO (modex)) {
bExtraClear = 0;
nLastMsgYCrd = -1;
}
else
bExtraClear = gameData.app.nFrameCount;
#else
nLastMsgYCrd = -1;
#endif
}
szDisplayedBackgroundMsg [nVRCurrentPage][0] = 0;
}
// -----------------------------------------------------------------------------
void HUDClearMessages ()
{
int i, j;
tHUDMessage *pMsgs;
for (j = 2, pMsgs = gameData.hud.msgs; j; j--, pMsgs++) {
pMsgs->nMessages = 0;
pMsgs->nFirst =
pMsgs->nLast = 0;
pMsgs->xTimer = 0;
ClearBackgroundMessages ();
for (i = 0; i < HUD_MAX_MSGS; i++)
sprintf (pMsgs->szMsgs [i], TXT_SLAGEL);
}
}
// DDRestoreScreen
// Restore screens
// ----------------------------------------------------------------------------
int DDRestoreScreen()
{
mprintf((1, "Need to Restore DDraw Page0 and Page1.\n"));
if (!_lpDDSPrimary || IDirectDrawSurface_Restore(_lpDDSPrimary) !=DD_OK) {
mprintf((1, "Warning: Unable to restore Primary Surface.\n"));
return 0;
}
if (!GRMODEINFO(paged) && _lpDDSBack) {
if (IDirectDrawSurface_Restore(_lpDDSBack) != DD_OK) {
mprintf((1, "Warning: Unable to restore Back Surface.\n"));
return 0;
}
}
else if (!_DDFullScreen) {
if (!_lpDDSBack || IDirectDrawSurface_Restore(_lpDDSBack) != DD_OK) {
mprintf((1, "Warning: Unable to restore Back Surface.\n"));
return 0;
}
}
return 1;
}
BOOL DDCreateScreen(int flags)
{
DDSCAPS ddscaps;
DDCAPS ddcaps, ddcaps2;
DDSURFACEDESC ddsd;
HRESULT ddresult;
memset(&ddcaps, 0, sizeof(ddcaps));
memset(&ddcaps2, 0, sizeof(ddcaps2));
ddcaps.dwSize = sizeof(ddcaps);
ddcaps2.dwSize = sizeof(ddcaps);
ddresult = IDirectDraw_GetCaps(_lpDD, &ddcaps, &ddcaps2);
if (!CheckDDResult(ddresult, "DDCreateScreen::GetCaps"))
return FALSE;
logentry("DirectDraw HW Caps: %x\nDirectDraw HEL Caps: %x\n",ddcaps.dwCaps,ddcaps2.dwCaps);
if (ddcaps.dwCaps & DDCAPS_BANKSWITCHED) {
logentry("DirectDraw: Hardware is bank-switched. Using SRAM rendering.\n");
_DDSysMemSurfacing = TRUE;
}
else {
logentry("DirectDraw: Hardware is not bank-switched. Using VRAM rendering.\n");
_DDSysMemSurfacing = FALSE;
}
// Determine GFX caps.
if (ddcaps.dwCaps & DDCAPS_COLORKEYHWASSIST)
ddDriverCaps.hwcolorkey = 1;
else
ddDriverCaps.hwcolorkey = 0;
if (ddcaps.dwCaps & DDCAPS_BLTSTRETCH)
ddDriverCaps.hwbltstretch = 1;
else
ddDriverCaps.hwbltstretch = 0;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
if (_DDFullScreen && GRMODEINFO(paged)) {
// We should use page flipping
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = 1;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_FLIP |
DDSCAPS_COMPLEX;
ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL);
if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -fullscreen"))
return FALSE;
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddresult = IDirectDrawSurface_GetAttachedSurface(_lpDDSPrimary,
&ddscaps, &_lpDDSBack);
if (!CheckDDResult(ddresult, "DDCreateScreen::GetAttachedSurface"))
return FALSE;
}
else {
// We just create a primary and offscreen buffer
if (GRMODEINFO(emul) && !_lpDDSPrimary) {
// make sure we don't reinitialize the screen if we already made it
// beforehand for windowed version
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL);
if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -windowed"))
return FALSE;
}
else if (!GRMODEINFO(emul)) {
// If we aren't emulating
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &_lpDDSPrimary, NULL);
if (!CheckDDResult(ddresult, "DDCreateScreen::CreateSurface -windowed"))
return FALSE;
}
if (GRMODEINFO(emul)) {
_lpDDSBack = DDCreateSurface(_DDModeList[W95DisplayMode].rw,
_DDModeList[W95DisplayMode].rh, 1);
if (!_lpDDSBack) {
mprintf((0,"Call to create DDSBackBuffer failed."));
return FALSE;
}
}
else _lpDDSBack = NULL;
}
// Create 8-bit palette
{
ubyte pal[768];
memset(pal, 0, 768);
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
IDirectDrawSurface_GetSurfaceDesc(_lpDDSPrimary, &ddsd);
logentry("Primary surface pixel format: %x, %d\n", ddsd.ddpfPixelFormat.dwFlags, ddsd.ddpfPixelFormat.dwRGBBitCount);
_lpDDPalette = DDCreatePalette(pal);
Assert(_lpDDPalette != NULL);
DDSetPalette(_lpDDPalette);
}
return TRUE;
}
int gr_palette_fade_out(ubyte *pal, int nsteps, int allow_keys )
{
ubyte c;
int i,j;
HRESULT ddresult;
fix fade_palette[768];
fix fade_palette_delta[768];
allow_keys = allow_keys;
Assert(_lpDDPalActive!=0);
if (gr_palette_faded_out) return 0;
#ifndef NDEBUG
if (grd_fades_disabled) {
gr_palette_clear();
return 0;
}
#endif
for (i=0; i<768; i++ ) {
fade_palette[i] = i2f(pal[i]+gr_palette_gamma);
fade_palette_delta[i] = fade_palette[i] / nsteps;
}
for (j=0; j<nsteps; j++ ) {
for (i=0; i<256; i++ ) {
fade_palette[i*3] -= fade_palette_delta[i*3];
if (fade_palette[i*3] < 0) fade_palette[i*3] = 0;
fade_palette[i*3+1] -= fade_palette_delta[i*3+1];
if (fade_palette[i*3+1] < 0) fade_palette[i*3+1] = 0;
fade_palette[i*3+2] -= fade_palette_delta[i*3+2];
if (fade_palette[i*3+2] < 0) fade_palette[i*3+2] = 0;
c = f2i(fade_palette[i*3]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peRed = c << 2;
c = f2i(fade_palette[i*3+1]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peGreen = c << 2;
c = f2i(fade_palette[i*3+2]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peBlue = c << 2;
PalGDIData.ScratchPal[i].peFlags = 0;
}
if (!hPalGDI) {
IDirectDraw_WaitForVerticalBlank(lpDD, DDWAITVB_BLOCKBEGIN, NULL);
ddresult = IDirectDrawPalette_SetEntries(_lpDDPalActive, 0,
0, 256,
PalGDIData.ScratchPal);
Assert(ddresult == DD_OK);
}
else {
HDC hdc;
hdc = GetDC(GetLibraryWindow());
SetPaletteEntries(hPalGDI, 0, PalGDIData.num, PalGDIData.ScratchPal);
RealizePalette(hdc);
ReleaseDC(GetLibraryWindow(), hdc);
}
}
gr_palette_faded_out = 1;
if (GRMODEINFO(emul)) DDClearDisplay();
return 0;
}
