How to refresh the graphics to avoid black screen? - c++

Question

When I minimized my directx framework and open up the task manage then go back to the framework. It gives me the black screen. How should I modify my code to fix this flaw?
GraphicsClass.h
#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_
//////////////
// INCLUDES //
//////////////
#include <d3dx9.h>
#include <assert.h>
#include <string>
using namespace std;
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const unsigned int SCREEN_WIDTH = 1280;
const unsigned int SCREEN_HEIGHT = 720;
////////////////////////////////////////////////////////////////////////////////
// Class name: GraphicsClass
////////////////////////////////////////////////////////////////////////////////
class GraphicsClass
{
public:
GraphicsClass( HWND hwnd );
~GraphicsClass();
void SetPath( const string& loadFolder );
void BeginFrame();
void EndFrame();
void Load( IDirect3DTexture9*& texture, string imgName, int imgWidth, int imgHeight );
void setFont(ID3DXFont*& font, char* fontName, int fontHeight);
void SourceRect( RECT& sourceRect, int left, int right, int top, int bottom );
void DrawText( ID3DXFont*& font, LPCSTR string, int charNum, RECT& SourceRect, DWORD format, D3DCOLOR color );
void Draw( IDirect3DTexture9* texture );
void Draw( IDirect3DTexture9* texture, float posX, float posY );
void Draw( IDirect3DTexture9* texture, RECT& sourceRect, float posX, float posY );
private:
string path;
HRESULT result;
ID3DXSprite* pSprite;
IDirect3D9* pDirect3D;
IDirect3DDevice9* pDevice;
};
#endif
GraphicsClass.cpp
#include "GraphicsClass.h"
GraphicsClass::GraphicsClass( HWND hwnd )
{
pDirect3D = Direct3DCreate9( D3D_SDK_VERSION );
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.BackBufferWidth = SCREEN_WIDTH;
d3dpp.BackBufferHeight = SCREEN_HEIGHT;
d3dpp.hDeviceWindow = hwnd;
//d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
result = pDirect3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &pDevice );
assert( !FAILED(result) );
result = D3DXCreateSprite( pDevice, &pSprite );
assert( !FAILED(result) );
}
GraphicsClass::~GraphicsClass()
{
// Release and clean up sprite
pSprite->Release();
pSprite = NULL;
}
void GraphicsClass::SetPath( const string& path )
{
this->path = path;
}
void GraphicsClass::BeginFrame()
{
pDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 255, 255, 255 ), 1.0f, 0 );
pDevice->BeginScene();
// Specify alpha blend will ensure that the sprite will render the background with alpha.
pSprite->Begin( D3DXSPRITE_ALPHABLEND );
}
void GraphicsClass::EndFrame()
{
// End sprite drawing
pSprite->End();
pDevice->EndScene();
pDevice->Present( NULL, NULL, NULL, NULL );
}
void GraphicsClass::Load( IDirect3DTexture9*& texture, string imgName, int imgWidth, int imgHeight )
{
string fullPath;
fullPath = path + imgName;
result = D3DXCreateTextureFromFileEx( pDevice, fullPath.c_str(), imgWidth, imgHeight,
D3DX_DEFAULT, NULL, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, NULL,
NULL, NULL, &texture );
}
void GraphicsClass::setFont(ID3DXFont*& font, char* fontName, int fontHeight)
{
result = D3DXCreateFont(pDevice, fontHeight, 0, 0, 1, false,
DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, fontName, &font);
}
void GraphicsClass::SourceRect( RECT& sourceRect, int left, int right, int top, int bottom )
{
sourceRect.left = left;
sourceRect.right = right;
sourceRect.top = top;
sourceRect.bottom = bottom;
}
void GraphicsClass::DrawText( ID3DXFont*& font, LPCSTR string, int charNum, RECT& SourceRect, DWORD format, D3DCOLOR color)
{
font->DrawText(pSprite, string, charNum, &SourceRect, format, color);
}
void GraphicsClass::Draw( IDirect3DTexture9* texture )
{
pSprite->Draw( texture, NULL, NULL, &D3DXVECTOR3( 0, 0, 0 ), D3DCOLOR_XRGB( 255, 255, 255 ) );
}
void GraphicsClass::Draw( IDirect3DTexture9* texture, float posX, float posY )
{
pSprite->Draw( texture, NULL, NULL, &D3DXVECTOR3( posX, posY, 0 ), D3DCOLOR_XRGB( 255, 255, 255 ) );
}
void GraphicsClass::Draw( IDirect3DTexture9* texture, RECT& sourceRect, float posX, float posY )
{
pSprite->Draw( texture, &sourceRect, NULL, &D3DXVECTOR3( posX, posY, 0 ), D3DCOLOR_XRGB( 255, 255, 255 ) );
}
SystemClass.cpp
void SystemClass::InitializeWindows()
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int screenWidth, screenHeight;
int posX, posY;
// Get an external pointer to this object
ApplicationHandle = this;
// Get the instance of this application
m_hinstance = GetModuleHandle( NULL );
// Give the application a name
m_applicationName = "Zero DirectX Framework";
// Setup the windows class with default settings
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hinstance;
wc.hIcon = LoadIcon( NULL, IDI_WINLOGO );
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
wc.lpszMenuName = NULL;
wc.lpszClassName = m_applicationName;
wc.cbSize = sizeof( WNDCLASSEX );
// Register the window class
RegisterClassEx( &wc );
// Determine the resolution of the clients desktop screen
screenWidth = GetSystemMetrics( SM_CXSCREEN );
screenHeight = GetSystemMetrics( SM_CYSCREEN );
// Setup the screen settings depending on whether it is running in full screen or in windowed mode
if ( FULL_SCREEN )
{
// If full screen set the screen to maximum size of the users desktop and 32bit
memset( &dmScreenSettings, 0, sizeof(dmScreenSettings) );
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth;
dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Change the display settings to full screen
ChangeDisplaySettings( &dmScreenSettings, CDS_FULLSCREEN );
// Set the position of the window to the top left corner
posX = posY = 0;
// Create the window with the screen settings and get the handle to it
m_hwnd = CreateWindowEx( WS_EX_APPWINDOW, m_applicationName, m_applicationName,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL);
SetMenu( m_hwnd, NULL );
}
else
{
// If windowed then set it to 800x600 resolution
screenWidth = 1280;
screenHeight = 768;
// Place the window in the middle of the screen
posX = ( GetSystemMetrics( SM_CXSCREEN ) - screenWidth ) / 2;
posY = ( GetSystemMetrics( SM_CYSCREEN ) - screenHeight) / 2;
m_hwnd = CreateWindowEx( 0, m_applicationName, m_applicationName, WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
posX, posY, screenWidth, screenHeight,
NULL, NULL, m_hinstance, NULL );
}
// Bring the window up on the screen and set it as main focus
ShowWindow( m_hwnd, SW_SHOW );
SetForegroundWindow( m_hwnd );
SetFocus( m_hwnd );
// Hide the mouse cursor
ShowCursor(true);
}

Answer 1

You're not handling situation when device is lost, which is (possibly) what happens in this case.
Basically, BEFORE rendering anything you should test cooperative level, if it returns D3DERR_DEVICELOST, do not do not draw anything. If it returns D3DERR_DEVICENOTRESET, you should reset the device, if it returns 0 (D3DERR_OK or use SUCCEEDED macro), then proceed to draw the frame.
When device is reset, it loses all resources that are not in D3DPOOL_MANAGED, and you'll need to recreate them, or reload them. You can release all shaders and id3dx objects (like ID3DXFont) before calling IDirect3DDevice9::Reset, then recreate them after succesfull reset call.
Failure to handle "lost devices" will mean that you won't be able to alt-tab your game when running in fullscreen, and switching display mode might "break it". IN your situation black screen most likely happens for the same reason.