spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//-------------------------------------------------------------------------------------- 
// File: SimpleSample11.cpp 
// 
// Starting point for new Direct3D 11 samples. For a more basic starting point, 
// use the EmptyProject11 sample instead. 
// 
// Copyright (c) Microsoft Corporation. All rights reserved. 

//-------------------------------------------------------------------------------------- 
#include "DXUT.h" 
#include "DXUTgui.h" 
#include "DXUTmisc.h" 
#include "DXUTCamera.h" 
#include "DXUTSettingsDlg.h" 
#include "SDKmisc.h" 
#include "SDKmesh.h" 
#include "resource.h" 
#include "d3dx11effect.h" 

//#define DEBUG_VS // Uncomment this line to debug D3D9 vertex shaders 
//#define DEBUG_PS // Uncomment this line to debug D3D9 pixel shaders 

//-------------------------------------------------------------------------------------- 
// Global variables 
//-------------------------------------------------------------------------------------- 
CModelViewerCamera g_Camera; // A model viewing camera 
CDXUTDialogResourceManager g_DialogResourceManager; // manager for shared resources of dialogs 
CD3DSettingsDlg g_SettingsDlg; // Device settings dialog 
CDXUTTextHelper* g_pTxtHelper = NULL; 
CDXUTDialog g_HUD; // dialog for standard controls 
CDXUTDialog g_SampleUI; // dialog for sample specific controls 

// Direct3D 9 resources 
extern ID3DXFont* g_pFont9; 
extern ID3DXSprite* g_pSprite9; 

// Direct3D 11 resources 
ID3D11VertexShader* g_pVertexShader11 = NULL; 
ID3D11PixelShader* g_pPixelShader11 = NULL; 
ID3D11InputLayout* g_pLayout11 = NULL; 
ID3D11SamplerState* g_pSamLinear = NULL; 


//------------------------------------------------------------------------------------- 
//Eigene 
//------------------------------------------------------------------------------------- 
//Effekt und Technique 
ID3DX11Effect*    g_pEffect = NULL; 
ID3DX11EffectTechnique*    g_pTechnique = NULL; 


//Effektvariablen 
ID3DX11EffectMatrixVariable* g_pmWorldViewProj = NULL; 
ID3DX11EffectMatrixVariable* g_pmWorld = NULL; 

//Material 
ID3DX11EffectVectorVariable* g_pDiffuseVariable = NULL; 

//Textur 
ID3D11ShaderResourceView* g_pRV = NULL; 
ID3DX11EffectShaderResourceVariable* g_ptxDiffuseVariable = NULL; 

//Licht 
ID3DX11EffectVectorVariable* g_pLightDirVariable = NULL; 
ID3DX11EffectVectorVariable* g_pLightDiffuseVariable = NULL; 
ID3DX11EffectVectorVariable* g_pAmbientVariable = NULL; 

//Anderes 
D3DXMATRIX g_mWorld; 
CDXUTSDKMesh    g_Mesh; 
//-------------------------------------------------------------------------------------- 
// Constant buffers 
//-------------------------------------------------------------------------------------- 
#pragma pack(push,1) 
struct CB_VS_PER_OBJECT 
{ 
D3DXMATRIX m_mWorldViewProjection; 
D3DXMATRIX m_mWorld; 
D3DXVECTOR4 m_MaterialAmbientColor; 
D3DXVECTOR4 m_MaterialDiffuseColor; 
}; 

struct CB_VS_PER_FRAME 
{ 
D3DXVECTOR3 m_vLightDir; 
float m_fTime; 
D3DXVECTOR4 m_LightDiffuse; 
}; 
#pragma pack(pop) 

ID3D11Buffer* g_pcbVSPerObject11 = NULL; 
ID3D11Buffer* g_pcbVSPerFrame11 = NULL; 

//-------------------------------------------------------------------------------------- 
// UI control IDs 
//-------------------------------------------------------------------------------------- 
#define IDC_TOGGLEFULLSCREEN 1 
#define IDC_TOGGLEREF 2 
#define IDC_CHANGEDEVICE 3 


//-------------------------------------------------------------------------------------- 
// Forward declarations 
//-------------------------------------------------------------------------------------- 
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, 
void* pUserContext ); 
void CALLBACK OnKeyboard( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext ); 
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext ); 
void CALLBACK OnFrameMove( double fTime, float fElapsedTime, void* pUserContext ); 
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, void* pUserContext ); 



bool CALLBACK IsD3D11DeviceAcceptable( const CD3D11EnumAdapterInfo *AdapterInfo, UINT Output, const CD3D11EnumDeviceInfo *DeviceInfo, 
DXGI_FORMAT BackBufferFormat, bool bWindowed, void* pUserContext ); 
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, 
void* pUserContext ); 
HRESULT CALLBACK OnD3D11ResizedSwapChain( ID3D11Device* pd3dDevice, IDXGISwapChain* pSwapChain, 
const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ); 
void CALLBACK OnD3D11ReleasingSwapChain( void* pUserContext ); 
void CALLBACK OnD3D11DestroyDevice( void* pUserContext ); 
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime, 
float fElapsedTime, void* pUserContext ); 

void InitApp(); 
void RenderText(); 


//-------------------------------------------------------------------------------------- 
// Entry point to the program. Initializes everything and goes into a message processing 
// loop. Idle time is used to render the scene. 
//-------------------------------------------------------------------------------------- 
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow ) 
{ 
// Enable run-time memory check for debug builds. 
#if defined(DEBUG) | defined(_DEBUG) 
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); 
#endif 

// DXUT will create and use the best device (either D3D9 or D3D11) 
// that is available on the system depending on which D3D callbacks are set below 

// Set DXUT callbacks 
DXUTSetCallbackMsgProc( MsgProc ); 
DXUTSetCallbackKeyboard( OnKeyboard ); 
DXUTSetCallbackFrameMove( OnFrameMove ); 
DXUTSetCallbackDeviceChanging( ModifyDeviceSettings ); 

DXUTSetCallbackD3D11DeviceAcceptable( IsD3D11DeviceAcceptable ); 
DXUTSetCallbackD3D11DeviceCreated( OnD3D11CreateDevice ); 
DXUTSetCallbackD3D11SwapChainResized( OnD3D11ResizedSwapChain ); 
DXUTSetCallbackD3D11SwapChainReleasing( OnD3D11ReleasingSwapChain ); 
DXUTSetCallbackD3D11DeviceDestroyed( OnD3D11DestroyDevice ); 
DXUTSetCallbackD3D11FrameRender( OnD3D11FrameRender ); 

InitApp(); 
DXUTInit( true, true, NULL ); // Parse the command line, show msgboxes on error, no extra command line params 
DXUTSetCursorSettings( true, true ); 
DXUTCreateWindow( L"SimpleSample11" ); 

// Only require 10-level hardware, change to D3D_FEATURE_LEVEL_11_0 to require 11-class hardware 
// Switch to D3D_FEATURE_LEVEL_9_x for 10level9 hardware 
DXUTCreateDevice( D3D_FEATURE_LEVEL_10_0, true, 640, 480 ); 

DXUTMainLoop(); // Enter into the DXUT render loop 

return DXUTGetExitCode(); 
} 


//-------------------------------------------------------------------------------------- 
// Initialize the app 
//-------------------------------------------------------------------------------------- 
void InitApp() 
{ 
g_SettingsDlg.Init( &g_DialogResourceManager ); 
g_HUD.Init( &g_DialogResourceManager ); 
g_SampleUI.Init( &g_DialogResourceManager ); 

g_HUD.SetCallback( OnGUIEvent ); 
int iY = 30; 
int iYo = 26; 
g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 0, iY, 170, 22 ); 
g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 0, iY += iYo, 170, 22, VK_F3 ); 
g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 0, iY += iYo, 170, 22, VK_F2 ); 

g_SampleUI.SetCallback( OnGUIEvent ); iY = 10; 
} 


//-------------------------------------------------------------------------------------- 
// Render the help and statistics text. This function uses the ID3DXFont interface for 
// efficient text rendering. 
//-------------------------------------------------------------------------------------- 
void RenderText() 
{ 
g_pTxtHelper->Begin(); 
g_pTxtHelper->SetInsertionPos( 5, 5 ); 
g_pTxtHelper->SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) ); 
g_pTxtHelper->DrawTextLine( DXUTGetFrameStats( DXUTIsVsyncEnabled() ) ); 
g_pTxtHelper->DrawTextLine( DXUTGetDeviceStats() ); 
g_pTxtHelper->End(); 
} 


//-------------------------------------------------------------------------------------- 
// Reject any D3D11 devices that aren't acceptable by returning false 
//-------------------------------------------------------------------------------------- 
bool CALLBACK IsD3D11DeviceAcceptable( const CD3D11EnumAdapterInfo *AdapterInfo, UINT Output, const CD3D11EnumDeviceInfo *DeviceInfo, 
DXGI_FORMAT BackBufferFormat, bool bWindowed, void* pUserContext ) 
{ 
return true; 
} 


//-------------------------------------------------------------------------------------- 
// Create any D3D11 resources that aren't dependant on the back buffer 
//-------------------------------------------------------------------------------------- 
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, 
void* pUserContext ) 
{ 
HRESULT hr; 

ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); 
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); 
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); 
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); 

// Read the HLSL file 
WCHAR str[MAX_PATH]; 
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"SimpleSample.hlsl" ) ); 

// Compile the shaders 
DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS; 
#if defined( DEBUG ) || defined( _DEBUG ) 
// Set the D3DCOMPILE_DEBUG flag to embed debug information in the shaders. 
// Setting this flag improves the shader debugging experience, but still allows 
// the shaders to be optimized and to run exactly the way they will run in 
// the release configuration of this program. 
dwShaderFlags |= D3DCOMPILE_DEBUG; 
#endif 

// You should use the lowest possible shader profile for your shader to enable various feature levels. These 
// shaders are simple enough to work well within the lowest possible profile, and will run on all feature levels 


ID3DBlob* pBlob = NULL; 
V_RETURN( D3DX11CompileFromFile( str, NULL, NULL, "", "fx_5_0", dwShaderFlags, 0, NULL, 
&pBlob, NULL, NULL ) ); 

ID3DBlob* pPixelShaderBuffer = NULL; 
    V_RETURN( D3DX11CreateEffectFromMemory( pBlob->GetBufferPointer(), pBlob->GetBufferSize(), dwShaderFlags, pd3dDevice, &g_pEffect)); 



    //Effektvariablen 
    g_pmWorldViewProj = g_pEffect-> 
        GetVariableByName("g_mWorldViewProjection")->AsMatrix(); 
    g_pmWorld = g_pEffect->GetVariableByName("g_mWorld")->AsMatrix(); 

    //Licht 
    g_pLightDirVariable = g_pEffect->GetVariableByName("g_vLightDir")->AsVector(); 
    g_pLightDiffuseVariable = g_pEffect->GetVariableByName("g_LightDiffuse")-> 
        AsVector(); 

    //Material 
    g_pAmbientVariable = g_pEffect->GetVariableByName("g_MaterialAmbientColor")-> 
        AsVector(); 
    g_pDiffuseVariable = g_pEffect->GetVariableByName("g_MaterialDiffuseColor")-> 
        AsVector(); 

    //Textur 
DXUTFindDXSDKMediaFileCch(str, MAX_PATH, L"Genetica\\Born to Rule.jpg"); 
    DXUTGetGlobalResourceCache().CreateTextureFromFile(pd3dDevice, pd3dImmediateContext, 
str, &g_pRV); 
    g_ptxDiffuseVariable = g_pEffect->GetVariableByName("g_txDiffuse")-> 
        AsShaderResource(); 

    //Technique 
    g_pTechnique = g_pEffect->GetTechniqueByName("RenderScene"); 


//Vertexlayout 
    const D3D11_INPUT_ELEMENT_DESC layout[] = 
    { 
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, 
        D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
        { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, 
        D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, 
        D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
    }; 

// No longer need the shader blobs 
SAFE_RELEASE( pPixelShaderBuffer ); 

// Create state objects 
D3D11_SAMPLER_DESC samDesc; 
ZeroMemory( &samDesc, sizeof(samDesc) ); 
samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; 
samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; 
samDesc.MaxAnisotropy = 1; 
samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; 
samDesc.MaxLOD = D3D11_FLOAT32_MAX; 
V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSamLinear ) ); 
DXUT_SetDebugName( g_pSamLinear, "Linear" ); 

// Create constant buffers 
D3D11_BUFFER_DESC cbDesc; 
ZeroMemory( &cbDesc, sizeof(cbDesc) ); 
cbDesc.Usage = D3D11_USAGE_DYNAMIC; 
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; 
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; 

cbDesc.ByteWidth = sizeof( CB_VS_PER_OBJECT ); 
V_RETURN( pd3dDevice->CreateBuffer( &cbDesc, NULL, &g_pcbVSPerObject11 ) ); 
DXUT_SetDebugName( g_pcbVSPerObject11, "CB_VS_PER_OBJECT" ); 

cbDesc.ByteWidth = sizeof( CB_VS_PER_FRAME ); 
V_RETURN( pd3dDevice->CreateBuffer( &cbDesc, NULL, &g_pcbVSPerFrame11 ) ); 
DXUT_SetDebugName( g_pcbVSPerFrame11, "CB_VS_PER_FRAME" ); 

// Create other render resources here 

// Setup the camera's view parameters 
D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f ); 
D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f ); 
g_Camera.SetViewParams( &vecEye, &vecAt ); 

return S_OK; 
} 


//-------------------------------------------------------------------------------------- 
// Create any D3D11 resources that depend on the back buffer 
//-------------------------------------------------------------------------------------- 
HRESULT CALLBACK OnD3D11ResizedSwapChain( ID3D11Device* pd3dDevice, IDXGISwapChain* pSwapChain, 
const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) 
{ 
HRESULT hr; 

V_RETURN( g_DialogResourceManager.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); 
V_RETURN( g_SettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); 

// Setup the camera's projection parameters 
float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; 
g_Camera.SetProjParams( D3DX_PI / 4, fAspectRatio, 0.1f, 1000.0f ); 
g_Camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height ); 
g_Camera.SetButtonMasks( MOUSE_LEFT_BUTTON, MOUSE_WHEEL, MOUSE_MIDDLE_BUTTON ); 

g_HUD.SetLocation( pBackBufferSurfaceDesc->Width - 170, 0 ); 
g_HUD.SetSize( 170, 170 ); 
g_SampleUI.SetLocation( pBackBufferSurfaceDesc->Width - 170, pBackBufferSurfaceDesc->Height - 300 ); 
g_SampleUI.SetSize( 170, 300 ); 

return S_OK; 
} 


//-------------------------------------------------------------------------------------- 
// Render the scene using the D3D11 device 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime, 
float fElapsedTime, void* pUserContext ) 
{ 
// If the settings dialog is being shown, then render it instead of rendering the app's scene 
if( g_SettingsDlg.IsActive() ) 
{ 
g_SettingsDlg.OnRender( fElapsedTime ); 
return; 
} 

float ClearColor[4] = { 0.176f, 0.196f, 0.667f, 0.0f }; 
ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView(); 
pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor ); 

// Clear the depth stencil 
ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView(); 
pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); 

// Get the projection & view matrix from the camera class 
D3DXMatrixTranslation(&g_mWorld, 0, 0, 0); 

D3DXMATRIX mView = *g_Camera.GetViewMatrix(); 
D3DXMATRIX mProj = *g_Camera.GetProjMatrix(); 
D3DXMATRIX mWorldViewProjection = g_mWorld * mView * mProj; 





    g_pmWorldViewProj->SetMatrix((float*)&mWorldViewProjection); 
    g_pmWorld->SetMatrix((float*)&g_mWorld); 

    //Licht 
D3DXVECTOR3 LightDir(1.0f, 0.0f, 0.0f); 
if(g_pLightDirVariable) 
g_pLightDirVariable->SetFloatVector(LightDir); 

D3DXVECTOR3 LightDiffuse(1.0f, 0.0f, 0.0f); //Rot 
if(g_pLightDiffuseVariable) 
g_pLightDiffuseVariable->SetFloatVector(LightDiffuse); 

    //Material 
D3DXVECTOR3 Ambient(0.0f, 0.0f, 1.0f); //Blau 
if(g_pAmbientVariable) 
g_pAmbientVariable->SetFloatVector(Ambient); 

D3DXVECTOR3 Diffuse(1.0f, 1.0f, 1.0f); //Weiss 
    if(g_pDiffuseVariable) 
        g_pDiffuseVariable->SetFloatVector(Diffuse); 

    //Textur 
if(g_ptxDiffuseVariable) 
g_ptxDiffuseVariable->SetResource(g_pRV); 

    pd3dImmediateContext->IASetInputLayout( g_pLayout11 ); 

    g_pTechnique->GetPassByIndex(0)->Apply(0, pd3dImmediateContext); 

    g_Mesh.Render(pd3dImmediateContext); 






} 


//-------------------------------------------------------------------------------------- 
// Release D3D11 resources created in OnD3D11ResizedSwapChain 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnD3D11ReleasingSwapChain( void* pUserContext ) 
{ 
g_DialogResourceManager.OnD3D11ReleasingSwapChain(); 
} 


//-------------------------------------------------------------------------------------- 
// Release D3D11 resources created in OnD3D11CreateDevice 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnD3D11DestroyDevice( void* pUserContext ) 
{ 
g_DialogResourceManager.OnD3D11DestroyDevice(); 
g_SettingsDlg.OnD3D11DestroyDevice(); 
DXUTGetGlobalResourceCache().OnDestroyDevice(); 
SAFE_DELETE( g_pTxtHelper ); 

SAFE_RELEASE( g_pVertexShader11 ); 
SAFE_RELEASE( g_pPixelShader11 ); 
SAFE_RELEASE( g_pLayout11 ); 
SAFE_RELEASE( g_pSamLinear ); 

// Delete additional render resources here... 

SAFE_RELEASE( g_pcbVSPerObject11 ); 
SAFE_RELEASE( g_pcbVSPerFrame11 ); 
} 


//-------------------------------------------------------------------------------------- 
// Called right before creating a D3D9 or D3D11 device, allowing the app to modify the device settings as needed 
//-------------------------------------------------------------------------------------- 
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, void* pUserContext ) 
{ 
if( pDeviceSettings->ver == DXUT_D3D9_DEVICE ) 
{ 
IDirect3D9* pD3D = DXUTGetD3D9Object(); 
D3DCAPS9 Caps; 
pD3D->GetDeviceCaps( pDeviceSettings->d3d9.AdapterOrdinal, pDeviceSettings->d3d9.DeviceType, &Caps ); 

// If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW 
// then switch to SWVP. 
if( ( Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) == 0 || 
Caps.VertexShaderVersion < D3DVS_VERSION( 1, 1 ) ) 
{ 
pDeviceSettings->d3d9.BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING; 
} 

// Debugging vertex shaders requires either REF or software vertex processing 
// and debugging pixel shaders requires REF. 
#ifdef DEBUG_VS 
if( pDeviceSettings->d3d9.DeviceType != D3DDEVTYPE_REF ) 
{ 
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING; 
pDeviceSettings->d3d9.BehaviorFlags &= ~D3DCREATE_PUREDEVICE; 
pDeviceSettings->d3d9.BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; 
} 
#endif 
#ifdef DEBUG_PS 
pDeviceSettings->d3d9.DeviceType = D3DDEVTYPE_REF; 
#endif 
} 

// For the first device created if its a REF device, optionally display a warning dialog box 
static bool s_bFirstTime = true; 
if( s_bFirstTime ) 
{ 
s_bFirstTime = false; 
if( ( DXUT_D3D9_DEVICE == pDeviceSettings->ver && pDeviceSettings->d3d9.DeviceType == D3DDEVTYPE_REF ) || 
( DXUT_D3D11_DEVICE == pDeviceSettings->ver && 
pDeviceSettings->d3d11.DriverType == D3D_DRIVER_TYPE_REFERENCE ) ) 
{ 
DXUTDisplaySwitchingToREFWarning( pDeviceSettings->ver ); 
} 

} 

return true; 
} 


//-------------------------------------------------------------------------------------- 
// Handle updates to the scene. This is called regardless of which D3D API is used 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnFrameMove( double fTime, float fElapsedTime, void* pUserContext ) 
{ 
// Update the camera's position based on user input 
g_Camera.FrameMove( fElapsedTime ); 
} 


//-------------------------------------------------------------------------------------- 
// Handle messages to the application 
//-------------------------------------------------------------------------------------- 
LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, 
void* pUserContext ) 
{ 
// Pass messages to dialog resource manager calls so GUI state is updated correctly 
*pbNoFurtherProcessing = g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam ); 
if( *pbNoFurtherProcessing ) 
return 0; 

// Pass messages to settings dialog if its active 
if( g_SettingsDlg.IsActive() ) 
{ 
g_SettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam ); 
return 0; 
} 

// Give the dialogs a chance to handle the message first 
*pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam ); 
if( *pbNoFurtherProcessing ) 
return 0; 
*pbNoFurtherProcessing = g_SampleUI.MsgProc( hWnd, uMsg, wParam, lParam ); 
if( *pbNoFurtherProcessing ) 
return 0; 

// Pass all remaining windows messages to camera so it can respond to user input 
g_Camera.HandleMessages( hWnd, uMsg, wParam, lParam ); 

return 0; 
} 


//-------------------------------------------------------------------------------------- 
// Handle key presses 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnKeyboard( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext ) 
{ 
} 


//-------------------------------------------------------------------------------------- 
// Handles the GUI events 
//-------------------------------------------------------------------------------------- 
void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext ) 
{ 
switch( nControlID ) 
{ 
case IDC_TOGGLEFULLSCREEN: 
DXUTToggleFullScreen(); 
break; 
case IDC_TOGGLEREF: 
DXUTToggleREF(); 
break; 
case IDC_CHANGEDEVICE: 
g_SettingsDlg.SetActive( !g_SettingsDlg.IsActive() ); 
break; 
} 
}