//-------------------------------------------------------------------------------------- // File: ShadowMap.cpp // // Starting point for new Direct3D applications // // Copyright (c) Microsoft Corporation. All rights reserved. //-------------------------------------------------------------------------------------- #include "stdafx.h" #include "dxstdafx.h" #include "dxutmesh.h" #include "resource.h" #include "VideoTest.h" #include "dxsdkver.h" #if ( _DXSDK_PRODUCT_MAJOR > 9 || _DXSDK_BUILD_MAJOR > 1350 ) #error The installed DXSDK is not compatible version. #endif //#define DEBUG_VS // Uncomment this line to debug vertex shaders //#define DEBUG_PS // Uncomment this line to debug pixel shaders #pragma comment(lib, "dxerr9.lib") #pragma comment(lib, "dxguid.lib") #pragma comment(lib, "d3dx9.lib") #pragma comment(lib, "d3d9.lib") #pragma comment(lib, "winmm.lib") #pragma comment(lib, "comctl32.lib") #pragma comment(lib, "dsound.lib") CVideoTest* g_videoTest = NULL; #define SHADOWMAP_SIZE 512 #define HELPTEXTCOLOR D3DXCOLOR( 0.0f, 1.0f, 0.3f, 1.0f ) LPCWSTR g_aszMeshFile[] = { L"data\\room.x", L"data\\airplane.x", L"data\\car.x", L"data\\sphere.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\arrow.x", L"data\\ring.x", L"data\\ring.x", L"data\\picture.x", }; #define NUM_OBJ (sizeof(g_aszMeshFile)/sizeof(g_aszMeshFile[0])) D3DXMATRIXA16 g_amInitObjWorld[NUM_OBJ] = { D3DXMATRIXA16( 3.5f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f ), D3DXMATRIXA16( 0.43301f, 0.25f, 0.0f, 0.0f, -0.25f, 0.43301f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 5.0f, 1.33975f, 0.0f, 1.0f ), D3DXMATRIXA16( 0.8f, 0.0f, 0.0f, 0.0f, 0.0f, 0.8f, 0.0f, 0.0f, 0.0f, 0.0f, 0.8f, 0.0f, -14.5f, -7.1f, 0.0f, 1.0f ), D3DXMATRIXA16( 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 0.0f, -7.0f, 0.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, 5.0f, 0.2f, 5.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, 5.0f, 0.2f, -5.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, -5.0f, 0.2f, 5.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, -5.0f, 0.2f, -5.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, 14.0f, 0.2f, 14.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, 14.0f, 0.2f, -14.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, -14.0f, 0.2f, 14.0f, 1.0f ), D3DXMATRIXA16( 5.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.5f, 0.0f, 0.0f, -9.0f, 0.0f, 0.0f, -14.0f, 0.2f, -14.0f, 1.0f ), D3DXMATRIXA16( 0.9f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9f, 0.0f, -14.5f, -9.0f, 0.0f, 1.0f ), D3DXMATRIXA16( 0.9f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9f, 0.0f, 14.5f, -9.0f, 0.0f, 1.0f ), D3DXMATRIXA16( 12.5f, 0.0f, 0.0f, 0.0f, 0.0f, 12.0f, 0.0f, 0.0f, 0.0f, 0.0f, 12.5f, 0.0f, 0.0f, 0.0f, 15.0f,1.0f ), }; D3DVERTEXELEMENT9 g_aVertDecl[] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, { 0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, D3DDECL_END() }; //----------------------------------------------------------------------------- // Name: class CObj // Desc: Encapsulates a mesh object in the scene by grouping its world matrix // with the mesh. //----------------------------------------------------------------------------- struct CObj { CDXUTMesh m_Mesh; D3DXMATRIXA16 m_mWorld; }; //----------------------------------------------------------------------------- // Name: class CViewCamera // Desc: A camera class derived from CFirstPersonCamera. The arrow keys and // numpad keys are disabled for this type of camera. //----------------------------------------------------------------------------- class CViewCamera : public CFirstPersonCamera { protected: virtual D3DUtil_CameraKeys MapKey( UINT nKey ) { // Provide custom mapping here. // Same as default mapping but disable arrow keys. switch( nKey ) { case 'A': return CAM_STRAFE_LEFT; case 'D': return CAM_STRAFE_RIGHT; case 'W': return CAM_MOVE_FORWARD; case 'S': return CAM_MOVE_BACKWARD; case 'Q': return CAM_MOVE_DOWN; case 'E': return CAM_MOVE_UP; case VK_HOME: return CAM_RESET; } return CAM_UNKNOWN; } }; //----------------------------------------------------------------------------- // Name: class CLightCamera // Desc: A camera class derived from CFirstPersonCamera. The letter keys // are disabled for this type of camera. This class is intended for use // by the spot light. //----------------------------------------------------------------------------- class CLightCamera : public CFirstPersonCamera { protected: virtual D3DUtil_CameraKeys MapKey( UINT nKey ) { // Provide custom mapping here. // Same as default mapping but disable arrow keys. switch( nKey ) { case VK_LEFT: return CAM_STRAFE_LEFT; case VK_RIGHT: return CAM_STRAFE_RIGHT; case VK_UP: return CAM_MOVE_FORWARD; case VK_DOWN: return CAM_MOVE_BACKWARD; case VK_PRIOR: return CAM_MOVE_UP; // pgup case VK_NEXT: return CAM_MOVE_DOWN; // pgdn case VK_NUMPAD4: return CAM_STRAFE_LEFT; case VK_NUMPAD6: return CAM_STRAFE_RIGHT; case VK_NUMPAD8: return CAM_MOVE_FORWARD; case VK_NUMPAD2: return CAM_MOVE_BACKWARD; case VK_NUMPAD9: return CAM_MOVE_UP; case VK_NUMPAD3: return CAM_MOVE_DOWN; case VK_HOME: return CAM_RESET; } return CAM_UNKNOWN; } }; //-------------------------------------------------------------------------------------- // Global variables //-------------------------------------------------------------------------------------- ID3DXFont* g_pFont = NULL; // Font for drawing text ID3DXFont* g_pFontSmall = NULL; // Font for drawing text ID3DXSprite* g_pTextSprite = NULL; // Sprite for batching draw text calls ID3DXEffect* g_pEffect = NULL; // D3DX effect interface bool g_bShowHelp = true; // If true, it renders the UI control text CDXUTDialog g_HUD; // dialog for standard controls CFirstPersonCamera g_VCamera; // View camera CFirstPersonCamera g_LCamera; // Camera obj to help adjust light CObj g_Obj[NUM_OBJ]; // Scene object meshes LPDIRECT3DVERTEXDECLARATION9 g_pVertDecl = NULL;// Vertex decl for the sample LPDIRECT3DTEXTURE9 g_pTexDef = NULL; // Default texture for objects D3DLIGHT9 g_Light; // The spot light in the scene CDXUTMesh g_LightMesh; LPDIRECT3DTEXTURE9 g_pShadowMap = NULL; // Texture to which the shadow map is rendered LPDIRECT3DSURFACE9 g_pDSShadow = NULL; // Depth-stencil buffer for rendering to shadow map float g_fLightFov; // FOV of the spot light (in radian) D3DXMATRIXA16 g_mShadowProj; // Projection matrix for shadow map bool g_bRightMouseDown = false;// Indicates whether right mouse button is held bool g_bCameraPerspective // Indicates whether we should render view from = true; // the camera's or the light's perspective bool g_bFreeLight = true; // Whether the light is freely moveable. //-------------------------------------------------------------------------------------- // UI control IDs //-------------------------------------------------------------------------------------- #define IDC_TOGGLEFULLSCREEN 1 #define IDC_TOGGLEREF 3 #define IDC_CHANGEDEVICE 4 #define IDC_CHECKBOX 5 #define IDC_LIGHTPERSPECTIVE 6 #define IDC_ATTACHLIGHTTOCAR 7 //-------------------------------------------------------------------------------------- // Forward declarations //-------------------------------------------------------------------------------------- void InitializeDialogs(); bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed ); void CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps ); HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc ); HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc ); void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime ); void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime ); void RenderText(); LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing ); void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown ); void CALLBACK MouseProc( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddleButtonDown, bool bSideButton1Down, bool bSideButton2Down, int nMouseWheelDelta, int xPos, int yPos ); void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl ); void CALLBACK OnLostDevice(); void CALLBACK OnDestroyDevice(); void RenderScene( IDirect3DDevice9* pd3dDevice, bool bRenderShadow, float fElapsedTime, const D3DXMATRIX *pmView, const D3DXMATRIX *pmProj ); //-------------------------------------------------------------------------------------- // Entry point to the program. Initializes everything and goes into a message processing // loop. Idle time is used to render the scene. //-------------------------------------------------------------------------------------- INT WINAPI WinMain( HINSTANCE hInstance, HINSTANCE, LPSTR, int ) { // Enable run-time memory check for debug builds. #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif // Initialize the camera g_VCamera.SetScalers( 0.01f, 15.0f ); g_LCamera.SetScalers( 0.01f, 8.0f ); g_VCamera.SetRotateButtons( true, false, false ); g_LCamera.SetRotateButtons( false, false, true ); // Set up the view parameters for the camera D3DXVECTOR3 vFromPt = D3DXVECTOR3( 0.0f, 5.0f, -18.0f ); D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, -1.0f, 0.0f ); g_VCamera.SetViewParams( &vFromPt, &vLookatPt ); vFromPt = D3DXVECTOR3( 0.0f, 0.0f, -12.0f ); vLookatPt = D3DXVECTOR3( 0.0f, -2.0f, 1.0f ); g_LCamera.SetViewParams( &vFromPt, &vLookatPt ); // Initialize the spot light g_fLightFov = D3DX_PI / 2.0f; g_Light.Diffuse.r = 1.0f; g_Light.Diffuse.g = 1.0f; g_Light.Diffuse.b = 1.0f; g_Light.Diffuse.a = 1.0f; g_Light.Position = D3DXVECTOR3( -8.0f, -8.0f, 0.0f ); g_Light.Direction = D3DXVECTOR3( 1.0f, -1.0f, 0.0f ); D3DXVec3Normalize( (D3DXVECTOR3*)&g_Light.Direction, (D3DXVECTOR3*)&g_Light.Direction ); g_Light.Range = 10.0f; g_Light.Theta = g_fLightFov / 2.0f; g_Light.Phi = g_fLightFov / 2.0f; // Set the callback functions. These functions allow the sample framework to notify // the application about device changes, user input, and windows messages. The // callbacks are optional so you need only set callbacks for events you're interested // in. However, if you don't handle the device reset/lost callbacks then the sample // framework won't be able to reset your device since the application must first // release all device resources before resetting. Likewise, if you don't handle the // device created/destroyed callbacks then the sample framework won't be able to // recreate your device resources. DXUTSetCallbackDeviceCreated( OnCreateDevice ); DXUTSetCallbackDeviceReset( OnResetDevice ); DXUTSetCallbackDeviceLost( OnLostDevice ); DXUTSetCallbackDeviceDestroyed( OnDestroyDevice ); DXUTSetCallbackMsgProc( MsgProc ); DXUTSetCallbackKeyboard( KeyboardProc ); DXUTSetCallbackMouse( MouseProc ); DXUTSetCallbackFrameRender( OnFrameRender ); DXUTSetCallbackFrameMove( OnFrameMove ); g_videoTest = new CVideoTest(); InitializeDialogs(); // Show the cursor and clip it when in full screen DXUTSetCursorSettings( true, true ); // Initialize the sample framework and create the desired Win32 window and Direct3D // device for the application. Calling each of these functions is optional, but they // allow you to set several options which control the behavior of the framework. DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes #if _WIN64 DXUTCreateWindow( L"BandiVidSample (64bit)" ); #else DXUTCreateWindow( L"BandiVidSample" ); #endif int screenw = ::GetSystemMetrics(SM_CXSCREEN); int width, height; if(screenw>=2560) { width = 1920; height = 1080; width = 1024; height = 768; } else { width = 1024; height = 768; } DXUTCreateDevice( D3DADAPTER_DEFAULT, true, width, height, IsDeviceAcceptable, ModifyDeviceSettings ); // init capture main g_videoTest->Init(hInstance, DXUTGetHWND()); // Pass control to the sample framework for handling the message pump and // dispatching render calls. The sample framework will call your FrameMove // and FrameRender callback when there is idle time between handling window messages. DXUTMainLoop(); // Perform any application-level cleanup here. Direct3D device resources are released within the // appropriate callback functions and therefore don't require any cleanup code here. int ret = DXUTGetExitCode(); g_videoTest->Close(); delete g_videoTest; g_videoTest = NULL; _ASSERTE( _CrtCheckMemory( ) ); return ret; } //-------------------------------------------------------------------------------------- // Sets up the dialogs //-------------------------------------------------------------------------------------- void InitializeDialogs() { g_HUD.SetCallback( OnGUIEvent ); int iY = 10; g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 35, iY, 125, 22 ); g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 35, iY += 24, 125, 22 ); g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 35, iY += 24, 125, 22 ); g_HUD.AddCheckBox( IDC_CHECKBOX, L"Display help text", 35, iY += 24, 125, 22, true, VK_F1 ); g_HUD.AddCheckBox( IDC_LIGHTPERSPECTIVE, L"View from light's perspective", 0, iY += 24, 160, 22, false, L'V' ); g_HUD.AddCheckBox( IDC_ATTACHLIGHTTOCAR, L"Attach light to car", 0, iY += 24, 160, 22, false, L'F' ); if(g_videoTest) g_videoTest->InitializeDialogs(iY); } //-------------------------------------------------------------------------------------- // Called during device initialization, this code checks the device for some // minimum set of capabilities, and rejects those that don't pass by returning false. //-------------------------------------------------------------------------------------- bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed ) { // Skip backbuffer formats that don't support alpha blending IDirect3D9* pD3D = DXUTGetD3DObject(); if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType, AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, BackBufferFormat ) ) ) return false; // Must support pixel shader 2.0 if( pCaps->PixelShaderVersion < D3DPS_VERSION( 2, 0 ) ) return false; // need to support D3DFMT_R32F render target if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType, AdapterFormat, D3DUSAGE_RENDERTARGET, D3DRTYPE_CUBETEXTURE, D3DFMT_R32F ) ) ) return false; // need to support D3DFMT_A8R8G8B8 render target if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType, AdapterFormat, D3DUSAGE_RENDERTARGET, D3DRTYPE_CUBETEXTURE, D3DFMT_A8R8G8B8 ) ) ) return false; return true; } //-------------------------------------------------------------------------------------- // This callback function is called immediately before a device is created to allow the // application to modify the device settings. The supplied pDeviceSettings parameter // contains the settings that the framework has selected for the new device, and the // application can make any desired changes directly to this structure. Note however that // the sample framework will not correct invalid device settings so care must be taken // to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail. //-------------------------------------------------------------------------------------- void CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps ) { // If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW // then switch to SWVP. if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 || pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) ) { pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING; } else { pDeviceSettings->BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING; } // This application is designed to work on a pure device by not using // IDirect3D9::Get*() methods, so create a pure device if supported and using HWVP. if ((pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE) != 0 && (pDeviceSettings->BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING) != 0 ) pDeviceSettings->BehaviorFlags |= D3DCREATE_PUREDEVICE; // Debugging vertex shaders requires either REF or software vertex processing // and debugging pixel shaders requires REF. #ifdef DEBUG_VS if( pDeviceSettings->DeviceType != D3DDEVTYPE_REF ) { pDeviceSettings->BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING; pDeviceSettings->BehaviorFlags &= ~D3DCREATE_PUREDEVICE; pDeviceSettings->BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; } #endif #ifdef DEBUG_PS pDeviceSettings->DeviceType = D3DDEVTYPE_REF; #endif pDeviceSettings->pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT; pDeviceSettings->pp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; pDeviceSettings->AdapterFormat; } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has been // created, which will happen during application initialization and windowed/full screen // toggles. This is the best location to create D3DPOOL_MANAGED resources since these // resources need to be reloaded whenever the device is destroyed. Resources created // here should be released in the OnDestroyDevice callback. //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc ) { HRESULT hr; // Initialize the font V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &g_pFont ) ); V_RETURN( D3DXCreateFont( pd3dDevice, 12, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &g_pFontSmall ) ); // Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the // shader debugger. Debugging vertex shaders requires either REF or software vertex // processing, and debugging pixel shaders requires REF. The // D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the // shader debugger. It enables source level debugging, prevents instruction // reordering, prevents dead code elimination, and forces the compiler to compile // against the next higher available software target, which ensures that the // unoptimized shaders do not exceed the shader model limitations. Setting these // flags will cause slower rendering since the shaders will be unoptimized and // forced into software. See the DirectX documentation for more information about // using the shader debugger. DWORD dwShaderFlags = 0; #ifdef DEBUG_VS dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT; #endif #ifdef DEBUG_PS dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT; #endif // Read the D3DX effect file WCHAR str[MAX_PATH]; V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"data\\ShadowMap.fx" ) ); // If this fails, there should be debug output as to // they the .fx file failed to compile /* V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) ); */ // DX10SDK 에서 컴파일 가능하도록 수정 if(FAILED(D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) )) { V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"data\\ShadowMap2.fx" ) ); V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) ); } // Create vertex declaration V_RETURN( pd3dDevice->CreateVertexDeclaration( g_aVertDecl, &g_pVertDecl ) ); // Initialize the meshes for( int i = 0; i < NUM_OBJ; ++i ) { V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, g_aszMeshFile[i] ) ); if( FAILED( g_Obj[i].m_Mesh.Create( pd3dDevice, str ) ) ) return DXUTERR_MEDIANOTFOUND; V_RETURN( g_Obj[i].m_Mesh.SetVertexDecl( pd3dDevice, g_aVertDecl ) ); g_Obj[i].m_mWorld = g_amInitObjWorld[i]; } // Initialize the light mesh V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"data\\spotlight.x" ) ); if( FAILED( g_LightMesh.Create( pd3dDevice, str ) ) ) return DXUTERR_MEDIANOTFOUND; V_RETURN( g_LightMesh.SetVertexDecl( pd3dDevice, g_aVertDecl ) ); // World transform to identity D3DXMATRIXA16 mIdent; D3DXMatrixIdentity( &mIdent ); V_RETURN( pd3dDevice->SetTransform( D3DTS_WORLD, &mIdent ) ); if(g_videoTest) g_videoTest->OnD3D9CreateDevice(pd3dDevice, pBackBufferSurfaceDesc); return S_OK; } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has been // reset, which will happen after a lost device scenario. This is the best location to // create D3DPOOL_DEFAULT resources since these resources need to be reloaded whenever // the device is lost. Resources created here should be released in the OnLostDevice // callback. //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc ) { HRESULT hr; if( g_pFont ) V_RETURN( g_pFont->OnResetDevice() ); if( g_pFontSmall ) V_RETURN( g_pFontSmall->OnResetDevice() ); if( g_pEffect ) V_RETURN( g_pEffect->OnResetDevice() ); // Create a sprite to help batch calls when drawing many lines of text V_RETURN( D3DXCreateSprite( pd3dDevice, &g_pTextSprite ) ); // Setup the camera's projection parameters float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height; g_VCamera.SetProjParams( D3DX_PI/4, fAspectRatio, 0.1f, 100.0f ); g_LCamera.SetProjParams( D3DX_PI/4, fAspectRatio, 0.1f, 100.0f ); // Create the default texture (used when a triangle does not use a texture) V_RETURN( pd3dDevice->CreateTexture( 1, 1, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTexDef, NULL ) ); D3DLOCKED_RECT lr; V_RETURN( g_pTexDef->LockRect( 0, &lr, NULL, 0 ) ); *(LPDWORD)lr.pBits = D3DCOLOR_RGBA( 255, 255, 255, 255 ); V_RETURN( g_pTexDef->UnlockRect( 0 ) ); // Restore the scene objects for( int i = 0; i < NUM_OBJ; ++i ) V_RETURN( g_Obj[i].m_Mesh.RestoreDeviceObjects( pd3dDevice ) ); V_RETURN( g_LightMesh.RestoreDeviceObjects( pd3dDevice ) ); // Restore the effect variables V_RETURN( g_pEffect->SetVector( "g_vLightDiffuse", (D3DXVECTOR4 *)&g_Light.Diffuse ) ); V_RETURN( g_pEffect->SetFloat( "g_fCosTheta", cosf( g_Light.Theta ) ) ); // Create the shadow map texture V_RETURN( pd3dDevice->CreateTexture( SHADOWMAP_SIZE, SHADOWMAP_SIZE, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R32F, D3DPOOL_DEFAULT, &g_pShadowMap, NULL ) ); // Create the depth-stencil buffer to be used with the shadow map // We do this to ensure that the depth-stencil buffer is large // enough and has correct multisample type/quality when rendering // the shadow map. The default depth-stencil buffer created during // device creation will not be large enough if the user resizes the // window to a very small size. Furthermore, if the device is created // with multisampling, the default depth-stencil buffer will not // work with the shadow map texture because texture render targets // do not support multisample. DXUTDeviceSettings d3dSettings = DXUTGetDeviceSettings(); V_RETURN( pd3dDevice->CreateDepthStencilSurface( SHADOWMAP_SIZE, SHADOWMAP_SIZE, d3dSettings.pp.AutoDepthStencilFormat, D3DMULTISAMPLE_NONE, 0, TRUE, &g_pDSShadow, NULL ) ); // Initialize the shadow projection matrix D3DXMatrixPerspectiveFovLH( &g_mShadowProj, g_fLightFov, 1, 0.01f, 100.0f); g_HUD.SetLocation( pBackBufferSurfaceDesc->Width-170, 0 ); g_HUD.SetSize( 170, pBackBufferSurfaceDesc->Height ); CDXUTControl *pControl = g_HUD.GetControl( IDC_LIGHTPERSPECTIVE ); if( pControl ) pControl->SetLocation( 0, pBackBufferSurfaceDesc->Height - 50 ); pControl = g_HUD.GetControl( IDC_ATTACHLIGHTTOCAR ); if( pControl ) pControl->SetLocation( 0, pBackBufferSurfaceDesc->Height - 25 ); if(g_videoTest) g_videoTest->OnD3D9ResetDevice(pd3dDevice, pBackBufferSurfaceDesc); return S_OK; } //-------------------------------------------------------------------------------------- // This callback function will be called once at the beginning of every frame. This is the // best location for your application to handle updates to the scene, but is not // intended to contain actual rendering calls, which should instead be placed in the // OnFrameRender callback. //-------------------------------------------------------------------------------------- void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime ) { // Update the camera's position based on user input g_VCamera.FrameMove( fElapsedTime ); g_LCamera.FrameMove( fElapsedTime ); // Animate the plane, car and sphere meshes D3DXMATRIXA16 m; D3DXMatrixRotationY( &m, D3DX_PI * fElapsedTime / 4.0f ); D3DXMatrixMultiply( &g_Obj[1].m_mWorld, &g_Obj[1].m_mWorld, &m ); D3DXMatrixRotationY( &m, -D3DX_PI * fElapsedTime / 4.0f ); D3DXMatrixMultiply( &g_Obj[2].m_mWorld, &g_Obj[2].m_mWorld, &m ); D3DXVECTOR3 vR( 0.1f, 1.0f, -0.2f ); D3DXMatrixRotationAxis( &m, &vR, -D3DX_PI * fElapsedTime / 6.0f ); D3DXMatrixMultiply( &g_Obj[3].m_mWorld, &m, &g_Obj[3].m_mWorld ); if(g_videoTest) g_videoTest->OnFrameMove(fTime, fElapsedTime ); } //-------------------------------------------------------------------------------------- // Renders the scene onto the current render target using the current // technique in the effect. //-------------------------------------------------------------------------------------- void RenderScene( IDirect3DDevice9* pd3dDevice, bool bRenderShadow, float fElapsedTime, const D3DXMATRIX *pmView, const D3DXMATRIX *pmProj ) { HRESULT hr; // Set the projection matrix V( g_pEffect->SetMatrix( "g_mProj", pmProj ) ); // Update the light parameters in the effect if( g_bFreeLight ) { // Freely moveable light. Get light parameter // from the light camera. D3DXVECTOR3 v = *g_LCamera.GetEyePt(); D3DXVECTOR4 v4; D3DXVec3Transform( &v4, &v, pmView ); V( g_pEffect->SetVector( "g_vLightPos", &v4 ) ); *(D3DXVECTOR3*)&v4 = *g_LCamera.GetWorldAhead(); v4.w = 0.0f; // Set w 0 so that the translation part doesn't come to play D3DXVec4Transform( &v4, &v4, pmView ); // Direction in view space D3DXVec3Normalize( (D3DXVECTOR3*)&v4, (D3DXVECTOR3*)&v4 ); V( g_pEffect->SetVector( "g_vLightDir", &v4 ) ); } else { // Light attached to car. Get the car's world position and direction. D3DXMATRIXA16 m = g_Obj[2].m_mWorld; D3DXVECTOR3 v( m._41, m._42, m._43 ); D3DXVECTOR4 vPos; D3DXVec3Transform( &vPos, &v, pmView ); D3DXVECTOR4 v4( 0.0f, 0.0f, -1.0f, 1.0f ); // In object space, car is facing -Z m._41 = m._42 = m._43 = 0.0f; // Remove the translation D3DXVec4Transform( &v4, &v4, &m ); // Obtain direction in world space v4.w = 0.0f; // Set w 0 so that the translation part doesn't come to play D3DXVec4Transform( &v4, &v4, pmView ); // Direction in view space D3DXVec3Normalize( (D3DXVECTOR3*)&v4, (D3DXVECTOR3*)&v4 ); V( g_pEffect->SetVector( "g_vLightDir", &v4 ) ); vPos += v4 * 4.0f; // Offset the center by 3 so that it's closer to the headlight. V( g_pEffect->SetVector( "g_vLightPos", &vPos ) ); } // Clear the render buffers V( pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x000000ff, 1.0f, 0L ) ); if( bRenderShadow ) V( g_pEffect->SetTechnique( "RenderShadow" ) ); // Begin the scene if( SUCCEEDED( pd3dDevice->BeginScene() ) ) { if( !bRenderShadow ) V( g_pEffect->SetTechnique( "RenderScene" ) ); // Render the objects for( int obj = 0; obj < NUM_OBJ; ++obj ) { D3DXMATRIXA16 mWorldView = g_Obj[obj].m_mWorld; D3DXMatrixMultiply( &mWorldView, &mWorldView, pmView ); V( g_pEffect->SetMatrix( "g_mWorldView", &mWorldView ) ); LPD3DXMESH pMesh = g_Obj[obj].m_Mesh.GetLocalMesh(); UINT cPass; V( g_pEffect->Begin( &cPass, 0 ) ); for( UINT p = 0; p < cPass; ++p ) { V( g_pEffect->BeginPass( p ) ); for( DWORD i = 0; i < g_Obj[obj].m_Mesh.m_dwNumMaterials; ++i ) { D3DXVECTOR4 vDif( g_Obj[obj].m_Mesh.m_pMaterials[i].Diffuse.r, g_Obj[obj].m_Mesh.m_pMaterials[i].Diffuse.g, g_Obj[obj].m_Mesh.m_pMaterials[i].Diffuse.b, g_Obj[obj].m_Mesh.m_pMaterials[i].Diffuse.a ); V( g_pEffect->SetVector( "g_vMaterial", &vDif ) ); if( g_Obj[obj].m_Mesh.m_pTextures[i] ) { if( (obj==NUM_OBJ-1) && (i==2) && g_videoTest ) { LPDIRECT3DTEXTURE9 texture = g_videoTest->GetVideoTexture(); V( g_pEffect->SetTexture( "g_txScene", texture ? texture : g_pTexDef ) ) } else { V( g_pEffect->SetTexture( "g_txScene", g_Obj[obj].m_Mesh.m_pTextures[i] ) ) } } else V( g_pEffect->SetTexture( "g_txScene", g_pTexDef ) ) V( g_pEffect->CommitChanges() ); V( pMesh->DrawSubset( i ) ); } V( g_pEffect->EndPass() ); } V( g_pEffect->End() ); } // Render light if( !bRenderShadow ) V( g_pEffect->SetTechnique( "RenderLight" ) ); D3DXMATRIXA16 mWorldView = *g_LCamera.GetWorldMatrix(); D3DXMatrixMultiply( &mWorldView, &mWorldView, pmView ); V( g_pEffect->SetMatrix( "g_mWorldView", &mWorldView ) ); UINT cPass; LPD3DXMESH pMesh = g_LightMesh.GetLocalMesh(); V( g_pEffect->Begin( &cPass, 0 ) ); for( UINT p = 0; p < cPass; ++p ) { V( g_pEffect->BeginPass( p ) ); for( DWORD i = 0; i < g_LightMesh.m_dwNumMaterials; ++i ) { D3DXVECTOR4 vDif( g_LightMesh.m_pMaterials[i].Diffuse.r, g_LightMesh.m_pMaterials[i].Diffuse.g, g_LightMesh.m_pMaterials[i].Diffuse.b, g_LightMesh.m_pMaterials[i].Diffuse.a ); V( g_pEffect->SetVector( "g_vMaterial", &vDif ) ); V( g_pEffect->SetTexture( "g_txScene", g_LightMesh.m_pTextures[i] ) ); V( g_pEffect->CommitChanges() ); V( pMesh->DrawSubset( i ) ); } V( g_pEffect->EndPass() ); } V( g_pEffect->End() ); if( !bRenderShadow ) // Render stats and help text RenderText(); // Render the UI elements if( !bRenderShadow ) g_HUD.OnRender( fElapsedTime ); V( pd3dDevice->EndScene() ); } } //-------------------------------------------------------------------------------------- // This callback function will be called at the end of every frame to perform all the // rendering calls for the scene, and it will also be called if the window needs to be // repainted. After this function has returned, the sample framework will call // IDirect3DDevice9::Present to display the contents of the next buffer in the swap chain //-------------------------------------------------------------------------------------- void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime ) { HRESULT hr; // // Compute the view matrix for the light // This changes depending on the light mode // (free movement or attached) // D3DXMATRIXA16 mLightView; if( g_bFreeLight ) mLightView = *g_LCamera.GetViewMatrix(); else { // Light attached to car. mLightView = g_Obj[2].m_mWorld; D3DXVECTOR3 vPos( mLightView._41, mLightView._42, mLightView._43 ); // Offset z by -2 so that it's closer to headlight D3DXVECTOR4 vDir = D3DXVECTOR4( 0.0f, 0.0f, -1.0f, 1.0f ); // In object space, car is facing -Z mLightView._41 = mLightView._42 = mLightView._43 = 0.0f; // Remove the translation D3DXVec4Transform( &vDir, &vDir, &mLightView ); // Obtain direction in world space vDir.w = 0.0f; // Set w 0 so that the translation part below doesn't come to play D3DXVec4Normalize( &vDir, &vDir ); vPos.x += vDir.x * 4.0f; // Offset the center by 4 so that it's closer to the headlight vPos.y += vDir.y * 4.0f; vPos.z += vDir.z * 4.0f; vDir.x += vPos.x; // vDir denotes the look-at point vDir.y += vPos.y; vDir.z += vPos.z; D3DXVECTOR3 vUp( 0.0f, 1.0f, 0.0f ); D3DXMatrixLookAtLH( &mLightView, &vPos, (D3DXVECTOR3*)&vDir, &vUp ); } // // Render the shadow map // LPDIRECT3DSURFACE9 pOldRT = NULL; V( pd3dDevice->GetRenderTarget( 0, &pOldRT ) ); LPDIRECT3DSURFACE9 pShadowSurf; if( SUCCEEDED( g_pShadowMap->GetSurfaceLevel( 0, &pShadowSurf ) ) ) { pd3dDevice->SetRenderTarget( 0, pShadowSurf ); SAFE_RELEASE( pShadowSurf ); } LPDIRECT3DSURFACE9 pOldDS = NULL; if( SUCCEEDED( pd3dDevice->GetDepthStencilSurface( &pOldDS ) ) ) pd3dDevice->SetDepthStencilSurface( g_pDSShadow ); { CDXUTPerfEventGenerator g( DXUT_PERFEVENTCOLOR, L"Shadow Map" ); RenderScene( pd3dDevice, true, fElapsedTime, &mLightView, &g_mShadowProj ); } if( pOldDS ) { pd3dDevice->SetDepthStencilSurface( pOldDS ); pOldDS->Release(); } pd3dDevice->SetRenderTarget( 0, pOldRT ); SAFE_RELEASE( pOldRT ); // // Now that we have the shadow map, render the scene. // const D3DXMATRIX *pmView = g_bCameraPerspective ? g_VCamera.GetViewMatrix() : &mLightView; // Initialize required parameter V( g_pEffect->SetTexture( "g_txShadow", g_pShadowMap ) ); // Compute the matrix to transform from view space to // light projection space. This consists of // the inverse of view matrix * view matrix of light * light projection matrix D3DXMATRIXA16 mViewToLightProj; mViewToLightProj = *pmView; D3DXMatrixInverse( &mViewToLightProj, NULL, &mViewToLightProj ); D3DXMatrixMultiply( &mViewToLightProj, &mViewToLightProj, &mLightView ); D3DXMatrixMultiply( &mViewToLightProj, &mViewToLightProj, &g_mShadowProj ); V( g_pEffect->SetMatrix( "g_mViewToLightProj", &mViewToLightProj ) ); { CDXUTPerfEventGenerator g( DXUT_PERFEVENTCOLOR, L"Scene" ); RenderScene( pd3dDevice, false, fElapsedTime, pmView, g_VCamera.GetProjMatrix() ); } g_pEffect->SetTexture( "g_txShadow", NULL ); // Begin the scene if( g_videoTest && SUCCEEDED( pd3dDevice->BeginScene() ) ) { g_videoTest->RenderScene(pd3dDevice); V( pd3dDevice->EndScene() ); } } //-------------------------------------------------------------------------------------- // Render the help and statistics text. This function uses the ID3DXFont interface for // efficient text rendering. //-------------------------------------------------------------------------------------- void RenderText() { // The helper object simply helps keep track of text position, and color // and then it calls pFont->DrawText( m_pSprite, strMsg, -1, &rc, DT_NOCLIP, m_clr ); // If NULL is passed in as the sprite object, then it will work however the // pFont->DrawText() will not be batched together. Batching calls will improves performance. CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite, 15 ); // Output statistics txtHelper.Begin(); txtHelper.SetInsertionPos( 5, 5 ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) ); txtHelper.DrawTextLine( DXUTGetFrameStats() ); txtHelper.DrawTextLine( DXUTGetDeviceStats() ); g_videoTest->RenderText(txtHelper); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) ); // Draw help if( g_bShowHelp ) { const D3DSURFACE_DESC* pd3dsdBackBuffer = DXUTGetBackBufferSurfaceDesc(); txtHelper.SetInsertionPos( 10, pd3dsdBackBuffer->Height-15*10 ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 0.75f, 0.0f, 1.0f ) ); txtHelper.DrawTextLine( L"Controls:" ); txtHelper.SetInsertionPos( 15, pd3dsdBackBuffer->Height-15*9 ); txtHelper.DrawFormattedTextLine( L"Rotate camera\nMove camera\n" L"Rotate light\nMove light\n" L"Change light mode (Current: %s)\nChange view reference (Current: %s)\n" L"Hidehelp\nQuit", g_bFreeLight ? L"Free" : L"Car-attached", g_bCameraPerspective ? L"Camera" : L"Light" ); txtHelper.SetInsertionPos( 265, pd3dsdBackBuffer->Height-15*9 ); txtHelper.DrawTextLine( L"Left drag mouse\nW,S,A,D,Q,E\n" L"Right drag mouse\nW,S,A,D,Q,E while holding right mouse\n" L"F\nV\nF1\nESC" ); } else { txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) ); txtHelper.DrawTextLine( L"Press F1 for help" ); } txtHelper.End(); } //-------------------------------------------------------------------------------------- // Before handling window messages, the sample framework passes incoming windows // messages to the application through this callback function. If the application sets // *pbNoFurtherProcessing to TRUE, then the sample framework will not process this message. //-------------------------------------------------------------------------------------- LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing ) { *pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam ); if( *pbNoFurtherProcessing ) return 0; // Pass all windows messages to camera and dialogs so they can respond to user input if( WM_KEYDOWN != uMsg || g_bRightMouseDown ) g_LCamera.HandleMessages( hWnd, uMsg, wParam, lParam ); if( WM_KEYDOWN != uMsg || !g_bRightMouseDown ) { if( g_bCameraPerspective ) g_VCamera.HandleMessages( hWnd, uMsg, wParam, lParam ); else g_LCamera.HandleMessages( hWnd, uMsg, wParam, lParam ); } if(g_videoTest) g_videoTest->MsgProc(hWnd, uMsg, wParam, lParam,pbNoFurtherProcessing); return 0; } //-------------------------------------------------------------------------------------- // As a convenience, the sample framework inspects the incoming windows messages for // keystroke messages and decodes the message parameters to pass relevant keyboard // messages to the application. The framework does not remove the underlying keystroke // messages, which are still passed to the application's MsgProc callback. //-------------------------------------------------------------------------------------- void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown ) { } void CALLBACK MouseProc( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddleButtonDown, bool bSideButton1Down, bool bSideButton2Down, int nMouseWheelDelta, int xPos, int yPos ) { g_bRightMouseDown = bRightButtonDown; } //-------------------------------------------------------------------------------------- // Handles the GUI events //-------------------------------------------------------------------------------------- void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl ) { switch( nControlID ) { case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break; case IDC_TOGGLEREF: DXUTToggleREF(); break; case IDC_CHANGEDEVICE: DXUTSetShowSettingsDialog( !DXUTGetShowSettingsDialog() ); break; case IDC_CHECKBOX: { CDXUTCheckBox *pCheck = (CDXUTCheckBox *)pControl; g_bShowHelp = pCheck->GetChecked(); break; } case IDC_LIGHTPERSPECTIVE: { CDXUTCheckBox *pCheck = (CDXUTCheckBox *)pControl; g_bCameraPerspective = !pCheck->GetChecked(); if( g_bCameraPerspective ) { g_VCamera.SetRotateButtons( true, false, false ); g_LCamera.SetRotateButtons( false, false, true ); } else { g_VCamera.SetRotateButtons( false, false, false ); g_LCamera.SetRotateButtons( true, false, true ); } break; } case IDC_ATTACHLIGHTTOCAR: { CDXUTCheckBox *pCheck = (CDXUTCheckBox *)pControl; g_bFreeLight = !pCheck->GetChecked(); break; } default : if(g_videoTest) g_videoTest->OnGUIEvent(nEvent, nControlID, pControl); break; } } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has // entered a lost state and before IDirect3DDevice9::Reset is called. Resources created // in the OnResetDevice callback should be released here, which generally includes all // D3DPOOL_DEFAULT resources. See the "Lost Devices" section of the documentation for // information about lost devices. //-------------------------------------------------------------------------------------- void CALLBACK OnLostDevice() { if( g_pFont ) g_pFont->OnLostDevice(); if( g_pFontSmall ) g_pFontSmall->OnLostDevice(); if( g_pEffect ) g_pEffect->OnLostDevice(); SAFE_RELEASE(g_pTextSprite); SAFE_RELEASE( g_pDSShadow ); SAFE_RELEASE( g_pShadowMap ); SAFE_RELEASE( g_pTexDef ); for( int i = 0; i < NUM_OBJ; ++i ) g_Obj[i].m_Mesh.InvalidateDeviceObjects(); g_LightMesh.InvalidateDeviceObjects(); if(g_videoTest) g_videoTest->OnD3D9LostDevice(); } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has // been destroyed, which generally happens as a result of application termination or // windowed/full screen toggles. Resources created in the OnCreateDevice callback // should be released here, which generally includes all D3DPOOL_MANAGED resources. //-------------------------------------------------------------------------------------- void CALLBACK OnDestroyDevice() { SAFE_RELEASE( g_pEffect ); SAFE_RELEASE( g_pFont ); SAFE_RELEASE( g_pFontSmall ); SAFE_RELEASE( g_pVertDecl ); SAFE_RELEASE( g_pEffect ); for( int i = 0; i < NUM_OBJ; ++i ) g_Obj[i].m_Mesh.Destroy(); g_LightMesh.Destroy(); if(g_videoTest) g_videoTest->OnD3D9DestroyDevice(); }