自学教程：C++ GetInputDesc函数代码示例

void FRCPassPostProcessAA::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessAA);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.ViewRect;	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);		// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	switch(Quality)	{		case 1:  SetShaderTemplAA<1>(Context); break;		case 2:  SetShaderTemplAA<2>(Context); break;		case 3:  SetShaderTemplAA<3>(Context); break;		case 4:  SetShaderTemplAA<4>(Context); break;		case 5:  SetShaderTemplAA<5>(Context); break;		default: SetShaderTemplAA<6>(Context); break;	}		// Draw a quad mapping scene color to the view's render target	TShaderMapRef<FFXAAVS> VertexShader(Context.GetShaderMap());	DrawRectangle(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		*VertexShader,		EDRF_Default);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessLensBlur::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PassPostProcessLensBlur);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);		if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	FIntPoint TexSize = InputDesc->Extent;	// usually 1, 2, 4 or 8	uint32 ScaleToFullRes = GSceneRenderTargets.GetBufferSizeXY().X / TexSize.X;	FIntRect ViewRect = FIntRect::DivideAndRoundUp(View.ViewRect, ScaleToFullRes);	FIntPoint ViewSize = ViewRect.Size();	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef(), ESimpleRenderTargetMode::EClearColorToBlack);	Context.SetViewportAndCallRHI(ViewRect);	// set the state (additive blending)	Context.RHICmdList.SetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_One, BF_One>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessLensBlurVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessLensBlurPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GEmptyVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	uint32 TileSize = 1;	FIntPoint TileCount = ViewSize / TileSize;	float PixelKernelSize = PercentKernelSize / 100.0f * ViewSize.X;	VertexShader->SetParameters(Context, TileCount, TileSize, PixelKernelSize, Threshold);	PixelShader->SetParameters(Context, PixelKernelSize);	Context.RHICmdList.SetStreamSource(0, NULL, 0, 0);	// needs to be the same on shader side (faster on NVIDIA and AMD)	int32 QuadsPerInstance = 4;	Context.RHICmdList.DrawPrimitive(PT_TriangleList, 0, 2, FMath::DivideAndRoundUp(TileCount.X * TileCount.Y, QuadsPerInstance));	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessMorpheus::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessMorpheus);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.UnscaledViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(DestRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessMorpheusVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessMorpheusPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	FMatrix QuadTexTransform;	FMatrix QuadPosTransform = FMatrix::Identity;	PixelShader->SetPS(Context, SrcRect, SrcSize, View.StereoPass, QuadTexTransform);	// Draw a quad mapping scene color to the view's render target	DrawTransformedRectangle(		Context.RHICmdList,		0, 0,		DestRect.Width(), DestRect.Height(),		QuadPosTransform,		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		QuadTexTransform,		DestRect.Size(),		SrcSize		);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessVisualizeBloomOverlay::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, VisualizeBloomOverlay);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	check(InputDesc && "Input is not hooked up correctly");	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	uint32 ScaleFactor = GSceneRenderTargets.GetBufferSizeXY().X / SrcSize.X;	FIntRect SrcRect = View.ViewRect / ScaleFactor;	FIntRect DestRect = SrcRect;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	// is optimized away if possible (RT size=view size, )	Context.RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 1.0f, false, 0, DestRect);	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestRect.Width(), DestRect.Height(), 1.0f );	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessVisualizeBloomOverlayPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;	SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetParameters(Context);	VertexShader->SetParameters(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessVisualizeMotionBlur::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(VisualizeMotionBlur, DEC_SCENE_ITEMS);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	FIntPoint TexSize = InputDesc->Extent;	// we assume the input and output is full resolution	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	uint32 ScaleFactor = GSceneRenderTargets.GetBufferSizeXY().X / SrcSize.X;	FIntRect SrcRect = FIntRect::DivideAndRoundUp(View.ViewRect, ScaleFactor);	FIntRect DestRect = SrcRect;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	RHISetRenderTarget(DestRenderTarget.TargetableTexture, FTextureRHIRef());		// is optimized away if possible (RT size=view size, )	RHIClear(true, FLinearColor::Black, false, 1.0f, false, 0, SrcRect);	Context.SetViewportAndCallRHI(SrcRect);	// set the state	RHISetBlendState(TStaticBlendState<>::GetRHI());	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	// Quality 0: visualize	SetMotionBlurShaderTempl<0>(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		0, 0,		SrcRect.Width(), SrcRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y, 		SrcRect.Width(), SrcRect.Height(),		SrcRect.Size(),		SrcSize,		EDRF_UseTriangleOptimization);	RHICopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessHistogramReduce::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHistogramReduce);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessHistogramReducePS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	// we currently assume the input is half res, one full res pixel less to avoid getting bilinear filtered input	FIntPoint GatherExtent = (View.ViewRect.Size() - FIntPoint(1, 1)) / 2;	uint32 LoopSizeValue = ComputeLoopSize(GatherExtent);	PixelShader->SetPS(Context, LoopSizeValue);	DrawPostProcessPass(		Context.RHICmdList,		0, 0,		DestSize.X, DestSize.Y,		0, 0,		SrcSize.X, 0,		DestSize,		SrcSize,		*VertexShader,		View.StereoPass,		Context.HasHmdMesh(),		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessVisualizeComplexity::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessVisualizeComplexity);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.UnscaledViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(DestRect);	// turn off culling and blending	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	// turn off depth reads/writes	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	//reuse this generic vertex shader	TShaderMapRef<FShaderComplexityApplyVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FShaderComplexityApplyPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState ShaderComplexityBoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), ShaderComplexityBoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetParameters(Context, Colors);		DrawRectangle(		Context.RHICmdList,		0, 0,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessSceneColorFringe::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, SceneColorFringe);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(View.ViewRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());		TShaderMapRef<FPostProcessSceneColorFringeVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessSceneColorFringePS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetParameters(Context);	VertexShader->SetParameters(Context);		// Draw a quad mapping scene color to the view's render target	DrawRectangle(		Context.RHICmdList,		0, 0,		View.ViewRect.Width(), View.ViewRect.Height(),		View.ViewRect.Min.X, View.ViewRect.Min.Y, 		View.ViewRect.Width(), View.ViewRect.Height(),		View.ViewRect.Size(),		FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY(),		*VertexShader,		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessHMD::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHMD, DEC_SCENE_ITEMS);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		const FIntRect SrcRect = View.ViewRect;	const FIntRect DestRect = View.UnscaledViewRect;	const FIntPoint SrcSize = InputDesc->Extent;    const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(DestRect);	Context.RHICmdList.Clear(true, FLinearColor::Black, false, 1.0f, false, 0, FIntRect());	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	FMatrix QuadTexTransform = FMatrix::Identity;	FMatrix QuadPosTransform = FMatrix::Identity;	check(GEngine->HMDDevice.IsValid());	{		TShaderMapRef<FPostProcessHMDVS<false> > VertexShader(Context.GetShaderMap());		TShaderMapRef<FPostProcessHMDPS<false> > PixelShader(Context.GetShaderMap());		static FGlobalBoundShaderState BoundShaderState;				SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GDistortionVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		VertexShader->SetVS(Context, View.StereoPass);		PixelShader->SetPS(Context, SrcRect, SrcSize, View.StereoPass, QuadTexTransform);	}	GEngine->HMDDevice->DrawDistortionMesh_RenderThread(Context, View, SrcSize);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

bool FRCPassPostProcessWeightedSampleSum::DoFastBlur() const{	bool bRet = false;	// only do the fast blur only with bilinear filtering	if(CombineMethod == EFCM_Weighted)	{		const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);		// input is not hooked up correctly		check(InputDesc);		if(FilterShape == EFS_Horiz)		{			FIntPoint SrcSize = InputDesc->Extent;			int32 SrcSizeForThisAxis = SrcSize.X;			// in texel (input resolution), *2 as we use the diameter			// we scale by width because FOV is defined horizontally			float EffectiveBlurRadius = SizeScale * SrcSizeForThisAxis  * 2 / 100.0f;#if PLATFORM_HTML5			float FastBlurThreshold = CVarFastBlurThreshold.GetValueOnGameThread();#else			float FastBlurThreshold = CVarFastBlurThreshold.GetValueOnRenderThread();#endif			// small radius look too different with this optimization so we only to it for larger radius			bRet = EffectiveBlurRadius >= FastBlurThreshold;		}		else		{			FIntPoint SrcSize = InputDesc->Extent;			FIntPoint BufferSize = GSceneRenderTargets.GetBufferSizeXY();			float InputRatio = SrcSize.X / (float)SrcSize.Y;			float BufferRatio = BufferSize.X / (float)BufferSize.Y;			// Half res input detected			bRet = InputRatio < BufferRatio * 0.75f;		}	}	return bRet;}

void FRCPassPostProcessHistogram::Process(FRenderingCompositePassContext& Context){    SCOPED_DRAW_EVENT(PostProcessHistogram, DEC_SCENE_ITEMS);    const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);    if(!InputDesc)    {        // input is not hooked up correctly        return;    }    const FSceneView& View = Context.View;    const FSceneViewFamily& ViewFamily = *(View.Family);    FIntPoint SrcSize = InputDesc->Extent;    FIntRect DestRect = View.ViewRect;    const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);    TShaderMapRef<FPostProcessHistogramCS> ComputeShader(GetGlobalShaderMap());    RHISetComputeShader(ComputeShader->GetComputeShader());    RHISetRenderTarget(FTextureRHIRef(), FTextureRHIRef());    // set destination    check(DestRenderTarget.UAV);    RHISetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), DestRenderTarget.UAV);    // we currently assume the input is half res, one full res pixel less to avoid getting bilinear filtered input    FIntPoint GatherExtent = (DestRect.Size() - FIntPoint(1, 1)) / 2;    FIntPoint ThreadGroupCountValue = ComputeThreadGroupCount(GatherExtent);    ComputeShader->SetCS(Context, ThreadGroupCountValue, (DestRect.Min + FIntPoint(1, 1)) / 2, GatherExtent);    DispatchComputeShader(*ComputeShader, ThreadGroupCountValue.X, ThreadGroupCountValue.Y, 1);    // un-set destination    RHISetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), NULL);    RHICopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessHistogram::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHistogram);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntPoint SrcSize = InputDesc->Extent;	FIntRect DestRect = View.ViewRect;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	TShaderMapRef<FPostProcessHistogramCS> ComputeShader(Context.GetShaderMap());	SetRenderTarget(Context.RHICmdList, FTextureRHIRef(), FTextureRHIRef());    Context.RHICmdList.SetComputeShader(ComputeShader->GetComputeShader());    	// set destination	check(DestRenderTarget.UAV);	Context.RHICmdList.TransitionResource(EResourceTransitionAccess::ERWBarrier, EResourceTransitionPipeline::EGfxToCompute, DestRenderTarget.UAV);	Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), DestRenderTarget.UAV);	FIntPoint GatherExtent = ComputeGatherExtent(View);	FIntPoint ThreadGroupCountValue = ComputeThreadGroupCount(GatherExtent);	ComputeShader->SetCS(Context.RHICmdList, Context, ThreadGroupCountValue, (DestRect.Min + FIntPoint(1, 1)) / 2, GatherExtent);		DispatchComputeShader(Context.RHICmdList, *ComputeShader, ThreadGroupCountValue.X, ThreadGroupCountValue.Y, 1);	// un-set destination	Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), NULL);	Context.RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, EResourceTransitionPipeline::EComputeToGfx, DestRenderTarget.UAV);	ensureMsgf(DestRenderTarget.TargetableTexture == DestRenderTarget.ShaderResourceTexture, TEXT("%s should be resolved to a separate SRV"), *DestRenderTarget.TargetableTexture->GetName().ToString());	}

void FRCPassPostProcessVelocityFlatten::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessVelocityFlatten);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		const FSceneRenderTargetItem& DestRenderTarget0 = PassOutputs[0].RequestSurface(Context);	const FSceneRenderTargetItem& DestRenderTarget1 = PassOutputs[1].RequestSurface(Context);	//const FSceneRenderTargetItem& DestRenderTarget2 = PassOutputs[2].RequestSurface(Context);	TShaderMapRef< FPostProcessVelocityFlattenCS > ComputeShader( Context.GetShaderMap() );	Context.RHICmdList.SetComputeShader(ComputeShader->GetComputeShader());	SetRenderTarget(Context.RHICmdList, FTextureRHIRef(), FTextureRHIRef());	// set destination	Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutVelocityFlat.GetBaseIndex(), DestRenderTarget0.UAV );	//Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutPackedVelocityDepth.GetBaseIndex(), DestRenderTarget1.UAV );	Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutMaxTileVelocity.GetBaseIndex(), DestRenderTarget1.UAV );	ComputeShader->SetCS(Context.RHICmdList, Context, View );		FIntPoint ThreadGroupCountValue = ComputeThreadGroupCount( View.ViewRect.Size() );	DispatchComputeShader(Context.RHICmdList, *ComputeShader, ThreadGroupCountValue.X, ThreadGroupCountValue.Y, 1);	// un-set destination	Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutVelocityFlat.GetBaseIndex(), NULL );	//Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutPackedVelocityDepth.GetBaseIndex(), NULL );	Context.RHICmdList.SetUAVParameter( ComputeShader->GetComputeShader(), ComputeShader->OutMaxTileVelocity.GetBaseIndex(), NULL );	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget0.TargetableTexture, DestRenderTarget0.ShaderResourceTexture, false, FResolveParams());	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget1.TargetableTexture, DestRenderTarget1.ShaderResourceTexture, false, FResolveParams());	//Context.RHICmdList.CopyToResolveTarget(DestRenderTarget1.TargetableTexture, DestRenderTarget2.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessPassThrough::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(PassThrough, DEC_SCENE_ITEMS);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	FIntPoint TexSize = InputDesc->Extent;	// we assume the input and output is full resolution	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = Dest ? Dest->GetDesc().Extent : PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	uint32 InputScaleFactor = GSceneRenderTargets.GetBufferSizeXY().X / SrcSize.X;	uint32 OutputScaleFactor = GSceneRenderTargets.GetBufferSizeXY().X / DestSize.X;	FIntRect SrcRect = View.ViewRect / InputScaleFactor;	FIntRect DestRect = View.ViewRect / OutputScaleFactor;	const FSceneRenderTargetItem& DestRenderTarget = Dest ? Dest->GetRenderTargetItem() : PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	RHISetRenderTarget(DestRenderTarget.TargetableTexture, FTextureRHIRef());		Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f);	// set the state	if(bAdditiveBlend)	{		RHISetBlendState(TStaticBlendState<CW_RGB,BO_Add,BF_One,BF_One,BO_Add,BF_One,BF_One>::GetRHI());	}	else	{		RHISetBlendState(TStaticBlendState<>::GetRHI());	}	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());	TShaderMapRef<FPostProcessPassThroughPS> PixelShader(GetGlobalShaderMap());	static FGlobalBoundShaderState BoundShaderState;	SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	VertexShader->SetParameters(Context);	PixelShader->SetParameters(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		EDRF_UseTriangleOptimization);	RHICopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessVisualizeShadingModels::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessVisualizeShadingModels);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	const FSceneView& View = Context.View;	const FViewInfo& ViewInfo = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.ViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(DestRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessVisualizeShadingModelsPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetPS(Context, ((FViewInfo&)View).ShadingModelMaskInView);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	FRenderTargetTemp TempRenderTarget(View, (const FTexture2DRHIRef&)DestRenderTarget.TargetableTexture);	FCanvas Canvas(&TempRenderTarget, NULL, 0, 0, 0, Context.GetFeatureLevel());	float X = 30;	float Y = 28;	const float YStep = 14;	const float ColumnWidth = 250;	FString Line;	Canvas.DrawShadowedString( X, Y += YStep, TEXT("Visualize ShadingModels (mostly to track down bugs)"), GetStatsFont(), FLinearColor(1, 1, 1));	Y = 160 - YStep - 4;		uint32 Value = ((FViewInfo&)View).ShadingModelMaskInView;	Line = FString::Printf(TEXT("View.ShadingModelMaskInView = 0x%x"), Value);	Canvas.DrawShadowedString( X, Y, *Line, GetStatsFont(), FLinearColor(0.5f, 0.5f, 0.5f));	Y += YStep;	UEnum* Enum = FindObject<UEnum>(NULL, TEXT("Engine.EMaterialShadingModel"));	check(Enum);	Y += 5;	for(uint32 i = 0; i < MSM_MAX; ++i)	{		FString Name = Enum->GetEnumName(i);		Line = FString::Printf(TEXT("%d.  %s"), i, *Name);		bool bThere = (Value & (1 << i)) != 0;		Canvas.DrawShadowedString(X + 30, Y, *Line, GetStatsFont(), bThere ? FLinearColor(1, 1, 1) : FLinearColor(0, 0, 0) );		Y += 20;	}	Line = FString::Printf(TEXT("(On CPU, based on what gets rendered)"));	Canvas.DrawShadowedString( X, Y, *Line, GetStatsFont(), FLinearColor(0.5f, 0.5f, 0.5f)); Y += YStep;	Canvas.Flush_RenderThread(Context.RHICmdList);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());	// AdjustGBufferRefCount(1) call is done in constructor	FSceneRenderTargets::Get(Context.RHICmdList).AdjustGBufferRefCount(Context.RHICmdList, -1);}

void FRCPassPostProcessVisualizeBuffer::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(VisualizeBuffer, DEC_SCENE_ITEMS);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.ViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	RHISetRenderTarget(DestRenderTarget.TargetableTexture, FTextureRHIRef());		Context.SetViewportAndCallRHI(DestRect);	// set the state	RHISetBlendState(TStaticBlendState<>::GetRHI());	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	SetShaderTempl<false>(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		0, 0,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		EDRF_UseTriangleOptimization);	// Now draw the requested tiles into the grid	TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());	TShaderMapRef<FPostProcessVisualizeBufferPS<true> > PixelShader(GetGlobalShaderMap());	RHISetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha>::GetRHI());	static FGlobalBoundShaderState BoundShaderState;	SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetPS(Context);	// Track the name and position of each tile we draw so we can write text labels over them	struct LabelRecord	{		FString Label;		int32 LocationX;		int32 LocationY;	};	TArray<LabelRecord> Labels;	const int32 MaxTilesX = 4;	const int32 MaxTilesY = 4;	const int32 TileWidth = DestRect.Width() / MaxTilesX;	const int32 TileHeight = DestRect.Height() / MaxTilesY;	int32 CurrentTileIndex = 0; 	for (TArray<TileData>::TConstIterator It = Tiles.CreateConstIterator(); It; ++It, ++CurrentTileIndex)	{		FRenderingCompositeOutputRef Tile = It->Source;		if (Tile.IsValid())		{			FTextureRHIRef Texture = Tile.GetOutput()->PooledRenderTarget->GetRenderTargetItem().TargetableTexture;			int32 TileX = CurrentTileIndex % MaxTilesX;			int32 TileY = CurrentTileIndex / MaxTilesX;			PixelShader->SetSourceTexture(Texture);			DrawRectangle(				TileX * TileWidth, TileY * TileHeight,				TileWidth, TileHeight,				SrcRect.Min.X, SrcRect.Min.Y,				SrcRect.Width(), SrcRect.Height(),				DestRect.Size(),				SrcSize,				EDRF_Default);			Labels.Add(LabelRecord());			Labels.Last().Label = It->Name;			Labels.Last().LocationX = 8 + TileX * TileWidth;			Labels.Last().LocationY = (TileY + 1) * TileHeight - 19;		}	}	// Draw tile labels	// this is a helper class for FCanvas to be able to get screen size//.........这里部分代码省略.........

void FRCPassPostProcessLensFlares::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, LensFlares);	const FPooledRenderTargetDesc* InputDesc1 = GetInputDesc(ePId_Input0);	const FPooledRenderTargetDesc* InputDesc2 = GetInputDesc(ePId_Input1);		if(!InputDesc1 || !InputDesc2)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint TexSize1 = InputDesc1->Extent;	FIntPoint TexSize2 = InputDesc2->Extent;	uint32 ScaleToFullRes1 = GSceneRenderTargets.GetBufferSizeXY().X / TexSize1.X;	uint32 ScaleToFullRes2 = GSceneRenderTargets.GetBufferSizeXY().X / TexSize2.X;	FIntRect ViewRect1 = FIntRect::DivideAndRoundUp(View.ViewRect, ScaleToFullRes1);	FIntRect ViewRect2 = FIntRect::DivideAndRoundUp(View.ViewRect, ScaleToFullRes2);	FIntPoint ViewSize1 = ViewRect1.Size();	FIntPoint ViewSize2 = ViewRect2.Size();	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());			// is optimized away if possible (RT size=view size, )	Context.RHICmdList.Clear(true, FLinearColor::Black, false, 1.0f, false, 0, ViewRect1);	Context.SetViewportAndCallRHI(ViewRect1);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());		// setup background (bloom), can be implemented to use additive blending to avoid the read here	{		TShaderMapRef<FPostProcessLensFlareBasePS> PixelShader(Context.GetShaderMap());		static FGlobalBoundShaderState BoundShaderState;				SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		VertexShader->SetParameters(Context);		PixelShader->SetParameters(Context);		// Draw a quad mapping scene color to the view's render target		DrawRectangle(			Context.RHICmdList,			0, 0,			ViewSize1.X, ViewSize1.Y,			ViewRect1.Min.X, ViewRect1.Min.Y,			ViewSize1.X, ViewSize1.Y,			ViewSize1,			TexSize1,			*VertexShader,			EDRF_UseTriangleOptimization);	}	// additive blend	Context.RHICmdList.SetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_One, BF_One>::GetRHI());	// add lens flares on top of that	{		TShaderMapRef<FPostProcessLensFlaresPS> PixelShader(Context.GetShaderMap());		static FGlobalBoundShaderState BoundShaderState;				SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		FVector2D TexScaleValue = FVector2D(TexSize2) / ViewSize2;		VertexShader->SetParameters(Context);		PixelShader->SetParameters(Context, TexScaleValue);		// todo: expose		const uint32 Count = 8;		// we assume the center of the view is the center of the lens (would not be correct for tiled rendering)		FVector2D Center = FVector2D(ViewSize1) * 0.5f;		FLinearColor LensFlareHDRColor = Context.View.FinalPostProcessSettings.LensFlareTint * Context.View.FinalPostProcessSettings.LensFlareIntensity;			// to get the same brightness with 4x more quads (TileSize=1 in LensBlur)		LensFlareHDRColor.R *= 0.25f;		LensFlareHDRColor.G *= 0.25f;		LensFlareHDRColor.B *= 0.25f;		for(uint32 i = 0; i < Count; ++i)//.........这里部分代码省略.........

void FRCPassPostProcessVisualizeHDR::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(PostProcessVisualizeHDR, DEC_SCENE_ITEMS);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.ViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	RHISetRenderTarget(DestRenderTarget.TargetableTexture, FTextureRHIRef());		Context.SetViewportAndCallRHI(DestRect);	// set the state	RHISetBlendState(TStaticBlendState<>::GetRHI());	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());	TShaderMapRef<FPostProcessVisualizeHDRPS> PixelShader(GetGlobalShaderMap());	static FGlobalBoundShaderState BoundShaderState;	SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetPS(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		EDRF_UseTriangleOptimization);	// this is a helper class for FCanvas to be able to get screen size	class FRenderTargetTemp : public FRenderTarget	{	public:		const FSceneView& View;		const FTexture2DRHIRef Texture;		FRenderTargetTemp(const FSceneView& InView, const FTexture2DRHIRef InTexture)			: View(InView), Texture(InTexture)		{		}		virtual FIntPoint GetSizeXY() const		{			return View.ViewRect.Size();		};		virtual const FTexture2DRHIRef& GetRenderTargetTexture() const		{			return Texture;		}	} TempRenderTarget(View, (const FTexture2DRHIRef&)DestRenderTarget.TargetableTexture);	FCanvas Canvas(&TempRenderTarget, NULL, ViewFamily.CurrentRealTime, ViewFamily.CurrentWorldTime, ViewFamily.DeltaWorldTime);	float X = 30;	float Y = 8;	const float YStep = 14;	const float ColumnWidth = 250;	FString Line;	Line = FString::Printf(TEXT("HDR Histogram (Logarithmic, max of RGB)"));	Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Y += 160;	float MinX = 64 + 10;	float MaxY = View.ViewRect.Max.Y - 64;	float SizeX = View.ViewRect.Size().X - 64 * 2 - 20;	for(uint32 i = 0; i <= 4; ++i)	{		int XAdd = (int)(i * SizeX / 4);		float HistogramPosition =  i / 4.0f;		float LogValue = FMath::Lerp(View.FinalPostProcessSettings.HistogramLogMin, View.FinalPostProcessSettings.HistogramLogMax, HistogramPosition);		Line = FString::Printf(TEXT("%.2g"), LogValue);		Canvas.DrawShadowedString( MinX + XAdd - 5, MaxY, *Line, GetStatsFont(), FLinearColor(1, 0.3f, 0.3f));		Line = LogToString(LogValue);		Canvas.DrawShadowedString( MinX + XAdd - 5, MaxY + YStep, *Line, GetStatsFont(), FLinearColor(0.3f, 0.3f, 1));	}	Y += 3 * YStep;//.........这里部分代码省略.........

void FRCPassPostProcessBokehDOFRecombine::Process(FRenderingCompositePassContext& Context){	uint32 Method = 2;	FRenderingCompositeOutputRef* Input1 = GetInput(ePId_Input1);	if(Input1 && Input1->GetPass())	{		if(GetInput(ePId_Input2)->GetPass())		{			Method = 3;		}		else		{			Method = 1;		}	}	else	{		check(GetInput(ePId_Input2)->GetPass());	}	FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(Context.RHICmdList);	FIntPoint OutScaledSize;	float OutScale;	SceneContext.GetSeparateTranslucencyDimensions(OutScaledSize, OutScale);	const bool bUseNearestDepthNeighborUpsample = 		CVarSeparateTranslucencyUpsampleMode.GetValueOnRenderThread() != 0		&& FMath::Abs(OutScale - .5f) < .001f;	if (Method != 1 && bUseNearestDepthNeighborUpsample)	{		Method += 2;	}	const FSceneView& View = Context.View;	SCOPED_DRAW_EVENTF(Context.RHICmdList, BokehDOFRecombine, TEXT("BokehDOFRecombine#%d %dx%d"), Method, View.ViewRect.Width(), View.ViewRect.Height());	const FPooledRenderTargetDesc* InputDesc0 = GetInputDesc(ePId_Input0);	const FPooledRenderTargetDesc* InputDesc1 = GetInputDesc(ePId_Input1);	FIntPoint TexSize = InputDesc1 ? InputDesc1->Extent : InputDesc0->Extent;	// usually 1, 2, 4 or 8	uint32 ScaleToFullRes = FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY().X / TexSize.X;	FIntRect HalfResViewRect = FIntRect::DivideAndRoundUp(View.ViewRect, ScaleToFullRes);	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	// is optimized away if possible (RT size=view size, )	Context.RHICmdList.Clear(true, FLinearColor::Black, false, 1.0f, false, 0, View.ViewRect);	Context.SetViewportAndCallRHI(View.ViewRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	switch(Method)	{		case 1: SetShader<1>(Context); break;		case 2: SetShader<2>(Context); break;		case 3: SetShader<3>(Context); break;		case 4: SetShader<4>(Context); break;		case 5: SetShader<5>(Context); break;		default:			check(0);	}	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	DrawPostProcessPass(		Context.RHICmdList,		0, 0,		View.ViewRect.Width(), View.ViewRect.Height(),		HalfResViewRect.Min.X, HalfResViewRect.Min.Y,		HalfResViewRect.Width(), HalfResViewRect.Height(),		View.ViewRect.Size(),		TexSize,		*VertexShader,		View.StereoPass,		Context.HasHmdMesh(),		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessDownsample::Process(FRenderingCompositePassContext& Context){	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	uint32 ScaleFactor = FMath::DivideAndRoundUp(FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY().Y, SrcSize.Y);	FIntRect SrcRect = View.ViewRect / ScaleFactor;	FIntRect DestRect = FIntRect::DivideAndRoundUp(SrcRect, 2);	SrcRect = DestRect * 2;	SCOPED_DRAW_EVENTF(Context.RHICmdList, Downsample, TEXT("Downsample %dx%d"), DestRect.Width(), DestRect.Height());	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// check if we have to clear the whole surface.	// Otherwise perform the clear when the dest rectangle has been computed.	auto FeatureLevel = Context.View.GetFeatureLevel();	if (FeatureLevel == ERHIFeatureLevel::ES2 || FeatureLevel == ERHIFeatureLevel::ES3_1)	{		// Set the view family's render target/viewport.		SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef(), ESimpleRenderTargetMode::EClearColorAndDepth);		Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	}	else	{		// Set the view family's render target/viewport.		SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef(), ESimpleRenderTargetMode::EExistingColorAndDepth);		Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );		DrawClearQuad(Context.RHICmdList, Context.GetFeatureLevel(), true, FLinearColor(0, 0, 0, 0), false, 1.0f, false, 0, DestSize, DestRect);	}	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	// InflateSize increases the size of the source/dest rectangle to compensate for bilinear reads and UIBlur pass requirements.	int32 InflateSize;	// if second input is hooked up	if (IsDepthInputAvailable())	{		// also put depth in alpha		InflateSize = 2;		SetShader<2>(Context, InputDesc);	}	else	{		if (Quality == 0)		{			SetShader<0>(Context, InputDesc);			InflateSize = 1;		}		else		{			SetShader<1>(Context, InputDesc);			InflateSize = 2;		}	}	TShaderMapRef<FPostProcessDownsampleVS> VertexShader(Context.GetShaderMap());	DrawPostProcessPass(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		*VertexShader,		View.StereoPass,		false, // This pass is input for passes that can't use the hmd mask, so we need to disable it to ensure valid input data		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessWeightedSampleSum::Process(FRenderingCompositePassContext& Context){	const FSceneView& View = Context.View;	FRenderingCompositeOutput *Input = PassInputs[0].GetOutput();	// input is not hooked up correctly	check(Input);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	// input is not hooked up correctly	check(InputDesc);	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	FIntPoint SrcScaleFactor = GSceneRenderTargets.GetBufferSizeXY() / SrcSize;	FIntPoint DstScaleFactor = GSceneRenderTargets.GetBufferSizeXY() / DestSize;	TRefCountPtr<IPooledRenderTarget> InputPooledElement = Input->RequestInput();	check(!InputPooledElement->IsFree());	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	FVector2D InvSrcSize(1.0f / SrcSize.X, 1.0f / SrcSize.Y);	// we scale by width because FOV is defined horizontally	float SrcSizeForThisAxis = View.ViewRect.Width() / (float)SrcScaleFactor.X;	// in texel (input resolution), /2 as we use the diameter, 100 as we use percent	float EffectiveBlurRadius = SizeScale * SrcSizeForThisAxis  / 2 / 100.0f;	FVector2D BlurOffsets[MAX_FILTER_SAMPLES];	FLinearColor BlurWeights[MAX_FILTER_SAMPLES];	FVector2D OffsetAndWeight[MAX_FILTER_SAMPLES];	const auto FeatureLevel = Context.View.GetFeatureLevel();	// compute 1D filtered samples	uint32 MaxNumSamples = GetMaxNumSamples(FeatureLevel);	uint32 NumSamples = Compute1DGaussianFilterKernel(FeatureLevel, EffectiveBlurRadius, OffsetAndWeight, MaxNumSamples, FilterShape, CrossCenterWeight);	SCOPED_DRAW_EVENTF(Context.RHICmdList, PostProcessWeightedSampleSum, TEXT("PostProcessWeightedSampleSum#%d"), NumSamples);	// compute weights as weighted contributions of the TintValue	for(uint32 i = 0; i < NumSamples; ++i)	{		BlurWeights[i] = TintValue * OffsetAndWeight[i].Y;	}	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	const FTextureRHIRef& FilterTexture = InputPooledElement->GetRenderTargetItem().ShaderResourceTexture;	FRenderingCompositeOutput *Input1 = PassInputs[1].GetOutput();	uint32 CombineMethodInt = 0;	if(CombineMethod == EFCM_MaxMagnitude)	{		CombineMethodInt = 2;	}	// can be optimized	FTextureRHIRef AdditiveTexture;	if(Input1)	{		TRefCountPtr<IPooledRenderTarget> InputPooledElement1 = Input1->RequestInput();		AdditiveTexture = InputPooledElement1->GetRenderTargetItem().ShaderResourceTexture;		check(CombineMethod == EFCM_Weighted);		CombineMethodInt = 1;	}	bool bDoFastBlur = DoFastBlur();	if (FilterShape == EFS_Horiz)	{		float YOffset = bDoFastBlur ? (InvSrcSize.Y * 0.5f) : 0.0f;		for (uint32 i = 0; i < NumSamples; ++i)		{			BlurOffsets[i] = FVector2D(InvSrcSize.X * OffsetAndWeight[i].X, YOffset);		}	}	else	{//.........这里部分代码省略.........

void FRCPassPostProcessSubsurface::Process(FRenderingCompositePassContext& Context){	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	check(InputDesc);	{		const IPooledRenderTarget* PooledRT = GetSubsufaceProfileTexture_RT(Context.RHICmdList);		check(PooledRT);		// for debugging		GRenderTargetPool.VisualizeTexture.SetCheckPoint(Context.RHICmdList, PooledRT);	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	check(DestSize.X);	check(DestSize.Y);	check(SrcSize.X);	check(SrcSize.Y);	FIntRect SrcRect = FIntRect(0, 0, DestSize.X, DestSize.Y);	FIntRect DestRect = SrcRect;	TRefCountPtr<IPooledRenderTarget> NewSceneColor;	const FSceneRenderTargetItem* DestRenderTarget;	{		DestRenderTarget = &PassOutputs[0].RequestSurface(Context);		check(DestRenderTarget);	}	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget->TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	SCOPED_DRAW_EVENTF(Context.RHICmdList, SubsurfacePass, TEXT("SubsurfaceDirection#%d"), Direction);	uint32 SampleSet = FMath::Clamp(CVarSSSSampleSet.GetValueOnRenderThread(), 0, 2);	if (Direction == 0)	{		SetSubsurfaceShaderSampleSet<0>(Context, VertexShader, SampleSet);	}	else	{		SetSubsurfaceShaderSampleSet<1>(Context, VertexShader, SampleSet);	}	DrawPostProcessPass(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		*VertexShader,		View.StereoPass,		Context.HasHmdMesh(),		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget->TargetableTexture, DestRenderTarget->ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessSubsurfaceSetup::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, SubsurfaceSetup);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	FIntRect DestRect = FIntRect(0, 0, DestSize.X, DestSize.Y);	FIntRect SrcRect = View.ViewRect;		if(bHalfRes)	{		// upscale rectangle to not slightly scale (might miss a pixel)		SrcRect = DestRect * 2 + View.ViewRect.Min;	}	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	if(bHalfRes)	{		SetSubsurfaceSetupShader<1>(Context);	}	else	{		SetSubsurfaceSetupShader<0>(Context);	}	// Draw a quad mapping scene color to the view's render target	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	DrawPostProcessPass(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		*VertexShader,		View.StereoPass,		Context.HasHmdMesh(),		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessGBufferHints::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, GBufferHints);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);		FIntRect SrcRect = View.ViewRect;	FIntRect DestRect = View.ViewRect;	FIntPoint SrcSize = InputDesc->Extent;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.SetViewportAndCallRHI(DestRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	TShaderMapRef<FPostProcessGBufferHintsPS> PixelShader(Context.GetShaderMap());	static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, Context.GetFeatureLevel(), BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetPS(Context);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		Context.RHICmdList,		0, 0,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestRect.Size(),		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	// this is a helper class for FCanvas to be able to get screen size	class FRenderTargetTemp : public FRenderTarget	{	public:		const FSceneView& View;		const FTexture2DRHIRef Texture;		FRenderTargetTemp(const FSceneView& InView, const FTexture2DRHIRef InTexture)			: View(InView), Texture(InTexture)		{		}		virtual FIntPoint GetSizeXY() const		{			return View.ViewRect.Size();		};		virtual const FTexture2DRHIRef& GetRenderTargetTexture() const		{			return Texture;		}	} TempRenderTarget(View, (const FTexture2DRHIRef&)DestRenderTarget.TargetableTexture);	FCanvas Canvas(&TempRenderTarget, NULL, ViewFamily.CurrentRealTime, ViewFamily.CurrentWorldTime, ViewFamily.DeltaWorldTime, View.GetFeatureLevel());	float X = 30;	float Y = 8;	const float YStep = 14;	const float ColumnWidth = 250;	FString Line;	Line = FString::Printf(TEXT("GBufferHints"));	Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));	Y += YStep;		Line = FString::Printf(TEXT("Yellow: Unrealistic material (In nature even black materials reflect quite some light)"));	Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(0.8f, 0.8f, 0));	Line = FString::Printf(TEXT("Red: Impossive material (this material emits more light than it receives)"));	Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 0, 0));	Canvas.Flush_RenderThread(Context.RHICmdList);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());	// AdjustGBufferRefCount(1) call is done in constructor	FSceneRenderTargets::Get(Context.RHICmdList).AdjustGBufferRefCount(-1);}

void FRCPassPostProcessDOFRecombine::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, DOFRecombine);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input1);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const auto FeatureLevel = Context.GetFeatureLevel();	auto ShaderMap = Context.GetShaderMap();	FIntPoint TexSize = InputDesc->Extent;	// usually 1, 2, 4 or 8	uint32 ScaleToFullRes = FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY().X / TexSize.X;	FIntRect HalfResViewRect = View.ViewRect / ScaleToFullRes;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	// is optimized away if possible (RT size=view size, )	Context.RHICmdList.Clear(true, FLinearColor::Black, false, 1.0f, false, 0, View.ViewRect);	Context.SetViewportAndCallRHI(View.ViewRect);	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(ShaderMap);	if (bNearBlurEnabled)	{		static FGlobalBoundShaderState BoundShaderState;				TShaderMapRef< FPostProcessDOFRecombinePS<1> > PixelShader(ShaderMap);		SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		PixelShader->SetParameters(Context);	}	else	{		static FGlobalBoundShaderState BoundShaderState;				TShaderMapRef< FPostProcessDOFRecombinePS<0> > PixelShader(ShaderMap);		SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		PixelShader->SetParameters(Context);	}	VertexShader->SetParameters(Context);	DrawPostProcessPass(		Context.RHICmdList,		0, 0,		View.ViewRect.Width(), View.ViewRect.Height(),		HalfResViewRect.Min.X, HalfResViewRect.Min.Y,		HalfResViewRect.Width(), HalfResViewRect.Height(),		View.ViewRect.Size(),		TexSize,		*VertexShader,		View.StereoPass,		Context.HasHmdMesh(),		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessNoiseBlur::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, NoiseBlur);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	if(!InputDesc)	{		// input is not hooked up correctly		return;	}	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent;	// e.g. 4 means the input texture is 4x smaller than the buffer size	uint32 ScaleFactor = FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY().X / SrcSize.X;	FIntRect SrcRect = View.ViewRect / ScaleFactor;	FIntRect DestRect = SrcRect;	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	// is optimized away if possible (RT size=view size, )	Context.RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 1.0f, false, 0, DestRect);	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	// set the state	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());		if(Quality == 0)	{		SetNoiseBlurShader<0>(Context, Radius);	}	else if(Quality == 1)	{		SetNoiseBlurShader<1>(Context, Radius);	}	else	{		SetNoiseBlurShader<2>(Context, Radius);	}	// Draw a quad mapping scene color to the view's render target	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	DrawRectangle(		Context.RHICmdList,		DestRect.Min.X, DestRect.Min.Y,		DestRect.Width(), DestRect.Height(),		SrcRect.Min.X, SrcRect.Min.Y,		SrcRect.Width(), SrcRect.Height(),		DestSize,		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}