//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { // // Clear the back buffer // float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red, green, blue, alpha ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); // // Clear the depth stencil // ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // // Update variables that change once per frame // g_pWorldVariable->SetMatrix( ( float* )&g_World ); g_pMeshColorVariable->SetFloatVector( ( float* )g_vMeshColor ); // // Render the cube // D3D10_TECHNIQUE_DESC techDesc; g_pTechnique->GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; ++p ) { g_pTechnique->GetPassByIndex( p )->Apply( 0 ); pd3dDevice->DrawIndexed( 36, 0, 0 ); } }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D9 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { HRESULT hr = S_OK; float ClearColor[4] = { 0,0,0,0 }; ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // 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; } // Render the scene { D3DXVECTOR4 vLightDir( -1,1,-1,1 ); D3DXVec4Normalize( &vLightDir, &vLightDir ); g_pvWorldLightDir->SetFloatVector( ( float* )&vLightDir ); g_pfTime->SetFloat( ( float )fTime ); g_pfElapsedTime->SetFloat( fElapsedTime ); VisibilityCullTiles(); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Sky" ); RenderSky( pd3dDevice ); DXUT_EndPerfEvent(); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Terrain" ); RenderTerrain( pd3dDevice ); DXUT_EndPerfEvent(); if( g_bRenderBalls ) { DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Balls" ); RenderBalls( pd3dDevice ); DXUT_EndPerfEvent(); } if( g_bRenderGrass ) { DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"Render Grass" ); RenderGrass( pd3dDevice ); 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(); } }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { // Clear the render target float ClearColor[4] = { 0.9569f, 0.9569f, 1.0f, 0.0f }; ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // Render the result D3DXMATRIX mWorld; D3DXMATRIX mView; D3DXMATRIX mProj; D3DXMATRIX mWorldView; D3DXMATRIX mWorldViewProj; mWorld = *g_Camera.GetWorldMatrix(); mProj = *g_Camera.GetProjMatrix(); mView = *g_Camera.GetViewMatrix(); mWorldView = mWorld * mView; mWorldViewProj = mWorldView * mProj; // Set variables g_pmWorldViewProj->SetMatrix( ( float* )&mWorldViewProj ); g_pmWorldView->SetMatrix( ( float* )&mWorldView ); g_pmWorld->SetMatrix( ( float* )&mWorld ); g_pmView->SetMatrix( ( float* )&mView ); g_pmProj->SetMatrix( ( float* )&mProj ); g_pDiffuseTex->SetResource( g_pMeshTexRV ); D3DXVECTOR3 lightDir( -1,1,-1 ); D3DXVECTOR3 viewLightDir; D3DXVec3TransformNormal( &viewLightDir, &lightDir, &mView ); D3DXVec3Normalize( &viewLightDir, &viewLightDir ); g_pViewSpaceLightDir->SetFloatVector( ( float* )&viewLightDir ); // Set Input Assembler params UINT stride = g_VertStride; UINT offset = 0; pd3dDevice->IASetInputLayout( g_pVertexLayout ); pd3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST ); pd3dDevice->IASetIndexBuffer( g_pIB, DXGI_FORMAT_R32_UINT, 0 ); pd3dDevice->IASetVertexBuffers( 0, 1, &g_pVB, &stride, &offset ); // Render using the technique g_pRenderTextured D3D10_TECHNIQUE_DESC techDesc; g_pRenderTextured->GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; p++ ) { g_pRenderTextured->GetPassByIndex( p )->Apply( 0 ); pd3dDevice->DrawIndexed( g_NumIndices, 0, 0 ); } }
void D3DEngine::OnFrameRender(ID3D10Device* d3d_device, float elapsed_time) { // // Clear the back buffer // float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red, green, blue, alpha ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); d3d_device->ClearRenderTargetView( pRTV, ClearColor ); // // Clear the depth stencil // ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); d3d_device->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // // Update variables that change once per frame // world_variable_->SetMatrix( ( float* )&world_ ); // // Set the Vertex Layout // d3d_device->IASetInputLayout( vertex_layout_ ); // // Render the mesh // UINT Strides[1]; UINT Offsets[1]; ID3D10Buffer* pVB[1]; pVB[0] = mesh_.GetVB10( 0, 0 ); Strides[0] = ( UINT )mesh_.GetVertexStride( 0, 0 ); Offsets[0] = 0; d3d_device->IASetVertexBuffers( 0, 1, pVB, Strides, Offsets ); d3d_device->IASetIndexBuffer( mesh_.GetIB10( 0 ), mesh_.GetIBFormat10( 0 ), 0 ); D3D10_TECHNIQUE_DESC techDesc; technique_->GetDesc( &techDesc ); SDKMESH_SUBSET* pSubset = NULL; ID3D10ShaderResourceView* pDiffuseRV = NULL; D3D10_PRIMITIVE_TOPOLOGY PrimType; for( UINT p = 0; p < techDesc.Passes; ++p ) { for( UINT subset = 0; subset < mesh_.GetNumSubsets( 0 ); ++subset ) { pSubset = mesh_.GetSubset( 0, subset ); PrimType = mesh_.GetPrimitiveType10( ( SDKMESH_PRIMITIVE_TYPE )pSubset->PrimitiveType ); d3d_device->IASetPrimitiveTopology( PrimType ); pDiffuseRV = mesh_.GetMaterial( pSubset->MaterialID )->pDiffuseRV10; diffuse_variable_->SetResource( pDiffuseRV ); technique_->GetPassByIndex( p )->Apply( 0 ); d3d_device->DrawIndexed( ( UINT )pSubset->IndexCount, 0, ( UINT )pSubset->VertexStart ); } } //the mesh class also had a render method that allows rendering the mesh with the most common options mesh_.Render(d3d_device, technique_, diffuse_variable_); }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { // Clear the render target float ClearColor[4] = { 0.9569f, 0.9569f, 1.0f, 0.0f }; ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); D3DXMATRIX mWorld; D3DXMATRIX mView; D3DXMATRIX mProj; D3DXMATRIX mWorldView; D3DXMATRIX mWorldViewProj; mWorld = *g_Camera.GetWorldMatrix(); mProj = *g_Camera.GetProjMatrix(); mView = *g_Camera.GetViewMatrix(); mWorldView = mWorld * mView; mWorldViewProj = mWorldView * mProj; // Set variables g_pmWorldViewProj->SetMatrix( ( float* )&mWorldViewProj ); g_pmWorldView->SetMatrix( ( float* )&mWorldView ); g_pmWorld->SetMatrix( ( float* )&mWorld ); g_pmProj->SetMatrix( ( float* )&mProj ); g_pDiffuseTex->SetResource( g_pMeshTexRV ); D3DXVECTOR3 lightDir( -1,1,-1 ); D3DXVECTOR3 viewLightDir; D3DXVec3TransformNormal( &viewLightDir, &lightDir, &mView ); D3DXVec3Normalize( &viewLightDir, &viewLightDir ); g_pViewSpaceLightDir->SetFloatVector( ( float* )&viewLightDir ); // Get VB and IB UINT offset = 0; UINT stride = g_Mesh.GetVertexStride( 0, 0 ); ID3D10Buffer* pVB = g_Mesh.GetVB10( 0, 0 ); ID3D10Buffer* pIB = g_Mesh.GetAdjIB10( 0 ); // Set Input Assembler params pd3dDevice->IASetInputLayout( g_pVertexLayout ); pd3dDevice->IASetIndexBuffer( pIB, g_Mesh.GetIBFormat10( 0 ), 0 ); pd3dDevice->IASetVertexBuffers( 0, 1, &pVB, &stride, &offset ); pd3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ ); // Render using the technique g_pRenderTextured SDKMESH_SUBSET* pSubset = NULL; D3D10_TECHNIQUE_DESC techDesc; g_pRenderTextured->GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; p++ ) { g_pRenderTextured->GetPassByIndex( p )->Apply( 0 ); for( UINT subset = 0; subset < g_Mesh.GetNumSubsets( 0 ); subset++ ) { pSubset = g_Mesh.GetSubset( 0, subset ); pd3dDevice->DrawIndexed( ( UINT )pSubset->IndexCount * 2, ( UINT )pSubset->IndexStart, ( UINT )pSubset->VertexStart ); } } // Render the chess piece just for show // Render using the technique g_pRenderPiece g_pRenderPiece->GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; p++ ) { g_pRenderPiece->GetPassByIndex( p )->Apply( 0 ); for( UINT subset = 0; subset < g_Mesh.GetNumSubsets( 0 ); subset++ ) { pSubset = g_Mesh.GetSubset( 0, subset ); pd3dDevice->DrawIndexed( ( UINT )pSubset->IndexCount * 2, ( UINT )pSubset->IndexStart, ( UINT )pSubset->VertexStart ); } } }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { // Clear the render target float ClearColor[4] = { 0.9569f, 0.9569f, 1.0f, 0.0f }; ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // Make sure we only grow the tree the first time we go to render. // If we recreated the same tree every frame, we would definitely waste time. static bool bFirst = true; if( bFirst ) { //----------------------------------------------------------------------------------------- // o/__ <-- BreakdancinBob NOTE: Give the grow algorithm access to the random buffer // | (\ //----------------------------------------------------------------------------------------- g_pRandomBuf->SetResource( g_pRandomBufferRV ); // Grow the branches one step at a time for( UINT i = 0; i < g_NumGrowthSpurts; i++ ) { GrowBranches( pd3dDevice ); } bFirst = false; } // Render the result D3DXMATRIX mWorld; D3DXMATRIX mView; D3DXMATRIX mProj; D3DXMATRIX mWorldViewProj; D3DXMATRIX mWorldView; mWorld = *g_Camera.GetWorldMatrix(); mProj = *g_Camera.GetProjMatrix(); mView = *g_Camera.GetViewMatrix(); mWorldView = mWorld * mView; mWorldViewProj = mWorldView * mProj; // Set variables g_pmWorldViewProj->SetMatrix( ( float* )&mWorldViewProj ); g_pmWorld->SetMatrix( ( float* )&mWorld ); g_pmWorldView->SetMatrix( ( float* )&mWorldView ); g_pDiffuseTex->SetResource( g_pMeshTexRV ); D3DXVECTOR3 lightDir( -1,1,-1 ); D3DXVECTOR3 viewLightDir; D3DXVec3TransformNormal( &viewLightDir, &lightDir, &mView ); D3DXVec3Normalize( &viewLightDir, &viewLightDir ); g_pViewSpaceLightDir->SetFloatVector( ( float* )&viewLightDir ); // Set Input Assembler params ID3D10Buffer* pBuffers[1]; pBuffers[0] = g_pDrawFrom; UINT stride = g_VertStride; UINT offset = 0; pd3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST ); pd3dDevice->IASetVertexBuffers( 0, 1, pBuffers, &stride, &offset ); // Render using the technique g_pRenderTextured D3D10_TECHNIQUE_DESC techDesc; g_pRenderTextured->GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; p++ ) { g_pRenderTextured->GetPassByIndex( p )->Apply( 0 ); pd3dDevice->DrawAuto(); } }
//-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender(ID3D10Device* pDev10, double fTime, float fElapsedTime, void* pUserContext) { HRESULT hr; g_pCamManager->SyncToCameraUI(g_CameraUI); //dont delete, used no only here const DXGI_SURFACE_DESC *pBackBufferSurfaceDesc = DXUTGetDXGIBackBufferSurfaceDesc(); if( ShadowAlgorithm != OldShadowAlgorithm ) { OldShadowAlgorithm = ShadowAlgorithm; switch( ShadowAlgorithm ) { case STANDARD_BP: g_ABP.OnD3D10DestroyDevice(); break; case BP_MSSM_KERNEL: g_BPMSSMKernel.OnD3D10DestroyDevice(); break; case STD_VSM: g_StdVSM.OnD3D10DestroyDevice(); break; case MIP_VSM: g_MipVSM.OnD3D10DestroyDevice(); break; case HIR_BP: g_HBP.OnD3D10DestroyDevice(); break; case BP_GI: g_BPGI.OnD3D10DestroyDevice(); break; case STD_PCSS: g_PCSS.OnD3D10DestroyDevice(); break; default: break; }; switch( ShadowAlgorithm ) { case STANDARD_BP: g_ABP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_ABP.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case BP_MSSM_KERNEL: g_BPMSSMKernel.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_BPMSSMKernel.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case STD_VSM: g_StdVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_StdVSM.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case MIP_VSM: g_MipVSM.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_MipVSM.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case HIR_BP: g_HBP.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_HBP.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case BP_GI: g_BPGI.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_BPGI.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; case STD_PCSS: g_PCSS.OnD3D10CreateDevice(pDev10,pBackBufferSurfaceDesc,pUserContext); g_PCSS.OnD3D10SwapChainResized(pDev10,NULL,pBackBufferSurfaceDesc,pUserContext ); break; default: break; }; } //begin light and view pos management { static double old_fTime = 0.001; fTime = old_fTime; old_fTime += 0.02; static double oldTime = 0; static unsigned old_iSta = 0; static double stop_time = 0; static double total_stop_time = 0; double tmp = fTime; unsigned iSta = g_SampleUI.GetCheckBox(IDC_STATIC)->GetChecked(); if( 0 == old_iSta && 1 == iSta )//turn to be static { stop_time = fTime - total_stop_time; } if( 1 == iSta ) { total_stop_time += ( fTime - oldTime ); fTime = stop_time; } if( 0 == iSta ) { fTime -= total_stop_time; } old_iSta = iSta; oldTime = tmp; }//end light and view pos management S3UTCamera& g_CameraRef = *(g_pCamManager->ActiveEye()); // compute view matrix D3DXMATRIX mTmp, mWorldView, mWorldViewProj, mWorldViewInv; D3DXMatrixInverse(&mTmp, NULL, g_CameraRef.GetWorldMatrix()); D3DXMatrixMultiply(&mWorldView, &mTmp, g_CameraRef.GetViewMatrix()); // correct near/far clip planes according to camera location D3DXVECTOR3 vBox[2]; float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height; // clear depth and color ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pDev10->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0); ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); if( g_D3DSettingsDlg.IsActive() ) { g_D3DSettingsDlg.OnRender( fElapsedTime ); return; } Parameters para; para.fLightZn = g_fCtrledLightZn; float biases[15]; biases[0] = g_fDepthBiasObject0; biases[1] = g_fDefaultDepthBias; biases[2] = g_fDepthBiasHammer; biases[3] = g_fDepthBiasLeftForearm; biases[4] = g_fDepthBiasRightForearm; biases[5] = g_fDepthBiasLeftShoulder; biases[6] = g_fDepthBiasRightShoulder; biases[7] = g_fDepthBiasBlackPlate; biases[8] = g_fDepthBiasHelmet; biases[9] = g_fDepthBiasEyes; biases[10] = g_fDepthBiasBelt; biases[11] = g_fDepthBiasLeftThigh; biases[12] = g_fDepthBiasRightThigh; biases[13] = g_fDepthBiasLeftShin; biases[14] = g_fDepthBiasRightShin; g_MeshScene.set_biases(biases,15); float light_size[NUM_LIGHT] = LIGHT_SIZE; float light_ZNS[NUM_LIGHT] = LIGHT_ZNS; float light_view_angle[NUM_LIGHT] = LIGHT_VIEW_ANGLES; D3DXVECTOR4 light_color[NUM_LIGHT] = LIGHT_COLOR; bool render_ogre = g_SampleUI.GetCheckBox( IDC_ANIMATE )->GetChecked(); bool render_scene = g_SampleUI.GetCheckBox( IDC_SCENE )->GetChecked(); bool render_fan = g_SampleUI.GetCheckBox( IDC_FAN )->GetChecked(); float ClearColor[4] = { 0, 0, 0, 1 }; pDev10->ClearRenderTargetView(g_pBlendBuffer->m_pRTView, ClearColor); //use alpha val 1 to represent untouched pixels pDev10->ClearRenderTargetView(g_pWidgetBuffer->m_pRTView, ClearColor); //light management ID3D10RenderTargetView *p_RTV; ID3D10ShaderResourceView *p_SRV; static float light_scale_factor = 0.2; static float ls_incre = 0.04; if( g_LightVary == true || g_fFilterSize < g_fFilterSizeCtrl ) { g_fFilterSize -= ls_incre; if( g_fFilterSize < 0.1 || g_fFilterSize > g_fFilterSizeCtrl ) ls_incre = -ls_incre; } else { g_fFilterSize = g_fFilterSizeCtrl; } g_fFilterSize = g_fFilterSizeCtrl; //light pos is not modified here. this light pos stored in 3DWidget is only synced with light camera after rendering of the light //if you try to modify light pos here, light would be freezed, of course, this is a bug introduced by bad design D3DXVECTOR3 vTmp; // render GBuffer pDev10->OMSetDepthStencilState(g_pDSState,0); g_GBuffer.OnD3D10FrameRender( true, true, g_SampleUI, g_MeshScene, g_CameraRef, pDev10, fTime, fElapsedTime, pUserContext ); g_Blender.OriginalSampleMask = 0; pDev10->OMGetBlendState( &g_Blender.pOriginalBlendState, g_Blender.OriginalBlendFactor, &g_Blender.OriginalSampleMask ); float BlendBufferClearColor[4] = { 1, 1, 0, 1 }; bool isFirstPass = true; for( int cam_idx = 0; cam_idx < g_pCamManager->CameraCount(); ++cam_idx ) { // rendering a subdivided light if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&& g_pCamManager->Camera(cam_idx)->IsActive() ) { float scaled_half_light_size = (g_pCamManager->Camera(cam_idx)->GetLightSize()*LIGHT_SCALE_FACTOR); float fStartPt = -scaled_half_light_size; float fInterval = 2 * scaled_half_light_size / g_nNumLightSample; float fSubLightSize = g_pCamManager->Camera(cam_idx)->GetLightSize(); if( g_nNumLightSample > 0 ) { fSubLightSize = fSubLightSize / g_nNumLightSample; } if( g_nNumLightSample == 0 ) { g_nNumLightSample = 1; } static float total_light_x_incre = 0; static int light_mov_dir = 0; float shadow_factor = 0.8/(g_nNumLightSample * g_nNumLightSample); for( int ix = 0; ix < g_nNumLightSample; ++ix ) { for( int iy = 0; iy < g_nNumLightSample; ++iy ) { D3DXVECTOR3 vLight = *g_pCamManager->Camera(cam_idx)->GetEyePt(); S3UTCamera local_cam = *g_pCamManager->Camera(cam_idx); D3DXVECTOR3 vTrans( fStartPt+(ix+0.5)*fInterval,fStartPt+(iy+0.5)*fInterval,0 ); if( g_nNumLightSample == 1 ) { vTrans = D3DXVECTOR3(0,0,0); } D3DXMATRIX mInvLightView; D3DXVECTOR4 tmp_light_pos; D3DXMatrixInverse(&mInvLightView, NULL, local_cam.GetViewMatrix()); D3DXVec3Transform(&tmp_light_pos, &vTrans, &mInvLightView ); D3DXVECTOR3 tmp_light_pos_3(tmp_light_pos.x,tmp_light_pos.y,tmp_light_pos.z); D3DXVECTOR3 vLookAt = *local_cam.GetLookAtPt(); local_cam.SetViewParams( &tmp_light_pos_3, &vLookAt ); g_MeshScene.set_parameters( render_ogre, render_scene, render_fan, false ); D3DXMATRIX mLightView; // here we compute light viewprojection so that light oversees the whole scene D3DXMATRIX mTranslate; D3DXMatrixInverse(&mTranslate, NULL, local_cam.GetWorldMatrix()); D3DXMatrixMultiply(&mLightView, &mTranslate, local_cam.GetViewMatrix()); unsigned iTmp = g_SampleUI.GetCheckBox(IDC_BDUMP_SHADOWMAP)->GetChecked(); ssmap.Render(pDev10, &g_MeshScene, local_cam,fTime,fElapsedTime,iTmp); pDev10->RSSetState(g_pRenderState); p_RTV = g_pBlendBuffer->m_pRTView; float NewBlendFactor[4] = {0,0,0,0}; //alpha blending initial; if( isFirstPass ) { isFirstPass = false; pDev10->OMSetBlendState( g_Blender.m_pSceneBlendStateInitial, NewBlendFactor, 0xffffffff ); } else { pDev10->OMSetBlendState( g_Blender.m_pSceneBlendStateOn, NewBlendFactor, 0xffffffff ); } if( ShadowAlgorithm == BP_GI ) { V(g_BPGI.m_pEffect->GetVariableByName("g_fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_BPGI.set_parameters( para,p_RTV,&light_color[0] ); g_BPGI.set_input_buffer( &g_GBuffer ); g_BPGI.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } else if( ShadowAlgorithm == STANDARD_BP ) { V(g_ABP.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_ABP.set_parameters( para,p_RTV,&light_color[0] ); g_ABP.set_input_buffer( &g_GBuffer ); g_ABP.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } else if( ShadowAlgorithm == BP_MSSM_KERNEL ) { V(g_BPMSSMKernel.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_BPMSSMKernel.set_parameters( para,p_RTV,&light_color[0] ); g_BPMSSMKernel.set_input_buffer( &g_GBuffer ); g_BPMSSMKernel.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } else if( ShadowAlgorithm == STD_VSM ) { V(g_StdVSM.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_StdVSM.set_bias( g_fDefaultDepthBias,g_f3rdDepthDelta, g_f1stDepthDelta ); g_StdVSM.set_parameters( para,p_RTV,&light_color[0] ); g_StdVSM.set_input_buffer( &g_GBuffer ); g_StdVSM.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } else if( ShadowAlgorithm == MIP_VSM ) { V(g_MipVSM.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_MipVSM.set_parameters( para,p_RTV,&light_color[0] ); g_MipVSM.set_input_buffer( &g_GBuffer ); g_MipVSM.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } else if( ShadowAlgorithm == STD_PCSS ) { V(g_PCSS.m_pEffect->GetVariableByName("fLumiFactor")->AsScalar()->SetFloat( shadow_factor )); g_PCSS.set_parameters( para,p_RTV,&light_color[0] ); g_PCSS.set_input_buffer( &g_GBuffer ); g_PCSS.OnD3D10FrameRender(render_ogre,render_scene,g_SampleUI,g_MeshScene,fSubLightSize,ssmap,g_CameraRef,local_cam,pDev10,fTime,fElapsedTime,pUserContext); } //alpha blending restore pDev10->OMSetBlendState( g_Blender.pOriginalBlendState, g_Blender.OriginalBlendFactor, g_Blender.OriginalSampleMask ); if( g_SampleUI.GetCheckBox( IDC_SHOW_3DWIDGET )->GetChecked() ) { if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&& g_pCamManager->Camera(cam_idx)->IsActive() ) { pDev10->OMSetRenderTargets(1, &(g_pWidgetBuffer->m_pRTView), g_GBuffer.m_pDepthBuffer->m_pDSView); g_Widget.m_pSsmap = &ssmap; g_Widget.OnD3D10FrameRender(pDev10,g_CameraRef,local_cam); } } } } } } //----------------------------------------------------------------------------------- D3DXMATRIX mMatrixScale; D3DXMATRIX mMatrixScaleWVP; D3DXMatrixScaling( &mMatrixScale,(FLOAT)5,(FLOAT)5,(FLOAT)5 ); D3DXMatrixMultiply( &mMatrixScaleWVP, &mMatrixScale, &mWorldViewProj ); ID3D10RenderTargetView* pOrigRTV = DXUTGetD3D10RenderTargetView(); pDev10->OMSetRenderTargets(1,&pOrigRTV,NULL); float FinalClearColor[4] = { 1, 0, 0, 1 }; pDev10->ClearRenderTargetView(pOrigRTV, FinalClearColor); g_MeshScene.set_parameters( render_ogre,render_scene, render_fan ); g_Final.set_parameters( para, pOrigRTV, NULL, g_pBlendBuffer->m_pSRView, g_pWidgetBuffer->m_pSRView ); S3UTCamera& g_LCameraRef = g_LCamera[0]; g_Final.set_input_buffer( &g_GBuffer ); g_pSkyBox->OnFrameRender( mMatrixScaleWVP ); g_Final.OnD3D10FrameRender(g_SampleUI,g_MeshScene,g_fFilterSize,ssmap,g_CameraRef,g_LCameraRef,pDev10,fTime,fElapsedTime,pUserContext); g_LCameraRef.SetProjParams(g_fCtrledLightFov, 1.0, g_fCtrledLightZn, g_fCtrledLightZf); //if( g_SampleUI.GetCheckBox( IDC_SHOW_3DWIDGET )->GetChecked() ) //{ // for( int cam_idx = 0; cam_idx < g_pCamManager->CameraCount(); ++cam_idx ) // { // // rendering a subdivided light // if( g_pCamManager->Camera(cam_idx)->GetCamType() == S3UTCamera::eLight&& // g_pCamManager->Camera(cam_idx)->IsActive() ) // { // g_Widget.m_pSsmap = &ssmap; // g_Widget.OnD3D10FrameRender(pDev10,g_CameraRef,*(g_pCamManager->Camera(cam_idx))); // } // } //} // render UI if (g_bShowUI) { RenderText(); g_SampleUI.OnRender(fElapsedTime); //g_HUD.OnRender(fElapsedTime); } if( g_bShowLightUI ) { g_CameraUI.OnRender(fElapsedTime); } if( g_SampleUI.GetCheckBox( IDC_FRAME_DUMP )->GetChecked() ) { static int g_Frame = 0; IDXGISwapChain* pSwapChain = DXUTGetDXGISwapChain(); ID3D10Texture2D* pRT; pSwapChain->GetBuffer(0, __uuidof(pRT), reinterpret_cast<void**>(&pRT)); WCHAR filename[32]; StringCchPrintf(filename, 100, L"DumpedImages\\screenshot%.3d.jpg", g_Frame); D3DX10SaveTextureToFile(pRT, D3DX10_IFF_JPG, filename); SAFE_RELEASE(pRT); ++g_Frame; } }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, 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_D3DSettingsDlg.IsActive() ) { g_D3DSettingsDlg.OnRender( fElapsedTime ); return; } // // Clear the back buffer // float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; // red, green, blue, alpha ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); // // Clear the depth stencil // ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // // Update variables that change once per frame // g_pProjectionVariable->SetMatrix( ( float* )g_Camera.GetProjMatrix() ); g_pViewVariable->SetMatrix( ( float* )g_Camera.GetViewMatrix() ); g_pWorldVariable->SetMatrix( ( float* )&g_World ); // // Set the Vertex Layout // pd3dDevice->IASetInputLayout( g_pVertexLayout ); // // Render the mesh // UINT Strides[1]; UINT Offsets[1]; ID3D10Buffer* pVB[1]; pVB[0] = g_Mesh.GetVB10( 0, 0 ); Strides[0] = ( UINT )g_Mesh.GetVertexStride( 0, 0 ); Offsets[0] = 0; pd3dDevice->IASetVertexBuffers( 0, 1, pVB, Strides, Offsets ); pd3dDevice->IASetIndexBuffer( g_Mesh.GetIB10( 0 ), g_Mesh.GetIBFormat10( 0 ), 0 ); D3D10_TECHNIQUE_DESC techDesc; g_pTechnique->GetDesc( &techDesc ); SDKMESH_SUBSET* pSubset = NULL; ID3D10ShaderResourceView* pDiffuseRV = NULL; D3D10_PRIMITIVE_TOPOLOGY PrimType; for( UINT p = 0; p < techDesc.Passes; ++p ) { for( UINT subset = 0; subset < g_Mesh.GetNumSubsets( 0 ); ++subset ) { pSubset = g_Mesh.GetSubset( 0, subset ); PrimType = g_Mesh.GetPrimitiveType10( ( SDKMESH_PRIMITIVE_TYPE )pSubset->PrimitiveType ); pd3dDevice->IASetPrimitiveTopology( PrimType ); pDiffuseRV = g_Mesh.GetMaterial( pSubset->MaterialID )->pDiffuseRV10; g_ptxDiffuseVariable->SetResource( pDiffuseRV ); g_pTechnique->GetPassByIndex( p )->Apply( 0 ); pd3dDevice->DrawIndexed( ( UINT )pSubset->IndexCount, 0, ( UINT )pSubset->VertexStart ); } } //the mesh class also had a render method that allows rendering the mesh with the most common options //g_Mesh.Render( pd3dDevice, g_pTechnique, g_ptxDiffuseVariable ); // // Render the UI // g_HUD.OnRender( fElapsedTime ); g_SampleUI.OnRender( fElapsedTime ); RenderText(); }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, 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; } // // Clear the back buffer // float ClearColor[4] = { .0f, 0.0f, 0.0f, 1.0f } ; // red, green, blue, alpha ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); // // Clear the depth stencil // ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // // Update the Cull Mode (non-FX method) setup the render state // pd3dDevice->RSSetState( g_pRasterStates[ 0 ] ); HRESULT hr; D3DXMATRIXA16 mWorld; D3DXMATRIXA16 mView; D3DXMATRIXA16 mProj; D3DXMATRIXA16 mWorldViewProjection; // Get the projection & view matrix from the camera class mWorld = *g_Camera.GetWorldMatrix(); mView = *g_Camera.GetViewMatrix(); mProj = *g_Camera.GetProjMatrix(); mWorldViewProjection = mWorld * mView * mProj; // Update the effect's variables. V( g_pWorldViewProjection->SetMatrix( (float*)&mWorldViewProjection ) ); V( g_pWorld->SetMatrix( (float*)&mWorld ) ); V( g_pTime->SetFloat( (float)fTime ) ); V( g_pCameraPosition->SetFloatVector( (float*)g_Camera.GetEyePt() ) ); // Blend pd3dDevice->OMSetDepthStencilState(0, 0); float blendFactor[] = {0.0f, 0.0f, 0.0f, 0.0f}; pd3dDevice->OMSetBlendState(0, blendFactor, 0xffffffff); // // Set the Vertex Layout // pd3dDevice->IASetInputLayout( g_pVertexLayout ); UINT iCurSubset = ( UINT )( INT_PTR )g_SampleUI.GetComboBox( IDC_SUBSET )->GetSelectedData(); // // Render the mesh // // Stop render the loader mesh bool drawLoaderMesh = true; if (drawLoaderMesh) { if ( iCurSubset == -1 ) { for ( UINT iSubset = 0; iSubset < g_MeshLoader.GetNumSubsets(); ++iSubset ) { RenderSubset( iSubset ); } } else { RenderSubset( iCurSubset ); } } // // Render the Cube // //UINT cubeAttributCount; // This is not efficiency this procedure will always call to the GPU // To get the number of suset. //g_TrialCube->GetAttributeTable(NULL, &cubeAttributCount); //for (UINT iSubset = 0; iSubset < cubeAttributCount; iSubset++) //{ // g_TrialCube->DrawSubset(iSubset); //} //g_TrialCube->DrawSubset(0); pd3dDevice->RSSetState( g_pRasterStates[ g_eSceneRasterizerMode ] ); pd3dDevice->OMSetBlendState(g_TransparentBS, blendFactor, 0xffffffff); //g_pBox->draw(); bool drawAABBLevel=false; if (drawAABBLevel){ g_AABBConstructor->DrawLevel(g_CurrentAABBLevel); } // g_FunctionDraw->DrawFunction(); g_ParabolaDis->Draw(); //g_UVFileDisp->Draw(); //g_AABBConstructor->DrawAllAABBDetial(); // // Reset our Cull Mode (non-FX method) // pd3dDevice->RSSetState( g_pRasterStates[ 0 ] ); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); RenderText(); g_HUD.OnRender( fElapsedTime ); g_SampleUI.OnRender( fElapsedTime ); DXUT_EndPerfEvent(); }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, 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; } // // Clear the back buffer // float ClearColor[4] = { 0.3f, 0.3f, 0.3f, 1.0f } ; // red, green, blue, alpha ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); // // Clear the depth stencil // ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); HRESULT hr; D3DXMATRIXA16 mWorld; D3DXMATRIXA16 mView; D3DXMATRIXA16 mProj; D3DXMATRIXA16 mWorldViewProjection; // Get the projection & view matrix from the camera class mWorld = *g_Camera.GetWorldMatrix(); mView = *g_Camera.GetViewMatrix(); mProj = *g_Camera.GetProjMatrix(); mWorldViewProjection = mWorld * mView * mProj; // Update the effect's variables. V( g_pWorldViewProjection->SetMatrix( (float*)&mWorldViewProjection ) ); V( g_pWorld->SetMatrix( (float*)&mWorld ) ); V( g_pTime->SetFloat( (float)fTime ) ); V( g_pCameraPosition->SetFloatVector( (float*)g_Camera.GetEyePt() ) ); // // Set the Vertex Layout // pd3dDevice->IASetInputLayout( g_pVertexLayout ); UINT iCurSubset = ( UINT )( INT_PTR )g_SampleUI.GetComboBox( IDC_SUBSET )->GetSelectedData(); // // Render the mesh // if ( iCurSubset == -1 ) { for ( UINT iSubset = 0; iSubset < g_MeshLoader.GetNumSubsets(); ++iSubset ) { RenderSubset( iSubset ); } } else { RenderSubset( iCurSubset ); } DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); RenderText(); g_HUD.OnRender( fElapsedTime ); g_SampleUI.OnRender( fElapsedTime ); DXUT_EndPerfEvent(); }
//-------------------------------------------------------------------------------------- // Render the scene using the D3D10 device //-------------------------------------------------------------------------------------- void CALLBACK OnD3D10FrameRender( ID3D10Device* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { float ClearColor[4] = { 1.0f, 1.0f, 1.0f, 0.0f }; // R, G, B, A ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView(); pd3dDevice->ClearRenderTargetView( pRTV, ClearColor ); ID3D10DepthStencilView* pDSV = DXUTGetD3D10DepthStencilView(); pd3dDevice->ClearDepthStencilView( pDSV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // 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; } // Set our render target since we can't present multisampled ref ID3D10RenderTargetView* pOrigRT; ID3D10DepthStencilView* pOrigDS; pd3dDevice->OMGetRenderTargets( 1, &pOrigRT, &pOrigDS ); ID3D10RenderTargetView* aRTViews[ 1 ] = { g_pRTRV }; pd3dDevice->OMSetRenderTargets( 1, aRTViews, g_pDSRV ); pd3dDevice->ClearRenderTargetView( g_pRTRV, ClearColor ); pd3dDevice->ClearDepthStencilView( g_pDSRV, D3D10_CLEAR_DEPTH, 1.0, 0 ); // Set Matrices D3DXMATRIX mWorldViewProj; D3DXMATRIX mWorldView; D3DXMATRIX mViewProj; D3DXMATRIX mWorld; D3DXMATRIX mView; D3DXMATRIX mProj; // Fix the camera motion for now D3DXMATRIX mBlurViewProj[MAX_TIME_STEPS]; for( int i = 0; i < MAX_TIME_STEPS; i++ ) { mView = *g_Camera.GetViewMatrix(); mProj = *g_Camera.GetProjMatrix(); mBlurViewProj[i] = mView * mProj; } g_pmBlurViewProj->SetMatrixArray( ( float* )mBlurViewProj, 0, MAX_TIME_STEPS ); D3DXMatrixIdentity( &mWorld ); mView = *g_Camera.GetViewMatrix(); mProj = *g_Camera.GetProjMatrix(); mViewProj = mView * mProj; mWorldViewProj = mWorld * mViewProj; mWorldView = mWorld * mView; g_pmWorldViewProj->SetMatrix( ( float* )&mWorldViewProj ); g_pmViewProj->SetMatrix( ( float* )&mViewProj ); g_pmWorldView->SetMatrix( ( float* )&mWorldView ); RenderSceneMesh( pd3dDevice, &g_SceneMesh, false ); RenderFanMesh( pd3dDevice, &g_FanMesh, fTime, false ); if( g_bRenderOgre ) RenderSkinnedMesh( pd3dDevice, &g_AnimMesh, fTime, false ); for( UINT iMesh = 0; iMesh < g_NumLinkedMeshes; iMesh++ ) RenderLinkedMesh( pd3dDevice, &g_pLinkedMeshes[iMesh], &g_AnimMesh, g_MeshLinkages[iMesh].iBone, fTime, false ); if( g_bUseMotionBlur ) { RenderFanMesh( pd3dDevice, &g_FanMesh, fTime, true ); if( g_bRenderOgre ) RenderSkinnedMesh( pd3dDevice, &g_AnimMesh, fTime, true ); for( UINT iMesh = 0; iMesh < g_NumLinkedMeshes; iMesh++ ) RenderLinkedMesh( pd3dDevice, &g_pLinkedMeshes[iMesh], &g_AnimMesh, g_MeshLinkages[iMesh].iBone, fTime, true ); } //MSAA resolve ID3D10Resource* pRT; pOrigRT->GetResource( &pRT ); D3D10_RENDER_TARGET_VIEW_DESC rtDesc; pOrigRT->GetDesc( &rtDesc ); pd3dDevice->ResolveSubresource( pRT, D3D10CalcSubresource( 0, 0, 1 ), g_pRenderTarget, D3D10CalcSubresource( 0, 0, 1 ), rtDesc.Format ); SAFE_RELEASE( pRT ); // Use our Old RT again aRTViews[0] = pOrigRT; pd3dDevice->OMSetRenderTargets( 1, aRTViews, pOrigDS ); SAFE_RELEASE( pOrigRT ); SAFE_RELEASE( pOrigDS ); DXUT_BeginPerfEvent( DXUT_PERFEVENTCOLOR, L"HUD / Stats" ); RenderText(); g_HUD.OnRender( fElapsedTime ); g_SampleUI.OnRender( fElapsedTime ); DXUT_EndPerfEvent(); }