Example #1
0
void CALLBACK OnD3D11FrameRender(ID3D11Device* d3dDevice, ID3D11DeviceContext* d3dDeviceContext, double time,
                                 float elapsedTime, void* userContext)
{
	D3DXVECTOR3 cubePos;

    if (gZeroNextFrameTime) {
        elapsedTime = 0.0f;
    }
    gZeroNextFrameTime = false;

    if (gD3DSettingsDlg.IsActive()) {
        gD3DSettingsDlg.OnRender(elapsedTime);
        return;
    }

    // Lazily create the application if need be
    if (!gApp) {
        InitApp(d3dDevice);
    }

    // Lazily load scene
	/*!gMeshOpaque.IsLoaded() && !gMeshAlpha.IsLoaded() &&!gMeshOpaque2.IsLoaded()*/
    if (!sceneGraph.IsLoaded()) {
        InitScene(d3dDevice);
    }
	if(PXEngine)
	{
		for(int i = 0; i < cubeList->size(); i++)
		PXEngine->StepPhysX();
		if(cubeList)
		{
			for(int i = 0; i < cubeList->size(); i++)
			{
				if((*cubeList)[i]->id<0)
				{
					sceneGraph.SetInstancePosition(1,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
				}
				else
				{
					sceneGraph.SetMeshPosition(0,(*cubeList)[i]->id, (*cubeList)[i]->x, (*cubeList)[i]->y, (*cubeList)[i]->z);
				}
			}
		}
	}

	//crosshair
	D3DRECT rec2 = {screenCenterX-20, screenCenterY, screenCenterX + 20, screenCenterY + 2};
	D3DRECT rec3 = {screenCenterX, screenCenterY - 20, screenCenterX + 2, screenCenterY + 20};

    ID3D11RenderTargetView* pRTV = DXUTGetD3D11RenderTargetView();
	
    
    D3D11_VIEWPORT viewport;
    viewport.Width    = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Width);
    viewport.Height   = static_cast<float>(DXUTGetDXGIBackBufferSurfaceDesc()->Height);
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;
    viewport.TopLeftX = 0.0f;
    viewport.TopLeftY = 0.0f;
	screenCenterX = viewport.Width / 2;
	screenCenterY = viewport.Height / 2;

	gViewPort.Width = viewport.Width;
	gViewPort.Height = viewport.Height;
	gViewPort.MaxZ = viewport.MaxDepth;
	gViewPort.MinZ = viewport.MinDepth;
	gViewPort.X = viewport.TopLeftX;
	gViewPort.Y = viewport.TopLeftY;


		 gApp->Render(d3dDeviceContext, pRTV, sceneGraph, gSkyboxSRV,
        gWorldMatrix, &gViewerCamera, &viewport, &gUIConstants);
	
		 
		 sceneGraph.SetMeshPosition(0,1, 100000, 100000, 100000);
    if (gDisplayUI) {
        d3dDeviceContext->RSSetViewports(1, &viewport);

        // Render HUDs in reverse order
        d3dDeviceContext->OMSetRenderTargets(1, &pRTV, 0);
        for (int i = HUD_NUM - 1; i >= 0; --i) {
            gHUD[i].OnRender(elapsedTime);
        }

        // Render text
        gTextHelper->Begin();

        gTextHelper->SetInsertionPos(2, 0);
        gTextHelper->SetForegroundColor(D3DXCOLOR(1.0f, 1.0f, 0.0f, 1.0f));
        gTextHelper->DrawTextLine(DXUTGetFrameStats(DXUTIsVsyncEnabled()));
        //gTextHelper->DrawTextLine(DXUTGetDeviceStats());

        // Output frame time
        {
            std::wostringstream oss;
            oss << 1000.0f / DXUTGetFPS() << " ms / frame";
            gTextHelper->DrawTextLine(oss.str().c_str());
        }

        // Output light info
        {
            std::wostringstream oss;
            oss << "Lights: " << gApp->GetActiveLights();
            gTextHelper->DrawTextLine(oss.str().c_str());
        }
        
        gTextHelper->End();
    }
	
}
Example #2
0
File: App.cpp Project: Borzen/Awe
void App::RenderGBuffer(ID3D11DeviceContext* d3dDeviceContext,
                        SceneGraph& sceneGraph,
                        const CFirstPersonCamera* viewerCamera,
                        const D3D11_VIEWPORT* viewport,
                        const UIConstants* ui)
{
    // Clear GBuffer
    // NOTE: We actually only need to clear the depth buffer here since we replace unwritten (i.e. far plane) samples
    // with the skybox. We use the depth buffer to reconstruct position and only in-frustum positions are shaded.
    // NOTE: Complementary Z buffer: clear to 0 (far)!

#pragma region Set d3dDeviceContext 
    d3dDeviceContext->ClearDepthStencilView(mDepthBuffer->GetDepthStencil(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 0.0f, 0);

    d3dDeviceContext->IASetInputLayout(mMeshVertexLayout);

    d3dDeviceContext->VSSetConstantBuffers(0, 1, &mPerFrameConstants);
    d3dDeviceContext->VSSetShader(mGeometryVS->GetShader(), 0, 0);
    
    d3dDeviceContext->GSSetShader(0, 0, 0);

    d3dDeviceContext->RSSetViewports(1, viewport);

    d3dDeviceContext->PSSetConstantBuffers(0, 1, &mPerFrameConstants);
    d3dDeviceContext->PSSetSamplers(0, 1, &mDiffuseSampler);
    // Diffuse texture set per-material by DXUT mesh routines

    // Set up render GBuffer render targets
    d3dDeviceContext->OMSetDepthStencilState(mDepthState, 0);
    d3dDeviceContext->OMSetRenderTargets(static_cast<UINT>(mGBufferRTV.size()), &mGBufferRTV.front(), mDepthBuffer->GetDepthStencil());
    d3dDeviceContext->OMSetBlendState(mGeometryBlendState, 0, 0xFFFFFFFF);
	
#pragma endregion

	D3DXMATRIXA16 cameraProj = *viewerCamera->GetProjMatrix();
    D3DXMATRIXA16 cameraView = *viewerCamera->GetViewMatrix();
#pragma region Old Code
	/*D3DXMATRIXA16 worldMatrix;
	D3DXMATRIXA16 scaleMatrix;
	D3DXMatrixScaling(&scaleMatrix,0.05f,0.05f,0.05f);
	D3DXMatrixTranslation(&worldMatrix,0,0,0);
	
    //D3DXMATRIXA16 cameraViewProj = cameraView * cameraProj;
	*/
#pragma endregion
	if(sceneGraph.IsLoaded())
	{
		d3dDeviceContext->RSSetState(mRasterizerState);
        d3dDeviceContext->PSSetShader(mGBufferPS->GetShader(), 0, 0);
		sceneGraph.Render(d3dDeviceContext,mPerFrameConstants,cameraView,cameraProj);
	}
#pragma region Old Code
   /* D3DXMATRIXA16 cameraWorldViewProj =scaleMatrix * worldMatrix * cameraViewProj;
	
	D3D11_MAPPED_SUBRESOURCE mappedResource;
#pragma endregion

	// Fill in frame constants
#pragma region Frame constants
    {        
        d3dDeviceContext->Map(mPerFrameConstants, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
		PerFrameConstants* constants = static_cast<PerFrameConstants *>(mappedResource.pData);
		constants->mCameraWorldViewProj = scaleMatrix * worldMatrix * cameraViewProj;
		constants->mCameraWorldView = scaleMatrix * worldMatrix * cameraView;
		sceneGraph.ComputeInFrustumFlags(cameraWorldViewProj);
		//mesh_opaque.ComputeInFrustumFlags(cameraWorldViewProj,0);
		d3dDeviceContext->Unmap(mPerFrameConstants, 0);
	}
#pragma endregion

    // Render opaque geometry
    /*
	if (mesh_opaque.IsLoaded()) {
        d3dDeviceContext->RSSetState(mRasterizerState);
        d3dDeviceContext->PSSetShader(mGBufferPS->GetShader(), 0, 0);
        mesh_opaque.Render(d3dDeviceContext, 0);
    }

	// Fill in frame constants
#pragma region Frame constants
  /*  {D3DXMatrixTranslation(&worldMatrix,0,10,0);
        d3dDeviceContext->Map(mPerFrameConstants, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
		PerFrameConstants* constants = static_cast<PerFrameConstants *>(mappedResource.pData);
		constants->mCameraWorldViewProj = scaleMatrix * worldMatrix * cameraViewProj;
		constants->mCameraWorldView = scaleMatrix * worldMatrix * cameraView;
	//	if (mesh_opaque2.IsLoaded()) {
		//mesh_opaque2.ComputeInFrustumFlags(cameraWorldViewProj,0);
	//	}
		d3dDeviceContext->Unmap(mPerFrameConstants, 0);
	}*/
	
	/*
	if (mesh_opaque2.IsLoaded()) {
        d3dDeviceContext->RSSetState(mRasterizerState);
        d3dDeviceContext->PSSetShader(mGBufferPS->GetShader(), 0, 0);
        mesh_opaque2.Render(d3dDeviceContext, 0);
    }


    // Render alpha tested geometry
    if (mesh_alpha.IsLoaded()) {
        d3dDeviceContext->RSSetState(mDoubleSidedRasterizerState);
        d3dDeviceContext->PSSetShader(mGBufferAlphaTestPS->GetShader(), 0, 0);
        mesh_alpha.Render(d3dDeviceContext, 0);
    }
	*/

    // Cleanup (aka make the runtime happy)
#pragma endregion

    d3dDeviceContext->OMSetRenderTargets(0, 0, 0);
}