//-------------------------------------------------------------------------------------- // Handle updates to the scene. This is called regardless of which D3D API is used //-------------------------------------------------------------------------------------- void CALLBACK OnFrameMove( double fTime, FLOAT fElapsedTime, void* pUserContext ) { UNREFERENCED_PARAMETER(pUserContext); UNREFERENCED_PARAMETER(fTime); // Update the camera's position based on user input g_LightCamera.FrameMove( fElapsedTime ); g_ViewerCamera.FrameMove( fElapsedTime ); }
void CALLBACK MouseProc( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddleButtonDown, bool bSideButton1Down, bool bSideButton2Down, int nMouseWheelDelta, int xPos, int yPos, void* pUserContext ) { bool bOldLeftButtonDown = g_bLeftButtonDown; bool bOldRightButtonDown = g_bRightButtonDown; bool bOldMiddleButtonDown = g_bMiddleButtonDown; g_bLeftButtonDown = bLeftButtonDown; g_bMiddleButtonDown = bMiddleButtonDown; g_bRightButtonDown = bRightButtonDown; //* if( bOldLeftButtonDown && !g_bLeftButtonDown ) { // Disable movement g_Camera.SetEnablePositionMovement( false ); } else if( !bOldLeftButtonDown && g_bLeftButtonDown ) { // Enable movement g_Camera.SetEnablePositionMovement( true ); } else if( !bOldRightButtonDown && g_bRightButtonDown ) { // Enable movement g_Camera.SetEnablePositionMovement( false ); } else if( !bOldMiddleButtonDown && g_bMiddleButtonDown ) { // Enable movement g_Camera.SetEnablePositionMovement( false ); } // If no mouse button is down at all, enable camera movement. if( !g_bLeftButtonDown && !g_bRightButtonDown && !g_bMiddleButtonDown ) g_Camera.SetEnablePositionMovement( true ); //*/ /* if( bRightButtonDown ) { float dx = (xPos - g_ptSourisPosition.x)/5.f; float dy = (yPos - g_ptSourisPosition.y)/5.f; g_ptSourisPosition.x = xPos; g_ptSourisPosition.y = yPos; //if ( g_bSourisDroite ) { g_pCamera->m_fAngleH += -dx; g_pCamera->m_fAngleV += dy; } } //*/ }
//-------------------------------------------------------------------------------------- // Initialize the app //-------------------------------------------------------------------------------------- void InitApp() { #ifdef CONSOLE std::cout << "InitApp" << std::endl; #endif g_SettingsDlg.Init( &g_DialogResourceManager ); g_HUD.Init( &g_DialogResourceManager ); g_SampleUI.Init( &g_DialogResourceManager ); 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, VK_F3 ); g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 35, iY += 24, 125, 22, VK_F2 ); g_SampleUI.SetCallback( OnGUIEvent ); iY = 10; g_Camera.SetRotateButtons( true, false, false ); //g_pCamera = new CGlobalCamera(); D3DVECTOR Vdir={0,-1,0}; memset(&g_light,0,sizeof(D3DLIGHT9)); g_light.Type = D3DLIGHT_DIRECTIONAL; 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.Direction = Vdir; // Inits Particle Engine }
void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { // Update the camera's position based on user input g_Camera.FrameMove( fElapsedTime ); OnMyAppFrameMove( pd3dDevice, fTime, fElapsedTime, pUserContext ); }
//-------------------------------------------------------------------------------------- // Handle messages to the application //-------------------------------------------------------------------------------------- LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext ) { UNREFERENCED_PARAMETER(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_D3DSettingsDlg.IsActive() ) { g_D3DSettingsDlg.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_ViewerCamera.HandleMessages( hWnd, uMsg, wParam, lParam ); return 0; }
//-------------------------------------------------------------------------------------- // Create any D3D11 resources that depend on the back buffer //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D11ResizedSwapChain( ID3D11Device* pd3dDevice, IDXGISwapChain* pSwapChain, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { UNREFERENCED_PARAMETER(pSwapChain); UNREFERENCED_PARAMETER(pUserContext); HRESULT hr; XMVECTOR vMeshExtents = g_Scene.GetSceneAABBMax() - g_Scene.GetSceneAABBMin(); XMVECTOR vMeshLength = XMVector3Length( vMeshExtents ); FLOAT fMeshLength = XMVectorGetByIndex( vMeshLength, 0); V_RETURN( g_DialogResourceManager.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); V_RETURN( g_D3DSettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); g_fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT ) pBackBufferSurfaceDesc->Height; g_ViewerCamera.SetProjParams( XM_PI / 4, g_fAspectRatio, 0.05f, fMeshLength); g_Scene.OnResize(pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height); 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; }
//-------------------------------------------------------------------------------------- // Calcaulte the camera based on size of the current scene //-------------------------------------------------------------------------------------- void UpdateViewerCameraNearFar() { XMVECTOR vMeshExtents = g_CascadedShadow.GetSceneAABBMax() - g_CascadedShadow.GetSceneAABBMin(); XMVECTOR vMeshLength = XMVector3Length(vMeshExtents); FLOAT fMeshLength = XMVectorGetByIndex(vMeshLength, 0); g_ViewerCamera.SetProjParams(XM_PI / 4, g_fAspectRatio, 0.05f, fMeshLength); }
// Render the given sprites. They must already be sorted into back-to-front order. void SpriteRenderer::renderSprites(ID3D11DeviceContext* context, const std::vector<SpriteVertex>& sprites, const CFirstPersonCamera& camera) { HRESULT hr; if (sprites.size() > 1) { std::cout; } D3D11_BOX box; box.left = 0; box.right = sprites.size() * sizeof(SpriteVertex); box.top = 0; box.bottom = 1; box.front = 0; box.back = 1; context->UpdateSubresource(m_pVertexBuffer, 0, &box, sprites.data(), 0, 0); // Bind the vertex buffer to the input assembler stage unsigned int strides[] = { sizeof(SpriteVertex), }, offsets[] = { 0, }; context->IASetVertexBuffers(0, 1, &m_pVertexBuffer, strides, offsets); // Set the Input Layout context->IASetInputLayout(m_pInputLayout); context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST); // Load variables to shader SAFE_GET_MATRIX(m_pEffect, "g_ViewProjection", g_ViewProjection); SAFE_GET_VECTOR(m_pEffect, "g_CamRVec", camRightVec); SAFE_GET_VECTOR(m_pEffect, "g_CamUVec", camUpVec); SAFE_GET_RESOURCE(m_pEffect, "g_SprTexGatling", sprTexGatling); SAFE_GET_RESOURCE(m_pEffect, "g_SprTexPlasma", sprTexPlasma); SAFE_GET_RESOURCE(m_pEffect, "g_SprTexBoom", sprTexBoom); // Set view and projection transformations to get sprites to the right positions in world space DirectX::XMMATRIX viewProj = camera.GetViewMatrix() * camera.GetProjMatrix(); V(g_ViewProjection->SetMatrix((float*)&viewProj)); // Set Textures V(sprTexGatling->SetResource(m_spriteSRV[0])); V(sprTexPlasma->SetResource(m_spriteSRV[1])); V(sprTexBoom->SetResource(m_spriteSRV[2])); // Get camera's right and up vector V(camRightVec->SetFloatVector((float*)&camera.GetWorldRight())); V(camUpVec->SetFloatVector((float*)&camera.GetWorldUp())); // Apply the pass from the effect V(m_pEffect->GetTechniqueByName("sRender")->GetPassByName("P0")->Apply(0, context)); // Draw context->Draw(sprites.size(), 0); }
//-------------------------------------------------------------------------------------- // SwapChain has changed and may have new attributes such as size. // 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; DXUTTRACE(L"OnD3D11ResizedSwapChain called\n"); V_RETURN( g_DialogResourceManager.OnD3D11ResizedSwapChain(pd3dDevice, pBackBufferSurfaceDesc) ); V_RETURN( g_SettingsDlg.OnD3D11ResizedSwapChain(pd3dDevice, pBackBufferSurfaceDesc) ); g_BackBufferWidth = pBackBufferSurfaceDesc->Width; g_BackBufferHeight = pBackBufferSurfaceDesc->Height; g_FullViewport.TopLeftX = 0.f; g_FullViewport.TopLeftY = 0.f; g_FullViewport.MinDepth = 0.f; g_FullViewport.MaxDepth = 1.f; g_FullViewport.Width = (FLOAT)g_BackBufferWidth; g_FullViewport.Height = (FLOAT)g_BackBufferHeight; // Setup the camera's projection parameters float AspectRatio = (float)g_BackBufferWidth / (float)g_BackBufferHeight; g_OrbitalCamera.SetProjParams (FOVY, AspectRatio, ZNEAR, ZFAR); g_OrbitalCamera.SetWindow (g_BackBufferWidth, g_BackBufferHeight); g_OrbitalCamera.SetButtonMasks(MOUSE_LEFT_BUTTON, MOUSE_WHEEL, 0); g_FirstPersonCamera.SetProjParams (FOVY, AspectRatio, ZNEAR, ZFAR); g_FirstPersonCamera.SetRotateButtons( 1, 1, 1 ); UINT HudWidth = 256; float HudOpacity = 0.32f; g_HUD.SetLocation(g_BackBufferWidth - HudWidth, 0); g_HUD.SetSize (HudWidth, g_BackBufferHeight); g_HUD.SetBackgroundColors(D3DCOLOR_COLORVALUE(0,0,0,HudOpacity)); // Allocate our own screen-sized buffers, as the SwapChain only contains a non-MSAA color buffer. ResizeScreenSizedBuffers(pd3dDevice); return hr; }
//-------------------------------------------------------------------------------------- // 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; DXUTTRACE(L"OnD3D11CreateDevice called\n"); SetCursor(LoadCursor(0, IDC_ARROW)); ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); // does not addref V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice(pd3dDevice, pd3dImmediateContext) ); V_RETURN( g_SettingsDlg.OnD3D11CreateDevice(pd3dDevice) ); g_pTxtHelper = new CDXUTTextHelper(pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, g_TextLineHeight); // Setup orbital camera D3DXVECTOR3 vecEye(0.0f, 2.0f, 0.0f); D3DXVECTOR3 vecAt (0.0f, 0.0f, 0.0f); g_OrbitalCamera.SetViewParams(&vecEye, &vecAt); g_OrbitalCamera.SetRadius(1.5f, 0.01f); // Setup first-person camera D3DXVECTOR3 sibenikVecEye(0.0960150138f, 0.0273544509f, -0.0185411610f); D3DXVECTOR3 sibenikVecAt (-0.623801112f, -0.649074197f, -0.174454257f); g_FirstPersonCamera.SetViewParams(&sibenikVecEye, &sibenikVecAt); g_FirstPersonCamera.SetEnablePositionMovement(1); g_FirstPersonCamera.SetScalers(0.001f, 0.05f); // Load Scene3D.fx g_pSceneRenderer.OnCreateDevice(pd3dDevice); // Load meshes and bin files LoadScenes(pd3dDevice); GFSDK_SSAO_Status status; status = g_AORenderer.Create(pd3dDevice); assert(status == GFSDK_SSAO_OK); return S_OK; }
//-------------------------------------------------------------------------------------- // Handle updates to the scene. This is called regardless of which D3D API is used //-------------------------------------------------------------------------------------- void CALLBACK OnFrameMove(double fTime, float fElapsedTime, void* pUserContext) { SceneMesh *pSceneMesh = g_Scenes[g_CurrentSceneId].pMesh; g_UseOrbitalCamera = pSceneMesh && pSceneMesh->UseOrbitalCamera(); if (g_UseOrbitalCamera) { g_OrbitalCamera.FrameMove(fElapsedTime); } else { g_FirstPersonCamera.FrameMove(fElapsedTime); } }
//-------------------------------------------------------------------------------------- // Initialize the app //-------------------------------------------------------------------------------------- void InitApp() { // Initialize dialogs g_D3DSettingsDlg.Init( &g_DialogResourceManager ); g_HUD.Init( &g_DialogResourceManager ); g_SampleUI.Init( &g_DialogResourceManager ); g_HUD.SetCallback( OnGUIEvent ); int iY = 20; g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 0, iY, 170, 22 ); g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 0, iY += 26, 170, 22, VK_F3 ); g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 0, iY += 26, 170, 22, VK_F2 ); g_SampleUI.SetCallback( OnGUIEvent ); iY = 10; WCHAR sz[100]; iY += 24; swprintf_s( sz, L"Patch Divisions: %2.1f", g_fSubdivs ); g_SampleUI.AddStatic( IDC_PATCH_SUBDIVS_STATIC, sz, 10, iY += 26, 150, 22 ); g_SampleUI.AddSlider( IDC_PATCH_SUBDIVS, 10, iY += 24, 150, 22, 10 * MIN_DIVS, 10 * MAX_DIVS, (int)(g_fSubdivs * 10) ); iY += 24; g_SampleUI.AddCheckBox( IDC_TOGGLE_LINES, L"Toggle Wires", 20, iY += 26, 150, 22, g_bDrawWires ); iY += 24; g_SampleUI.AddRadioButton( IDC_PARTITION_INTEGER, IDC_PARTITION_MODE, L"Integer", 20, iY += 26, 170, 22 ); g_SampleUI.AddRadioButton( IDC_PARTITION_FRAC_EVEN, IDC_PARTITION_MODE, L"Fractional Even", 20, iY += 26, 170, 22 ); g_SampleUI.AddRadioButton( IDC_PARTITION_FRAC_ODD, IDC_PARTITION_MODE, L"Fractional Odd", 20, iY += 26, 170, 22 ); g_SampleUI.GetRadioButton( IDC_PARTITION_INTEGER )->SetChecked( true ); // Setup the camera's view parameters static const XMVECTORF32 s_vecEye = { 5.0f, 3.0f, -10.0f, 0.f }; static const XMVECTORF32 s_vecAt = { 5.0f, 0.0f, 0.0f, 0.f }; g_Camera.SetViewParams( s_vecEye, s_vecAt ); g_Camera.SetEnablePositionMovement(true); g_Camera.SetEnableYAxisMovement(true); }
//-------------------------------------------------------------------------------------- // Handle mouse buttons //-------------------------------------------------------------------------------------- void CALLBACK MouseProc( bool bLeftButtonDown, bool bRightButtonDown, bool bMiddleButtonDown, bool bSideButton1Down, bool bSideButton2Down, int nMouseWheelDelta, int xPos, int yPos, void* pUserContext ) { bool bOldLeftButtonDown = g_bLeftButtonDown; bool bOldRightButtonDown = g_bRightButtonDown; bool bOldMiddleButtonDown = g_bMiddleButtonDown; g_bLeftButtonDown = bLeftButtonDown; g_bMiddleButtonDown = bMiddleButtonDown; g_bRightButtonDown = bRightButtonDown; if( bOldLeftButtonDown && !g_bLeftButtonDown ) g_Camera.SetEnablePositionMovement( false ); else if( !bOldLeftButtonDown && g_bLeftButtonDown ) g_Camera.SetEnablePositionMovement( true ); if( !bOldRightButtonDown && g_bRightButtonDown ) { g_Camera.SetEnablePositionMovement( false ); } if( bOldMiddleButtonDown && !g_bMiddleButtonDown ) { g_LCamera.SetEnablePositionMovement( false ); } else if( !bOldMiddleButtonDown && g_bMiddleButtonDown ) { g_LCamera.SetEnablePositionMovement( true ); g_Camera.SetEnablePositionMovement( false ); } // If no mouse button is down at all, enable camera movement. if( !g_bLeftButtonDown && !g_bRightButtonDown && !g_bMiddleButtonDown ) g_Camera.SetEnablePositionMovement( 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 ) { // g_fElapsedTime = fElapsedTime; // Update the camera's position based on user input g_Camera.FrameMove( fElapsedTime ); //g_pCamera->Move(); // Updates particle system particleSystem.update( fElapsedTime ); // Changes the color of the model over time step += fElapsedTime * 0.5f; particleModel->setParam(PARAM_RED,0.6f + 0.4f * sin(step)); particleModel->setParam(PARAM_GREEN,0.6f + 0.4f * sin(step + D3DX_PI * 2.0f / 3.0f)); particleModel->setParam(PARAM_BLUE,0.6f + 0.4f * sin(step + D3DX_PI * 4.0f / 3.0f)); }
//-------------------------------------------------------------------------------------- // 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_D3DSettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); // Setup the camera's projection parameters float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; g_Camera.SetProjParams( D3DX_PI / 4, fAspectRatio, 2.0f, 4000.0f ); // g_Camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height ); // g_Camera.SetButtonMasks( MOUSE_MIDDLE_BUTTON, MOUSE_WHEEL, MOUSE_LEFT_BUTTON ); D3DXVECTOR3 vMin = D3DXVECTOR3( -1000.0f, -1000.0f, -1000.0f ); D3DXVECTOR3 vMax = D3DXVECTOR3( 1000.0f, 1000.0f, 1000.0f ); g_Camera.SetRotateButtons(TRUE, FALSE, FALSE); g_Camera.SetScalers( 0.01f, 30.0f ); g_Camera.SetDrag( true ); g_Camera.SetEnableYAxisMovement( true ); g_Camera.SetClipToBoundary( TRUE, &vMin, &vMax ); g_Camera.FrameMove( 0 ); 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 ); //Turn off backface culling D3D11_RASTERIZER_DESC rsDesc; ZeroMemory(&rsDesc,sizeof(D3D11_RASTERIZER_DESC) ); rsDesc.CullMode = D3D11_CULL_NONE; rsDesc.FillMode = D3D11_FILL_SOLID; //rsDesc.FillMode = D3D11_FILL_WIREFRAME; ID3D11RasterizerState *pRasterizerState = NULL; pd3dDevice->CreateRasterizerState(&rsDesc, &pRasterizerState); DXUTGetD3D11DeviceContext()->RSSetState(pRasterizerState); SAFE_RELEASE(pRasterizerState); return S_OK; }
//-------------------------------------------------------------------------------------- // Create any D3D9 resources that will live through a device reset (D3DPOOL_MANAGED) // and aren't tied to the back buffer size //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D9CreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { #ifdef CONSOLE std::cout << "OnD3D9CreateDevice" << std::endl; #endif HRESULT hr; V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) ); V_RETURN( g_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) ); V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &g_pFont9 ) ); // Read the D3DX effect file // WCHAR str[MAX_PATH]; DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE; #ifdef DEBUG_VS dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT; #endif #ifdef DEBUG_PS dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT; #endif //V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"SimpleSample.fx" ) ); //V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, L"e:/SimpleSample.fx", NULL, NULL, dwShaderFlags, NULL, &g_pEffect9, NULL ) ); // 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 ); //------------------------------------------------------------------------- //* // SPARK init DX9Info::setDevice( pd3dDevice ); hr = D3DXCreateTextureFromFile(pd3dDevice, L"res/point.bmp", &g_pTextureParticle); if( FAILED(hr) ) cout << "erreur chargement texture" << endl; return S_OK; }
//-------------------------------------------------------------------------------------- // Callback function for changed window size //-------------------------------------------------------------------------------------- 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_D3DSettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); // Setup the camera's projection parameters float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; g_Camera.SetProjParams( D3DX_PI / 4, fAspectRatio, 0.5f, 100.0f ); g_LCamera.SetProjParams( D3DX_PI / 4, fAspectRatio, 10.0f, 100.0f ); g_HUD.SetLocation( pBackBufferSurfaceDesc->Width - 170, 0 ); g_HUD.SetSize( 170, 170 ); g_SampleUI.SetLocation( pBackBufferSurfaceDesc->Width - 170, pBackBufferSurfaceDesc->Height - 240 ); g_SampleUI.SetSize( 150, 110 ); 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_D3DSettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); // Setup the camera's projection parameters float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; g_Camera.SetProjParams( XM_PI / 4, fAspectRatio, 0.1f, 2000.0f ); //g_Camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height ); //g_Camera.SetButtonMasks( MOUSE_MIDDLE_BUTTON, MOUSE_WHEEL, MOUSE_LEFT_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; }
//-------------------------------------------------------------------------------------- // Initialize the app //-------------------------------------------------------------------------------------- void InitApp() { WCHAR temp[64]; g_D3DSettingsDlg.Init( &g_DialogResourceManager ); g_HUD.Init( &g_DialogResourceManager ); g_SampleUI.Init( &g_DialogResourceManager ); g_HUD.SetCallback( OnGUIEvent ); int iY = 30; g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 0, iY, 170, 23 ); g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 0, iY += 26, 170, 23, VK_F3 ); g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 0, iY += 26, 170, 23, VK_F2 ); iY += 180; swprintf_s( temp, L"SunWidth = %2.2f", g_fSunWidth ); g_HUD.AddStatic( IDC_SUNWIDTH_TEXT, temp, 0, iY += 25, 100, 24 ); g_HUD.AddSlider( IDC_SUNWIDTH_SLIDER, 0, iY += 25, 150, 24, 0, 100, int( ( g_fSunWidth / 3.0 ) * 100 ) ); g_Camera.SetRotateButtons( true, false, false ); g_LCamera.SetButtonMasks( MOUSE_RIGHT_BUTTON, 0, 0 ); g_SampleUI.SetCallback( OnGUIEvent ); }
//-------------------------------------------------------------------------------------- // Handle messages to the application //-------------------------------------------------------------------------------------- LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext ) { // Pass all remaining windows messages to camera so it can respond to user input g_Camera.HandleMessages( hWnd, uMsg, wParam, lParam ); switch( uMsg ) { case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: g_bLeftMouseDown = true; break; case WM_LBUTTONUP: g_bLeftMouseDown = false; break; case WM_CAPTURECHANGED: if( (HWND)lParam != hWnd ) g_bLeftMouseDown = false; break; } return MyAppMsgProc(hWnd, uMsg, wParam, lParam, pbNoFurtherProcessing, pUserContext); }
//-------------------------------------------------------------------------------------- // Handle messages to the application //-------------------------------------------------------------------------------------- LRESULT CALLBACK MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext) { // Always allow dialog resource manager calls to handle global messages // so GUI state is updated correctly *pbNoFurtherProcessing = g_DialogResourceManager.MsgProc(hWnd, uMsg, wParam, lParam); if (*pbNoFurtherProcessing) { return 0; } 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; } // Pass all windows messages to camera so it can respond to user input if (g_UseOrbitalCamera) { g_OrbitalCamera.HandleMessages(hWnd, uMsg, wParam, lParam); } else { g_FirstPersonCamera.HandleMessages(hWnd, uMsg, wParam, lParam); } return 0; }
//-------------------------------------------------------------------------------------- // When the user changes scene, recreate these components as they are scene // dependent. //-------------------------------------------------------------------------------------- HRESULT CreateD3DComponents( ID3D11Device* pd3dDevice) { HRESULT hr; auto pd3dImmediateContext = DXUTGetD3D11DeviceContext(); V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); static const XMVECTORF32 s_vecEye = { 105.0f, 14.0f, -3.0f, 0.f }; static const XMVECTORF32 s_vecLookAt = { 0.0f, -7.5f, 0.0f, 0.f }; XMFLOAT3 vMin = XMFLOAT3( -1000.0f, -1000.0f, -1000.0f ); XMFLOAT3 vMax = XMFLOAT3( 1000.0f, 1000.0f, 1000.0f ); g_ViewerCamera.SetViewParams( s_vecEye, s_vecLookAt ); g_ViewerCamera.SetRotateButtons( true, false, false); g_ViewerCamera.SetScalers( 0.01f, 10.0f ); g_ViewerCamera.SetDrag( true ); g_ViewerCamera.SetEnableYAxisMovement( true ); g_ViewerCamera.SetClipToBoundary( true, &vMin, &vMax ); g_ViewerCamera.FrameMove( 0 ); static const XMVECTORF32 s_lightEye = { -320.0f, 300.0f, -220.3f, 0.f }; g_LightCamera.SetViewParams( s_lightEye, g_XMZero ); g_LightCamera.SetRotateButtons( true, false, false ); g_LightCamera.SetScalers( 0.01f, 50.0f ); g_LightCamera.SetDrag( true ); g_LightCamera.SetEnableYAxisMovement( true ); g_LightCamera.SetClipToBoundary( true, &vMin, &vMax ); g_LightCamera.SetProjParams( XM_PI / 4, 1.0f, 0.1f , 1000.0f); g_LightCamera.FrameMove( 0 ); // Get the final sizes uint32_t width = DXUTGetDXGIBackBufferSurfaceDesc()->Width; uint32_t height = DXUTGetDXGIBackBufferSurfaceDesc()->Height; g_Scene.Init( pd3dDevice, pd3dImmediateContext, &g_MeshPowerPlant, width, height); 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( double fTime, float fElapsedTime, void* pUserContext ) { // Update the camera's position based on user input g_Camera.FrameMove( fElapsedTime ); }
//-------------------------------------------------------------------------------------- // Create any D3D11 resources that aren't dependant on the back buffer //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { g_pd3dDevice = pd3dDevice; HRESULT hr; ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); V_RETURN( g_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); D3DXVECTOR3 vCenter( 0.25767413f, -28.503521f, 111.00689f); FLOAT fObjectRadius = 378.15607f; D3DXMatrixTranslation( &g_mCenterMesh, -vCenter.x, -vCenter.y, -vCenter.z ); D3DXMATRIXA16 m; D3DXMatrixRotationY( &m, D3DX_PI ); g_mCenterMesh *= m; D3DXMatrixRotationX( &m, D3DX_PI / 2.0f ); g_mCenterMesh *= m; // Compile the shaders to a model based on the feature level we acquired ID3DBlob* pVertexShaderBuffer = NULL; ID3DBlob* pGeometryShaderBuffer = NULL; ID3DBlob* pPixelShaderBuffer = NULL; switch( DXUTGetD3D11DeviceFeatureLevel() ) { case D3D_FEATURE_LEVEL_11_0: V_RETURN( CompileShaderFromFile( L"cloth_renderer_VS.hlsl", "VSMain", "vs_5_0" , &pVertexShaderBuffer ) ); V_RETURN( CompileShaderFromFile( L"cloth_renderer_PS.hlsl", "GSMain", "gs_5_0" , &pGeometryShaderBuffer ) ); V_RETURN( CompileShaderFromFile( L"cloth_renderer_PS.hlsl", "PSMain", "ps_5_0" , &pPixelShaderBuffer ) ); break; } // Create the shaders V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &g_pVertexShader ) ); V_RETURN( pd3dDevice->CreateGeometryShader( pGeometryShaderBuffer->GetBufferPointer(), pGeometryShaderBuffer->GetBufferSize(), NULL, &g_pGeometryShader ) ); V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &g_pPixelShader ) ); V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), &g_pVertexLayout11 ) ); SAFE_RELEASE( pVertexShaderBuffer ); SAFE_RELEASE( pPixelShaderBuffer ); SAFE_RELEASE( pGeometryShaderBuffer ); // Load the mesh V_RETURN( g_Mesh11.Create( pd3dDevice, L"tiny\\tiny.sdkmesh", true ) ); // Create a sampler state D3D11_SAMPLER_DESC SamDesc; SamDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; SamDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; SamDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; SamDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; SamDesc.MipLODBias = 0.0f; SamDesc.MaxAnisotropy = 1; SamDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; SamDesc.BorderColor[0] = SamDesc.BorderColor[1] = SamDesc.BorderColor[2] = SamDesc.BorderColor[3] = 0; SamDesc.MinLOD = 0; SamDesc.MaxLOD = D3D11_FLOAT32_MAX; V_RETURN( pd3dDevice->CreateSamplerState( &SamDesc, &g_pSamLinear ) ); // Setup constant buffers D3D11_BUFFER_DESC Desc; Desc.Usage = D3D11_USAGE_DYNAMIC; Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; Desc.MiscFlags = 0; Desc.ByteWidth = sizeof( CB_VS_PER_OBJECT ); V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbVSPerObject ) ); Desc.ByteWidth = sizeof( CB_PS_PER_OBJECT ); V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbPSPerObject ) ); Desc.ByteWidth = sizeof( CB_PS_PER_FRAME ); V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &g_pcbPSPerFrame ) ); // Setup the camera's view parameters D3DXVECTOR3 vecEye( 30.0f, 30.0f, -80.0f ); D3DXVECTOR3 vecAt ( 10.0f, 20.0f, -0.0f ); g_Camera.SetViewParams( &vecEye, &vecAt ); cloths.resize(numFlags); for( int flagIndex = 0; flagIndex < numFlags; ++flagIndex ) { cloths[flagIndex].create_buffers(clothWidth, clothHeight); } initBullet(); std::wstring flagTexsName[] = { L"atiFlag.bmp", L"amdFlag.bmp", }; int numFlagTexs = 2; WCHAR flagTexs[2][MAX_PATH]; HRESULT res = DXUTFindDXSDKMediaFileCch(flagTexs[0],MAX_PATH, flagTexsName[0].c_str()); res = DXUTFindDXSDKMediaFileCch(flagTexs[1],MAX_PATH, flagTexsName[1].c_str()); for( int flagIndex = 0; flagIndex < numFlags; ++flagIndex ) { cloths[flagIndex].create_texture(flagTexs[flagIndex % numFlagTexs]); cloths[flagIndex].x_offset = 0; cloths[flagIndex].y_offset = 0; cloths[flagIndex].z_offset = 0; } my_capsule.create_buffers(50,40); my_capsule.create_texture(); //Turn off backface culling D3D11_RASTERIZER_DESC rsDesc; ZeroMemory(&rsDesc,sizeof(D3D11_RASTERIZER_DESC) ); rsDesc.CullMode = D3D11_CULL_NONE; rsDesc.FillMode = D3D11_FILL_SOLID; hr = pd3dDevice->CreateRasterizerState(&rsDesc, &g_pRasterizerState); rsDesc.FillMode = D3D11_FILL_WIREFRAME; hr = pd3dDevice->CreateRasterizerState(&rsDesc, &g_pRasterizerStateWF); SAFE_RELEASE(pd3dImmediateContext); return S_OK; }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D11 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D11FrameRender( ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, double fTime, float fElapsedTime, void* pUserContext ) { HRESULT hr; // If the settings dialog is being shown, then render it instead of rendering the app's scene if( g_D3DSettingsDlg.IsActive() ) { g_D3DSettingsDlg.OnRender( fElapsedTime ); return; } //Render light arrow D3DXMATRIX mView; D3DXMATRIX mProj; mProj = ( *g_Camera.GetProjMatrix() ); mView = ( *g_Camera.GetViewMatrix() ); D3DXCOLOR arrowColor = D3DXCOLOR( 1, 1, 0, 1 ); //hr = g_LightControl.OnRender11( arrowColor, &mView, &mProj, g_Camera.GetEyePt() ); FirePart.calculate_particle(pd3dDevice,pd3dImmediateContext,fElapsedTime,&g_Camera,&g_LightControl); MissilePart.calculate_particle(pd3dDevice,pd3dImmediateContext,fElapsedTime,&g_Camera,&g_LightControl); board1.RenderTexture(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_LightControl); deboard.RenderTexture(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_LightControl); // Clear the render target and depth stencil float ClearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; //ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView(); ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView(); pd3dImmediateContext->ClearRenderTargetView( rtv_render_to_texture_ori, ClearColor ); ID3D11DepthStencilView* pDSV = DXUTGetD3D11DepthStencilView(); pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); pd3dImmediateContext->OMSetRenderTargets(1,&rtv_render_to_texture_ori,pDSV); pd3dImmediateContext->OMSetDepthStencilState(NULL, 0); sky.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); lightsphere.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); tessplane.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); tesscube.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); fuse.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,&g_LightControl); board1.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); deboard.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); test.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); if(show_buildings) { buildings.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); } geo_alien.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera,lightpos); FirePart.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera); MissilePart.Render(pd3dDevice,pd3dImmediateContext,fTime,fElapsedTime,pUserContext,&g_Camera); //ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView(); pd3dImmediateContext->OMSetDepthStencilState(NULL, 0); pd3dImmediateContext->OMSetBlendState(NULL,NULL,0xffffffff); //find bright spot pd3dImmediateContext->ClearRenderTargetView( rtv_render_to_texture_1, ClearColor ); pDSV = DXUTGetD3D11DepthStencilView(); pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); pd3dImmediateContext->OMSetRenderTargets(1,&rtv_render_to_texture_1,pDSV); pd3dImmediateContext->VSSetShader( VSPPFirstPass, NULL, 0 ); pd3dImmediateContext->PSSetShader( PSPPFirstPass, NULL, 0 ); pd3dImmediateContext->HSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->DSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->GSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->PSSetSamplers(0, 1, &g_pSamLinear); pd3dImmediateContext->PSSetShaderResources(0,1,&sr_texture_original); //pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid ); pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pd3dImmediateContext->Draw(9,0); //blur hori pd3dImmediateContext->ClearRenderTargetView( rtv_render_to_texture_2, ClearColor ); pDSV = DXUTGetD3D11DepthStencilView(); pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); pd3dImmediateContext->OMSetRenderTargets(1,&rtv_render_to_texture_2,pDSV); Compute_blur(1.0f / width, 0); D3D11_MAPPED_SUBRESOURCE MappedResource; V( pd3dImmediateContext->Map( blur_cb_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) ); blur_cbuffer* pPerFrame = ( blur_cbuffer* )MappedResource.pData; std::copy(&blur_cb_data.offset[0], &blur_cb_data.offset[15], pPerFrame->offset); //std::copy(&blur_cb_data.offset[0], &blur_cb_data.offset[15], pPerFrame->offset); //std::copy(&blur_cb_data.weight[0], &blur_cb_data.weight[15], pPerFrame->weight); pd3dImmediateContext->Unmap( blur_cb_buffer, 0 ); pd3dImmediateContext->VSSetShader( VSPPBlur, NULL, 0 ); pd3dImmediateContext->PSSetShader( PSPPBlur, NULL, 0 ); pd3dImmediateContext->HSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->DSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->GSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->PSSetConstantBuffers(0,1,&blur_cb_buffer); pd3dImmediateContext->PSSetSamplers(0, 1, &g_pSamLinear); pd3dImmediateContext->PSSetShaderResources(0,1,&sr_texture1); //pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid ); pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pd3dImmediateContext->Draw(9,0); //blur vert pd3dImmediateContext->ClearRenderTargetView( rtv_render_to_texture_1, ClearColor ); pDSV = DXUTGetD3D11DepthStencilView(); pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); pd3dImmediateContext->OMSetRenderTargets(1,&rtv_render_to_texture_1,pDSV); Compute_blur(0, 1.0f / height); V( pd3dImmediateContext->Map( blur_cb_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) ); pPerFrame = ( blur_cbuffer* )MappedResource.pData; std::copy(&blur_cb_data.offset[0], &blur_cb_data.offset[15], pPerFrame->offset); //std::copy(&blur_cb_data.offset[0], &blur_cb_data.offset[15], pPerFrame->offset); //std::copy(&blur_cb_data.weight[0], &blur_cb_data.weight[15], pPerFrame->weight); pd3dImmediateContext->Unmap( blur_cb_buffer, 0 ); pd3dImmediateContext->VSSetShader( VSPPBlur, NULL, 0 ); pd3dImmediateContext->PSSetShader( PSPPBlur, NULL, 0 ); pd3dImmediateContext->HSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->DSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->GSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->PSSetConstantBuffers(0,1,&blur_cb_buffer); pd3dImmediateContext->PSSetSamplers(0, 1, &g_pSamLinear); pd3dImmediateContext->PSSetShaderResources(0,1,&sr_texture2); //pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid ); pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pd3dImmediateContext->Draw(9,0); //combine effect pd3dImmediateContext->ClearRenderTargetView( pRTV, ClearColor ); pDSV = DXUTGetD3D11DepthStencilView(); pd3dImmediateContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); pd3dImmediateContext->OMSetRenderTargets(1,&pRTV,pDSV); // V( pd3dImmediateContext->Map( blur_cb_buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource ) ); // pPerFrame = ( blur_cbuffer* )MappedResource.pData; //std::copy(&blur_cb_data.offset[0], &blur_cb_data.offset[15], pPerFrame->offset); // pd3dImmediateContext->Unmap( blur_cb_buffer, 0 ); pd3dImmediateContext->VSSetShader( VSPPComb, NULL, 0 ); pd3dImmediateContext->PSSetShader( PSPPComb, NULL, 0 ); pd3dImmediateContext->HSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->DSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->GSSetShader( NULL, NULL, 0 ); pd3dImmediateContext->PSSetConstantBuffers(0,1,&blur_cb_buffer); pd3dImmediateContext->PSSetSamplers(0, 1, &g_pSamLinear); pd3dImmediateContext->PSSetShaderResources(0,1,&sr_texture1);//bloom blurred pd3dImmediateContext->PSSetShaderResources(1,1,&sr_texture_original);//base tex //pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid ); pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pd3dImmediateContext->Draw(9,0); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); g_HUD.OnRender( fElapsedTime ); g_SampleUI.OnRender( fElapsedTime ); RenderText(); DXUT_EndPerfEvent(); }
//-------------------------------------------------------------------------------------- // 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_D3DSettingsDlg.OnD3D11ResizedSwapChain( pd3dDevice, pBackBufferSurfaceDesc ) ); // Setup the camera's projection parameters width = pBackBufferSurfaceDesc->Width; height = pBackBufferSurfaceDesc->Height; float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; g_Camera.SetProjParams( D3DX_PI / 4, fAspectRatio, 2.0f, 100000.0f ); //g_Camera.SetWindow( pBackBufferSurfaceDesc->Width, pBackBufferSurfaceDesc->Height ); //g_Camera.SetButtonMasks( MOUSE_MIDDLE_BUTTON, MOUSE_WHEEL, MOUSE_LEFT_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 ); //deboard.OnD3D11ResizedSwapChain(pd3dDevice,pSwapChain,pBackBufferSurfaceDesc,pUserContext); DXGI_FORMAT format; D3D11_TEXTURE2D_DESC info ; ZeroMemory (& info , sizeof ( info )); info.Width = pBackBufferSurfaceDesc->Width; info.Height = pBackBufferSurfaceDesc->Height; info.MipLevels = 1; info.ArraySize = 1; info.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; info.SampleDesc . Count = 1; info.Usage = D3D11_USAGE_DEFAULT; info.BindFlags = D3D11_BIND_RENDER_TARGET|D3D11_BIND_SHADER_RESOURCE ; info.CPUAccessFlags = 0; info.MiscFlags = 0; hr = pd3dDevice->CreateTexture2D(&info,nullptr,&original_texture); hr = pd3dDevice->CreateTexture2D(&info,nullptr,&texture1); hr = pd3dDevice->CreateTexture2D(&info,nullptr,&texture2); format = info.Format; D3D11_SAMPLER_DESC sampDesc; ZeroMemory( &sampDesc, sizeof(sampDesc) ); sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP ; sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP ; sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP ; sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; sampDesc.MinLOD = 0; sampDesc.MaxLOD = 0; hr = pd3dDevice->CreateSamplerState( &sampDesc, &g_pSamLinear ); // render target view D3D11_RENDER_TARGET_VIEW_DESC target_info; target_info.Format = format; target_info.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; target_info.Texture2D.MipSlice = 0; hr = pd3dDevice->CreateRenderTargetView(original_texture, &target_info ,&rtv_render_to_texture_ori); hr = pd3dDevice->CreateRenderTargetView(texture1, &target_info ,&rtv_render_to_texture_1); hr = pd3dDevice->CreateRenderTargetView(texture2, &target_info ,&rtv_render_to_texture_2); D3D11_SHADER_RESOURCE_VIEW_DESC shader_resource_info; shader_resource_info.Format = format; shader_resource_info.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; shader_resource_info.Texture2D . MostDetailedMip = 0; shader_resource_info.Texture2D . MipLevels = 1; hr = pd3dDevice->CreateShaderResourceView(original_texture, &shader_resource_info ,&sr_texture_original); hr = pd3dDevice->CreateShaderResourceView(texture1, &shader_resource_info ,&sr_texture1); hr = pd3dDevice->CreateShaderResourceView(texture2, &shader_resource_info ,&sr_texture2); return S_OK; }
//-------------------------------------------------------------------------------------- // 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_D3DSettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); // D3DXVECTOR3 vCenter( 0.25767413f, -28.503521f, 111.00689f ); FLOAT fObjectRadius = 378.15607f; lightpos = D3DXVECTOR3(300,300,-200); //test = new testing(); hr = test.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext); hr = tessplane.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext); hr = tesscube.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,D3DXVECTOR3(300,50,-200));//D3DXVECTOR3(300,50,-200 hr = lightsphere.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,10,lightpos); hr = fuse.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext); hr = board1.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(300,-300,-1000)); hr = deboard.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(-300,-300,-1000)); hr = geo_alien.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext); hr = FirePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,80,0); //0 = fire hr = sky.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,D3DXVECTOR3(0,0,0)); hr = buildings.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext); hr = MissilePart.setup(pd3dDevice,pBackBufferSurfaceDesc,pUserContext,20,1); g_LightControl.SetRadius( 2000 ); // Setup the camera's view parameters D3DXVECTOR3 vecEye( 0.0f, 50.0f, -1000.0f ); D3DXVECTOR3 vecAt ( 0.0f, 0.0f, -0.0f ); g_Camera.SetRotateButtons(true,false,false); g_Camera.SetViewParams( &vecEye, &vecAt ); g_Camera.SetEnablePositionMovement( true ); g_Camera.SetScalers( 0.005f, 500.0f ); D3D11_DEPTH_STENCIL_DESC descDS; ZeroMemory(&descDS, sizeof(descDS)); descDS.DepthEnable = false; descDS.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; descDS.DepthFunc = D3D11_COMPARISON_LESS; descDS.StencilEnable = FALSE; hr = pd3dDevice->CreateDepthStencilState( &descDS, &g_DepthState); //setup stuff for post process ID3DBlob* pVertexShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) ); ID3DBlob* pPixelShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"PP1.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) ); V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPFirstPass ) ); DXUT_SetDebugName( VSPPFirstPass, "VSPost1" ); V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPFirstPass ) ); DXUT_SetDebugName( PSPPFirstPass, "PSPost1" ); pVertexShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) ); pPixelShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"Gaussblur.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) ); V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPBlur ) ); DXUT_SetDebugName( VSPPBlur, "VSBlur" ); V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPBlur ) ); DXUT_SetDebugName( PSPPBlur, "PSBlur" ); pVertexShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "VS", "vs_4_0", &pVertexShaderBuffer ) ); pPixelShaderBuffer = NULL; V_RETURN( CompileShaderFromFile( L"bloom_combine.hlsl", "PS", "ps_4_0", &pPixelShaderBuffer ) ); V_RETURN( pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &VSPPComb ) ); DXUT_SetDebugName( VSPPComb, "VSComb" ); V_RETURN( pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &PSPPComb ) ); DXUT_SetDebugName( PSPPComb, "PSComb" ); D3D11_BUFFER_DESC Desc; Desc.Usage = D3D11_USAGE_DYNAMIC; Desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; Desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; Desc.MiscFlags = 0; Desc.ByteWidth = sizeof( blur_cbuffer ); V_RETURN( pd3dDevice->CreateBuffer( &Desc, NULL, &blur_cb_buffer ) ); DXUT_SetDebugName( blur_cb_buffer, "blur_cb" ); //g_Camera.SetRadius( fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f ); return S_OK; }
//-------------------------------------------------------------------------------------- void RenderAOFromMesh(ID3D11Device* pd3dDevice, ID3D11DeviceContext* pd3dImmediateContext, ID3D11RenderTargetView* pBackBufferRTV, SceneMesh *pMesh) { UINT SampleCount = g_MSAADesc[g_MSAACurrentSettings].SampleCount; SceneViewInfo ViewInfo; pd3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pd3dImmediateContext->RSSetViewports(1, &g_FullViewport); //-------------------------------------------------------------------------------------- // Clear render target and depth buffer //-------------------------------------------------------------------------------------- float BgColor[4] = { 1.0f, 1.0f, 1.0f }; pd3dImmediateContext->ClearRenderTargetView(g_ColorRTV, BgColor); pd3dImmediateContext->ClearDepthStencilView(g_DepthStencilDSV, D3D11_CLEAR_DEPTH, 1.0, 0); //-------------------------------------------------------------------------------------- // Render color and depth with the Scene3D class //-------------------------------------------------------------------------------------- pd3dImmediateContext->OMSetRenderTargets(1, &g_ColorRTV, g_DepthStencilDSV); if (g_UseOrbitalCamera) { ViewInfo.WorldViewMatrix = (*g_OrbitalCamera.GetWorldMatrix()) * (*g_OrbitalCamera.GetViewMatrix()); ViewInfo.ProjectionMatrix = *g_OrbitalCamera.GetProjMatrix(); } else { D3DXMATRIX WorldMatrix; D3DXMatrixRotationX(&WorldMatrix, -D3DX_PI * 0.5f); ViewInfo.WorldViewMatrix = WorldMatrix * (*g_FirstPersonCamera.GetViewMatrix()); ViewInfo.ProjectionMatrix = *g_FirstPersonCamera.GetProjMatrix(); } g_pSceneRenderer.OnFrameRender(&ViewInfo, pMesh); //-------------------------------------------------------------------------------------- // Render the SSAO //-------------------------------------------------------------------------------------- GFSDK_SSAO_InputDepthData InputDepthData; InputDepthData.pFullResDepthTextureSRV = g_DepthStencilSRV; InputDepthData.pProjectionMatrix = (CONST FLOAT*)ViewInfo.ProjectionMatrix; InputDepthData.ProjectionMatrixLayout = GFSDK_SSAO_ROW_MAJOR_ORDER; InputDepthData.MetersToViewSpaceUnits = pMesh->GetSceneScale(); GFSDK_SSAO_Status status; status = g_AORenderer.RenderAO(pd3dImmediateContext, &InputDepthData, &g_AOParams, g_ColorRTV); assert(status == GFSDK_SSAO_OK); //-------------------------------------------------------------------------------------- // Copy/resolve colors to the 1xAA backbuffer //-------------------------------------------------------------------------------------- pd3dImmediateContext->OMSetRenderTargets(1, &pBackBufferRTV, NULL); ID3D11Texture2D* pBackBufferTexture; pBackBufferRTV->GetResource((ID3D11Resource**)&pBackBufferTexture); if (SampleCount > 1) { pd3dImmediateContext->ResolveSubresource(pBackBufferTexture, 0, g_ColorTexture, 0, DXGI_FORMAT_R8G8B8A8_UNORM); } else { pd3dImmediateContext->CopyResource(pBackBufferTexture, g_ColorTexture); } SAFE_RELEASE(pBackBufferTexture); }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D9 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D9FrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { HRESULT hr; D3DXMATRIXA16 mWorld; D3DXMATRIXA16 mView; D3DXMATRIXA16 mProj; D3DXMATRIXA16 mWorldViewProjection; // 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; } // Clear the render target and the zbuffer V( pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB( 0, 0, 0, 0 ), 1.0f, 0 ) ); //V( pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_COLORVALUE( 0.0f, 0.0f, 0.0f, 1.0f ), 1.0f, 0 ) ); // Render the scene if( SUCCEEDED( pd3dDevice->BeginScene() ) ) { // Get the projection & view matrix from the camera class //mWorld = *g_Camera.GetWorldMatrix(); mProj = *g_Camera.GetProjMatrix(); mView = *g_Camera.GetViewMatrix(); D3DXMatrixIdentity(&mWorld); //mWorldViewProjection = mWorld * mView * mProj; //* pd3dDevice->SetTransform(D3DTS_WORLD, &mWorld); pd3dDevice->SetTransform(D3DTS_VIEW, &mView); pd3dDevice->SetTransform(D3DTS_PROJECTION, &mProj); //*/ /* pd3dDevice->SetTransform(D3DTS_PROJECTION, &g_pCamera->m_mProj); pd3dDevice->SetTransform(D3DTS_VIEW, &g_pCamera->m_mView); pd3dDevice->SetTransform(D3DTS_WORLD, &mWorld); //*/ // Update the effect's variables. Instead of using strings, it would // be more efficient to cache a handle to the parameter by calling // ID3DXEffect::GetParameterByName /* V( g_pEffect9->SetMatrix( "g_mWorldViewProjection", &mWorldViewProjection ) ); V( g_pEffect9->SetMatrix( "g_mWorld", &mWorld ) ); V( g_pEffect9->SetFloat( "g_fTime", ( float )fTime ) ); */ pd3dDevice->SetRenderState( D3DRS_AMBIENT, D3DCOLOR_COLORVALUE( 0.8f, 0.8f, 0.8f, 1.0f )); pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, false ); pd3dDevice->SetRenderState( D3DRS_COLORVERTEX, true ); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Draw scene" ); particleSystem.render(); DXUT_EndPerfEvent(); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); // These events are to help PIX identify what the code is doing RenderText(); V( g_HUD.OnRender( fElapsedTime ) ); V( g_SampleUI.OnRender( fElapsedTime ) ); DXUT_EndPerfEvent(); V( pd3dDevice->EndScene() ); } }
//-------------------------------------------------------------------------------------- // Create any D3D9 resources that won't live through a device reset (D3DPOOL_DEFAULT) // or that are tied to the back buffer size //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D9ResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { #ifdef CONSOLE std::cout << "OnD3D9ResetDevice" << std::endl; #endif HRESULT hr; V_RETURN( g_DialogResourceManager.OnD3D9ResetDevice() ); V_RETURN( g_SettingsDlg.OnD3D9ResetDevice() ); if( g_pFont9 ) V_RETURN( g_pFont9->OnResetDevice() ); if( g_pEffect9 ) V_RETURN( g_pEffect9->OnResetDevice() ); V_RETURN( D3DXCreateSprite( pd3dDevice, &g_pSprite9 ) ); g_pTxtHelper = new CDXUTTextHelper( g_pFont9, g_pSprite9, NULL, NULL, 15 ); g_HUD.SetLocation( pBackBufferSurfaceDesc->Width - 170, 0 ); g_HUD.SetSize( 170, 170 ); g_SampleUI.SetLocation( pBackBufferSurfaceDesc->Width - 170, pBackBufferSurfaceDesc->Height - 350 ); g_SampleUI.SetSize( 170, 300 ); pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR ); pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR ); pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE ); //pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, TRUE ); pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE, TRUE ); pd3dDevice->SetRenderState( D3DRS_LIGHTING, false ); pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x80808080 ); D3DLIGHT9 light; D3DXVECTOR3 vecLightDirUnnormalized( 10.0f, -10.0f, 10.0f ); ZeroMemory( &light, sizeof( D3DLIGHT9 ) ); light.Type = D3DLIGHT_DIRECTIONAL; light.Diffuse.r = 1.0f; light.Diffuse.g = 1.0f; light.Diffuse.b = 1.0f; D3DXVec3Normalize( ( D3DXVECTOR3* )&light.Direction, &vecLightDirUnnormalized ); light.Position.x = 10.0f; light.Position.y = -10.0f; light.Position.z = 10.0f; light.Range = 1000.0f; pd3dDevice->SetLight( 0, &light ); pd3dDevice->LightEnable( 0, TRUE ); // Set the transform matrices D3DXMATRIXA16 matWorld; D3DXMatrixIdentity( &matWorld ); pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld ); // Setup the camera with view & projection matrix D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f ); D3DXVECTOR3 vecAt ( 0.0f, 0.0f, 0.0f ); g_Camera.SetViewParams( &vecEye, &vecAt ); float fAspectRatio = pBackBufferSurfaceDesc->Width / ( FLOAT )pBackBufferSurfaceDesc->Height; g_Camera.SetProjParams( D3DX_PI / 4, fAspectRatio, 1.0f, 1000.0f ); return S_OK; }