DDCALLS.C
/*
* Copyright (C) 1995, 1996 Microsoft Corporation. All Rights Reserved.
*
* File: ddcalls.c
*
* Manages DirectDraw objects needed for rendering. Part of D3DApp.
*
* D3DApp is a collection of helper functions for Direct3D applications.
* D3DApp consists of the following files:
*d3dapp.h Main D3DApp header to be included by application
* d3dappi.h Internal header
* d3dapp.c D3DApp functions seen by application.
* ddcalls.c All calls to DirectDraw objects except textures
* d3dcalls.c All calls to Direct3D objects except textures
* texture.c Texture loading and managing texture list
* misc.c Miscellaneous calls
*/
#include "d3dappi.h"
/***************************************************************************/
/* Direct Draw Creation */
/***************************************************************************/
/*
* D3DAppIDDEnumCallback
* Callback function used during enumeration of DirectDraw drivers.
* During enumeration, if a 3D capable hardware device is found, it is
* created and *(LPDIRECTDRAW*)lpContext is set to it. Otherwise, does
* nothing.
*/
BOOL FAR PASCAL D3DAppIDDEnumCallback(GUID FAR* lpGUID, LPSTR lpDriverDesc,
LPSTR lpDriverName, LPVOID lpContext)
{
LPDIRECTDRAW lpDD;
DDCAPS DriverCaps, HELCaps;
/*
* A NULL GUID* indicates the DirectDraw HEL which we are not interested
* in at the moment.
*/
if (lpGUID) {
/*
* Create the DirectDraw device using this driver. If it fails,
* just move on to the next driver.
*/
if (FAILED(DirectDrawCreate(lpGUID, &lpDD, NULL))) {
return DDENUMRET_OK;
}
/*
* Get the capabilities of this DirectDraw driver. If it fails,
* just move on to the next driver.
*/
memset(&DriverCaps, 0, sizeof(DDCAPS));
DriverCaps.dwSize = sizeof(DDCAPS);
memset(&HELCaps, 0, sizeof(DDCAPS));
HELCaps.dwSize = sizeof(DDCAPS);
if (FAILED(lpDD->lpVtbl->GetCaps(lpDD, &DriverCaps, &HELCaps))) {
lpDD->lpVtbl->Release(lpDD);
return DDENUMRET_OK;
}
if (DriverCaps.dwCaps & DDCAPS_3D) {
/*
* We have found a 3d hardware device. Return the DD object
* and stop enumeration.
*/
d3dappi.bIsPrimary = FALSE;
*(LPDIRECTDRAW*)lpContext = lpDD;
return DDENUMRET_CANCEL;
}
lpDD->lpVtbl->Release(lpDD);
}
return DDENUMRET_OK;
}
/*
* D3DAppICreateDD
* Creates the DirectDraw device and saves the current palette. If a 3D
* capable DD driver is available, use it as the DD device, otherwise, use
* the HEL. It is assumed that a 3D capable DD hardware driver is not the
* primary device and hence cannot operate in a window (ie it's a fullscreen
* only device displaying on a second monitor). Valid flags:
* D3DAPP_ONLYDDEMULATION Always use the DirectDraw HEL
*/
BOOL
D3DAppICreateDD(DWORD flags)
{
HDC hdc;
int i;
LPDIRECTDRAW lpDD = NULL;
/*
* If we aren't forced to use the DirectDraw HEL, search for a 3D capable
* DirectDraw hardware driver and create it.
*/
if (!(flags & D3DAPP_ONLYDDEMULATION)) {
LastError = DirectDrawEnumerate(D3DAppIDDEnumCallback, &lpDD);
if (LastError != DD_OK) {
D3DAppISetErrorString("DirectDrawEnumerate failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
}
if (!lpDD) {
/*
* If we haven't created a hardware DD device by now, resort to HEL
*/
d3dappi.bIsPrimary = TRUE;
LastError = DirectDrawCreate(NULL, &d3dappi.lpDD, NULL);
if (LastError != DD_OK) {
D3DAppISetErrorString("DirectDrawCreate failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
} else {
d3dappi.lpDD = lpDD;
}
/*
* Save the original palette for when we are paused. Just in case we
* start in a fullscreen mode, put them in ppe.
*/
hdc = GetDC(NULL);
GetSystemPaletteEntries(hdc, 0, (1 << 8),
(LPPALETTEENTRY)(&Originalppe[0]));
for (i = 0; i < 256; i++)
ppe[i] = Originalppe[i];
ReleaseDC(NULL, hdc);
return TRUE;
}
/***************************************************************************/
/* Enumerating the display modes */
/***************************************************************************/
/*
* EnumDisplayModesCallback
* Callback to save the display mode information.
*/
static HRESULT
CALLBACK EnumDisplayModesCallback(LPDDSURFACEDESC pddsd, LPVOID lpContext)
{
/*
* Very large resolutions cause problems on some hardware. They are also
* not very useful for real-time rendering. We have chosen to disable
* them by not reporting them as available.
*/
if (pddsd->dwWidth > 1024 || pddsd->dwHeight > 768)
return DDENUMRET_OK;
/*
* Save this mode at the end of the mode array and increment mode count
*/
d3dappi.Mode[d3dappi.NumModes].w = pddsd->dwWidth;
d3dappi.Mode[d3dappi.NumModes].h = pddsd->dwHeight;
d3dappi.Mode[d3dappi.NumModes].bpp = pddsd->ddpfPixelFormat.dwRGBBitCount;
d3dappi.Mode[d3dappi.NumModes].bThisDriverCanDo = FALSE;
d3dappi.NumModes++;
if (d3dappi.NumModes == D3DAPP_MAXMODES)
return DDENUMRET_CANCEL;
else
return DDENUMRET_OK;
}
/*
* CompareModes
* Compare two display modes during sorting. Modes are sorted by depth and
* then resolution.
*/
static int
CompareModes(const void* element1, const void* element2)
{
D3DAppMode *lpMode1, *lpMode2;
lpMode1 = (D3DAppMode*)element1;
lpMode2 = (D3DAppMode*)element2;
if (lpMode1->bpp > lpMode2->bpp)
return -1;
else if (lpMode2->bpp > lpMode1->bpp)
return 1;
else if (lpMode1->w > lpMode2->w)
return -1;
else if (lpMode2->w > lpMode1->w)
return 1;
else if (lpMode1->h > lpMode2->h)
return -1;
else if (lpMode2->h > lpMode1->h)
return 1;
else
return 0;
}
/*
* EnumerateDisplayModes
* Generates the list of available display modes.
*/
BOOL
D3DAppIEnumDisplayModes(void)
{
int i;
/*
* Get a list of available display modes from DirectDraw
*/
d3dappi.NumModes = 0;
LastError = d3dappi.lpDD->lpVtbl->EnumDisplayModes(d3dappi.lpDD, 0, NULL,
0, EnumDisplayModesCallback);
if(LastError != DD_OK ) {
D3DAppISetErrorString("EnumDisplayModes failed.\n%s",
D3DAppErrorToString(LastError));
d3dappi.NumModes = 0;
return FALSE;
}
/*
* Sort the list of display modes
*/
qsort((void *)&d3dappi.Mode[0], (size_t)d3dappi.NumModes, sizeof(D3DAppMode),
CompareModes);
/*
* Pick a default display mode. 640x480x16 is a very good mode for
* rendering, so choose it over all others. Otherwise, just take the
* first one. This selection may be overriden later if a driver is
* created which cannot render in this mode.
*/
d3dappi.CurrMode = 0;
for (i = 0; i < d3dappi.NumModes; i++) {
if (d3dappi.Mode[i].w == 640 && d3dappi.Mode[i].h == 480 &&
d3dappi.Mode[i].bpp == 16)
d3dappi.CurrMode = i;
}
memcpy(&d3dappi.ThisMode, &d3dappi.Mode[d3dappi.CurrMode],
sizeof(D3DAppMode));
return TRUE;
}
/***************************************************************************/
/* Creating Front and Back Buffers (and misc surf funcs) */
/***************************************************************************/
/*
* D3DAppICreateSurface
* Create a DirectDraw Surface of the given description. Using this function
* ensures that all surfaces end up in system memory if that option was set.
* Returns the result of the CreateSurface call.
*/
HRESULT
D3DAppICreateSurface(LPDDSURFACEDESC lpDDSurfDesc,
LPDIRECTDRAWSURFACE FAR *lpDDSurface) {
HRESULT result;
if (d3dappi.bOnlySystemMemory)
lpDDSurfDesc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
result = d3dappi.lpDD->lpVtbl->CreateSurface(d3dappi.lpDD, lpDDSurfDesc,
lpDDSurface, NULL);
return result;
}
/*
* D3DAppIGetSurfDesc
* Get the description of the given surface. Returns the result of the
* GetSurfaceDesc call.
*/
HRESULT
D3DAppIGetSurfDesc(LPDDSURFACEDESC lpDDSurfDesc,LPDIRECTDRAWSURFACE lpDDSurf)
{
HRESULT result;
memset(lpDDSurfDesc, 0, sizeof(DDSURFACEDESC));
lpDDSurfDesc->dwSize = sizeof(DDSURFACEDESC);
result = lpDDSurf->lpVtbl->GetSurfaceDesc(lpDDSurf, lpDDSurfDesc);
return result;
}
/*
* D3DAppICreateBuffers
* Creates the front and back buffers for the window or fullscreen case
* depending on the bFullscreen flag. In the window case, bpp is ignored.
*/
BOOL
D3DAppICreateBuffers(HWND hwnd, int w, int h, int bpp, BOOL bFullscreen, BOOL bIsHardware)
{
DDSURFACEDESC ddsd;
DDSCAPS ddscaps;
/*
* Release any old objects that might be lying around. This should have
* already been taken care of, but just in case...
*/
RELEASE(lpClipper);
RELEASE(d3dappi.lpBackBuffer);
RELEASE(d3dappi.lpFrontBuffer);
/*
* The size of the buffers is going to be w x h, so record it now
*/
if (w < D3DAPP_WINDOWMINIMUM)
w = D3DAPP_WINDOWMINIMUM;
if (h < D3DAPP_WINDOWMINIMUM)
h = D3DAPP_WINDOWMINIMUM;
szBuffers.cx = w;
szBuffers.cy = h;
if (bFullscreen) {
/*
* Create a complex flipping surface for fullscreen mode with one
* back buffer.
*/
memset(&ddsd,0,sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
if (bIsHardware)
ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
LastError = D3DAppICreateSurface(&ddsd, &d3dappi.lpFrontBuffer);
if(LastError != DD_OK) {
if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
D3DAppISetErrorString("There was not enough video memory to create the rendering surface.\nPlease restart the program and try another fullscreen mode with less resolution or lower bit depth.");
} else {
D3DAppISetErrorString("CreateSurface for fullscreen flipping surface failed.\n%s",
D3DAppErrorToString(LastError));
}
goto exit_with_error;
}
/*
* Obtain a pointer to the back buffer surface created above so we
* can use it later. For now, just check to see if it ended up in
* video memory (FYI).
*/
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
LastError = d3dappi.lpFrontBuffer->lpVtbl->GetAttachedSurface(d3dappi.lpFrontBuffer, &ddscaps, &d3dappi.lpBackBuffer);
if(LastError != DD_OK) {
D3DAppISetErrorString("GetAttachedSurface failed to get back buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failed to get surface description of back buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
d3dappi.bBackBufferInVideo =
(ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
}
else {
/*
* In the window case, create a front buffer which is the primary
* surface and a back buffer which is an offscreen plane surface.
*/
memset(&ddsd,0,sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof(DDSURFACEDESC);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
/*
* If we specify system memory when creating a primary surface, we
* won't get the actual primary surface in video memory. So, don't
* use D3DAppICreateSurface().
*/
LastError = d3dappi.lpDD->lpVtbl->CreateSurface(d3dappi.lpDD,
&ddsd, &d3dappi.lpFrontBuffer, NULL);
if(LastError != DD_OK ) {
if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
D3DAppISetErrorString("There was not enough video memory to create the rendering surface.\nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
} else {
D3DAppISetErrorString("CreateSurface for window front buffer failed.\n%s",
D3DAppErrorToString(LastError));
}
goto exit_with_error;
}
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
ddsd.dwWidth = w;
ddsd.dwHeight = h;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
if (bIsHardware)
ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
else
ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
LastError = D3DAppICreateSurface(&ddsd, &d3dappi.lpBackBuffer);
if (LastError != DD_OK) {
if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
D3DAppISetErrorString("There was not enough video memory to create the rendering surface.\nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
} else {
D3DAppISetErrorString("CreateSurface for window back buffer failed.\n%s",
D3DAppErrorToString(LastError));
}
goto exit_with_error;
}
/*
* Check to see if the back buffer is in video memory (FYI).
*/
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failed to get surface description for back buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
d3dappi.bBackBufferInVideo =
(ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
/*
* Create the DirectDraw Clipper object and attach it to the window
* and front buffer.
*/
LastError = d3dappi.lpDD->lpVtbl->CreateClipper(d3dappi.lpDD, 0,
&lpClipper, NULL);
if(LastError != DD_OK ) {
D3DAppISetErrorString("CreateClipper failed.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
LastError = lpClipper->lpVtbl->SetHWnd(lpClipper, 0, hwnd);
if(LastError != DD_OK ) {
D3DAppISetErrorString("Attaching clipper to window failed.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
LastError =
d3dappi.lpFrontBuffer->lpVtbl->SetClipper(d3dappi.lpFrontBuffer,
lpClipper);
if(LastError != DD_OK ) {
D3DAppISetErrorString("Attaching clipper to front buffer failed.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
}
D3DAppIClearBuffers();
return TRUE;
exit_with_error:
RELEASE(d3dappi.lpFrontBuffer);
RELEASE(d3dappi.lpBackBuffer);
RELEASE(lpClipper);
return FALSE;
}
/*
* D3DAppICheckForPalettized
* If the front/back buffer is palettized, we need to create a palette.
*/
BOOL
D3DAppICheckForPalettized(void)
{
DDSURFACEDESC ddsd;
/*
* Get the back buffer surface description and check to see if it's
* palettized
*/
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failed to get surface description for back buffer for palettizing.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
bPrimaryPalettized =
(ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) ? TRUE : FALSE;
if (bPrimaryPalettized) {
int i;
/*
* Get the current palette.
*/
HDC hdc = GetDC(NULL);
GetSystemPaletteEntries(hdc, 0, (1 << 8), ppe);
ReleaseDC(NULL, hdc);
/*
* Change the flags on the palette entries to allow D3D to change
* some of them. In the window case, we must not change the top and
* bottom ten (system colors), but in a fullscreen mode we can have
* all but the first and last.
*/
if (!d3dappi.bFullscreen) {
for (i = 0; i < 10; i++) ppe[i].peFlags = D3DPAL_READONLY;
for (i = 10; i < 256 - 10; i++) ppe[i].peFlags = D3DPAL_FREE | PC_RESERVED;
for (i = 256 - 10; i < 256; i++) ppe[i].peFlags = D3DPAL_READONLY;
} else {
ppe[0].peFlags = D3DPAL_READONLY;
for (i = 1; i < 255; i++) ppe[i].peFlags = D3DPAL_FREE | PC_RESERVED;
ppe[255].peFlags = D3DPAL_READONLY;
}
/*
* Create a palette using the old colors and new flags
*/
LastError = d3dappi.lpDD->lpVtbl->CreatePalette(d3dappi.lpDD,
DDPCAPS_8BIT | DDPCAPS_INITIALIZE,
ppe, &lpPalette, NULL);
if (LastError != DD_OK) {
D3DAppISetErrorString("CreatePalette failed.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
/*
* Set this as the front and back buffers' palette
*/
LastError =
d3dappi.lpBackBuffer->lpVtbl->SetPalette(d3dappi.lpBackBuffer,
lpPalette);
if(LastError != DD_OK ) {
D3DAppISetErrorString("SetPalette failed on back buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
LastError =
d3dappi.lpFrontBuffer->lpVtbl->SetPalette(d3dappi.lpFrontBuffer,
lpPalette);
if(LastError != DD_OK ) {
D3DAppISetErrorString("SetPalette failed on front buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
/*
* The palette is now valid, so set it again on anyt WM_ACTIVATE
*/
bPaletteActivate = TRUE;
}
return TRUE;
exit_with_error:
RELEASE(lpPalette);
return FALSE;
}
/***************************************************************************/
/* Creation of Z-Buffer */
/***************************************************************************/
/*
* D3DAppICreateZBuffer
* Create a Z-Buffer of the appropriate depth and attach it to the back
* buffer.
*/
BOOL
D3DAppICreateZBuffer(int w, int h, int driver)
{
DDSURFACEDESC ddsd;
DWORD devDepth;
/*
* Release any Z-Buffer that might be around just in case.
*/
RELEASE(d3dappi.lpZBuffer);
/*
* If this driver does not do z-buffering, don't create a z-buffer
*/
if (!d3dappi.Driver[driver].bDoesZBuffer)
return TRUE;
memset(&ddsd, 0 ,sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS |
DDSD_ZBUFFERBITDEPTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
ddsd.dwHeight = h;
ddsd.dwWidth = w;
/*
* If this is a hardware D3D driver, the Z-Buffer MUST end up in video
* memory. Otherwise, it MUST end up in system memory.
*/
if (d3dappi.Driver[driver].bIsHardware)
ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
else
ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
/*
* Get the Z buffer bit depth from this driver's D3D device description
*/
devDepth = d3dappi.Driver[driver].Desc.dwDeviceZBufferBitDepth;
if (devDepth & DDBD_32)
ddsd.dwZBufferBitDepth = 32;
else if (devDepth & DDBD_24)
ddsd.dwZBufferBitDepth = 24;
else if (devDepth & DDBD_16)
ddsd.dwZBufferBitDepth = 16;
else if (devDepth & DDBD_8)
ddsd.dwZBufferBitDepth = 8;
else {
D3DAppISetErrorString("Unsupported Z-buffer depth requested by device.\n");
return FALSE;
}
LastError = d3dappi.lpDD->lpVtbl->CreateSurface(d3dappi.lpDD, &ddsd,
&d3dappi.lpZBuffer,
NULL);
if(LastError != DD_OK) {
if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
if (d3dappi.bFullscreen) {
D3DAppISetErrorString("There was not enough video memory to create the Z-buffer surface.\nPlease restart the program and try another fullscreen mode with less resolution or lower bit depth.");
} else {
D3DAppISetErrorString("There was not enough video memory to create the Z-buffer surface.\nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
}
} else {
D3DAppISetErrorString("CreateSurface for Z-buffer failed.\n%s",
D3DAppErrorToString(LastError));
}
goto exit_with_error;
}
/*
* Attach the Z-buffer to the back buffer so D3D will find it
*/
LastError =
d3dappi.lpBackBuffer->lpVtbl->AddAttachedSurface(d3dappi.lpBackBuffer,
d3dappi.lpZBuffer);
if(LastError != DD_OK) {
D3DAppISetErrorString("AddAttachedBuffer failed for Z-Buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
/*
* Find out if it ended up in video memory.
*/
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpZBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failed to get surface description of Z buffer.\n%s",
D3DAppErrorToString(LastError));
goto exit_with_error;
}
d3dappi.bZBufferInVideo =
(ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
if (d3dappi.Driver[driver].bIsHardware && !d3dappi.bZBufferInVideo) {
D3DAppISetErrorString("Could not fit the Z-buffer in video memory for this hardware device.\n");
goto exit_with_error;
}
return TRUE;
exit_with_error:
RELEASE(d3dappi.lpZBuffer);
return FALSE;
}
/***************************************************************************/
/* WM_SIZE Handler */
/***************************************************************************/
/*
* D3DAppIHandleWM_SIZE
* Processes the WM_SIZE message. Resizes all the buffers and re-creates
* device if necessary.
*/
BOOL
D3DAppIHandleWM_SIZE(LRESULT* lresult, HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
int w, h, i;
/*
* If we have minimzied, take note and call the default window proc
*/
if (wParam == SIZE_MINIMIZED) {
d3dappi.bMinimized = TRUE;
*lresult = DefWindowProc(hwnd, message, wParam, lParam);
return TRUE;
}
/*
* In fullscreen mode, restore our surfaces and let DDraw take
* care of the rest.
*/
if (d3dappi.bFullscreen) {
D3DAppIValidateDirtyRects();
D3DAppCheckForLostSurfaces();
d3dappi.bMinimized = FALSE;
*lresult = DefWindowProc(hwnd, message, wParam, lParam);
return TRUE;
}
/*
* If we are minimized, this is the un-minimized size message.
*/
if (d3dappi.bMinimized) {
/*
* Restore our surfaces and update the dirty rectangle info
*/
D3DAppIValidateDirtyRects();
D3DAppCheckForLostSurfaces();
d3dappi.bMinimized = FALSE;
*lresult = DefWindowProc(hwnd, message, wParam, lParam);
return TRUE;
}
/*
* Since we are still here, this must be a regular, window resize
* message. A new viewport will definitely be needed, but the
* device and buffers will only be re-created if they have gotten bigger
* or change size by a very large amount.
*/
D3DAppIGetClientWin(hwnd);
w = LOWORD(lParam);
h = HIWORD(lParam);
/*
* If w and h are under the minimum, create buffers of the minimum size
*/
if (w < D3DAPP_WINDOWMINIMUM)
w = D3DAPP_WINDOWMINIMUM;
if (h < D3DAPP_WINDOWMINIMUM)
h = D3DAPP_WINDOWMINIMUM;
/*
* Destroy the viewport and all execute buffers
*/
d3dappi.bRenderingIsOK = FALSE;
ATTEMPT(D3DAppICallDeviceDestroyCallback());
/*
* Only create a new device and buffers if they changed significantly,
* otherwise just make sure the old buffers aren't lost.
*/
if ((w > szBuffers.cx || h > szBuffers.cy) ||
(w < szBuffers.cx / 2 || h < szBuffers.cy / 2)) {
/*
* Release the device
*/
RELEASE(d3dappi.lpD3DDevice);
/*
* Release the old buffers
*/
RELEASE(d3dappi.lpZBuffer);
RELEASE(lpPalette);
RELEASE(lpClipper);
RELEASE(d3dappi.lpBackBuffer);
RELEASE(d3dappi.lpFrontBuffer);
/*
* Create new ones
*/
ATTEMPT(D3DAppICreateBuffers(hwnd, w, h, D3DAPP_BOGUS, FALSE, d3dappi.ThisDriver.bIsHardware));
ATTEMPT(D3DAppICheckForPalettized());
ATTEMPT(D3DAppICreateZBuffer(w, h, d3dappi.CurrDriver));
/*
* Create the driver
*/
ATTEMPT(D3DAppICreateDevice(d3dappi.CurrDriver));
/*
* Since the driver did not change, the texture surfaces are still valid.
* We just need to get new handles.
*/
if (d3dappi.ThisDriver.bDoesTextures) {
for (i = 0; i < d3dappi.NumUsableTextures; i++) {
D3DAppIGetTextureHandle(i);
}
}
} else {
D3DAppCheckForLostSurfaces();
}
/*
* Call the device create callback to create the viewport, set the render
* state and clear the dirty rectangle info
*/
ATTEMPT(D3DAppICallDeviceCreateCallback(w, h));
ATTEMPT(D3DAppISetRenderState());
D3DAppIValidateDirtyRects();
d3dappi.bRenderingIsOK = TRUE;
/*
* Call the default window proc
*/
*lresult = DefWindowProc(hwnd, message, wParam, lParam);
return TRUE;
exit_with_error:
D3DAppICallDeviceDestroyCallback();
RELEASE(d3dappi.lpD3DDevice);
RELEASE(d3dappi.lpZBuffer);
RELEASE(lpPalette);
RELEASE(lpClipper);
RELEASE(d3dappi.lpBackBuffer);
RELEASE(d3dappi.lpFrontBuffer);
return FALSE;
}
/***************************************************************************/
/* Setting the display mode and cooperative level */
/***************************************************************************/
/*
* D3DAppISetCoopLevel
* Set the cooperative level to exclusive mode for fullscreen and normal for
* a window. Set the bIgnoreWM_SIZE flag because SetCooperativeLevel
* generates a WM_SIZE message you do not have to resize the buffers on.
*/
BOOL
D3DAppISetCoopLevel(HWND hwnd, BOOL bFullscreen)
{
if (bFullscreen) {
bIgnoreWM_SIZE = TRUE;
LastError = d3dappi.lpDD->lpVtbl->SetCooperativeLevel(d3dappi.lpDD,
hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
bIgnoreWM_SIZE = FALSE;
if(LastError != DD_OK ) {
D3DAppISetErrorString("SetCooperativeLevel to fullscreen failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
d3dappi.bFullscreen = TRUE;
} else {
bIgnoreWM_SIZE = TRUE;
LastError = d3dappi.lpDD->lpVtbl->SetCooperativeLevel(d3dappi.lpDD,
hwnd, DDSCL_NORMAL);
bIgnoreWM_SIZE = FALSE;
if(LastError != DD_OK ) {
D3DAppISetErrorString("SetCooperativeLevel to normal failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
d3dappi.bFullscreen = FALSE;
}
return TRUE;
}
/*
* D3DAppISetDisplayMode
* Set the display mode to the given dimensions and bits per pixel. The
* bIgnoreWM_SIZE message is set because the display change generates a
* WM_SIZE message which we don't want to resize the buffers on.
*/
BOOL
D3DAppISetDisplayMode(int w, int h, int bpp)
{
d3dappi.ThisMode.w = w; d3dappi.ThisMode.h = h;
d3dappi.ThisMode.bpp = bpp;
bIgnoreWM_SIZE = TRUE;
LastError = d3dappi.lpDD->lpVtbl->SetDisplayMode(d3dappi.lpDD, w, h,
bpp);
bIgnoreWM_SIZE = FALSE;
if(LastError != DD_OK ) {
D3DAppISetErrorString("SetDisplayMode to %dx%dx%d failed\n%s",
w, h, bpp, D3DAppErrorToString(LastError));
return FALSE;
}
return TRUE;
}
/*
* D3DAppIRestoreDispMode
* Restores the display mode to the current windows display mode. The
* bIgnoreWM_SIZE message is set because the display change generates a
* WM_SIZE message which we don't want to resize the buffers on.
*/
BOOL
D3DAppIRestoreDispMode(void)
{
bIgnoreWM_SIZE = TRUE;
LastError = d3dappi.lpDD->lpVtbl->RestoreDisplayMode(d3dappi.lpDD);
if (LastError != DD_OK) {
D3DAppISetErrorString("RestoreDisplayMode failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
bIgnoreWM_SIZE = FALSE;
return TRUE;
}
/*
* D3DAppRememberWindowsMode
* Record the current display mode in d3dappi.WindowsDisplay
*/
BOOL
D3DAppIRememberWindowsMode(void)
{
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof(DDSURFACEDESC);
LastError = d3dappi.lpDD->lpVtbl->GetDisplayMode(d3dappi.lpDD, &ddsd);
if (LastError != DD_OK) {
D3DAppISetErrorString("Getting the current display mode failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
d3dappi.WindowsDisplay.w = ddsd.dwWidth;
d3dappi.WindowsDisplay.h = ddsd.dwHeight;
d3dappi.WindowsDisplay.bpp = ddsd.ddpfPixelFormat.dwRGBBitCount;
return TRUE;
}
/***************************************************************************/
/* Misc DD Utilities */
/***************************************************************************/
/*
* D3DAppIClearBuffers
* Clear the front and back buffers to black
*/
BOOL
D3DAppIClearBuffers(void)
{
DDSURFACEDESC ddsd;
RECT dst;
DDBLTFX ddbltfx;
/*
* Find the width and height of the front buffer by getting its
* DDSURFACEDESC
*/
if (d3dappi.lpFrontBuffer) {
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpFrontBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failure getting the surface description of the front buffer before clearing.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
/*
* Clear the front buffer to black
*/
memset(&ddbltfx, 0, sizeof(ddbltfx));
ddbltfx.dwSize = sizeof(DDBLTFX);
SetRect(&dst, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
LastError = d3dappi.lpFrontBuffer->lpVtbl->Blt(d3dappi.lpFrontBuffer,
&dst, NULL, NULL,
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
if (LastError != DD_OK) {
D3DAppISetErrorString("Clearing the front buffer failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
}
if (d3dappi.lpBackBuffer) {
/*
* Find the width and height of the back buffer by getting its
* DDSURFACEDESC
*/
LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
if (LastError != DD_OK) {
D3DAppISetErrorString("Failure while getting the surface description of the back buffer before clearing.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
/*
* Clear the back buffer to black
*/
memset(&ddbltfx, 0, sizeof(ddbltfx));
ddbltfx.dwSize = sizeof(DDBLTFX);
SetRect(&dst, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
LastError = d3dappi.lpBackBuffer->lpVtbl->Blt(d3dappi.lpBackBuffer, &dst,
NULL, NULL,
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
if (LastError != DD_OK) {
D3DAppISetErrorString("Clearing the front buffer failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
}
return TRUE;
}
/*
* D3DAppIBPPToDDBD
* Convert an integer bit per pixel number to a DirectDraw bit depth flag
*/
DWORD
D3DAppIBPPToDDBD(int bpp)
{
switch(bpp) {
case 1:
return DDBD_1;
case 2:
return DDBD_2;
case 4:
return DDBD_4;
case 8:
return DDBD_8;
case 16:
return DDBD_16;
case 24:
return DDBD_24;
case 32:
return DDBD_32;
default:
return (DWORD)D3DAPP_BOGUS;
}
}
/*
* D3DAppTotalVideoMemory
* Returns the amount of total video memory supported (not free)
*/
DWORD
D3DAppTotalVideoMemory(void)
{
DDCAPS DriverCaps, HELCaps;
memset (&DriverCaps, 0, sizeof(DDCAPS));
DriverCaps.dwSize = sizeof(DDCAPS);
memset (&HELCaps, 0, sizeof(DDCAPS));
HELCaps.dwSize = sizeof(DDCAPS);
LastError = d3dappi.lpDD->lpVtbl->GetCaps(d3dappi.lpDD, &DriverCaps,
&HELCaps);
if (LastError != DD_OK) {
D3DAppISetErrorString("Getting DD capabilities failed while checking total video memory.\n%s",
D3DAppErrorToString(LastError));
return 0L;
}
if (DriverCaps.dwVidMemTotal)
return DriverCaps.dwVidMemTotal;
else
return HELCaps.dwVidMemTotal;
}