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

void FMediaTextureResource::UpdateDeferredResource(FRHICommandListImmediate& RHICmdList, bool bClearRenderTarget/*=true*/){	FTimespan CurrentFrameTime = VideoBuffer->GetCurrentSampleTime();	TSharedPtr<TArray<uint8>, ESPMode::ThreadSafe> CurrentFrame = VideoBuffer->GetCurrentSample();	if (CurrentFrame.IsValid())	{		// draw the latest video frame		if (CurrentFrameTime != LastFrameTime)		{			uint32 Stride = 0;			FRHITexture2D* Texture2D = TextureRHI->GetTexture2D();			uint8* TextureBuffer = (uint8*)RHILockTexture2D(Texture2D, 0, RLM_WriteOnly, Stride, false);			FMemory::Memcpy(TextureBuffer, CurrentFrame->GetData(), CurrentFrame->Num());			RHIUnlockTexture2D(Texture2D, 0, false);			LastFrameTime = CurrentFrameTime;			Cleared = false;		}	}	else if (!Cleared || (LastClearColor != Owner->ClearColor))	{		// clear texture if video track selected		FRHICommandListImmediate& CommandList = FRHICommandListExecutor::GetImmediateCommandList(); 		SetRenderTarget(CommandList, RenderTargetTextureRHI, FTextureRHIRef()); 		CommandList.SetViewport(0, 0, 0.0f, Owner->GetSurfaceWidth(), Owner->GetSurfaceHeight(), 1.0f); 		CommandList.Clear(true, Owner->ClearColor, false, 0.f, false, 0, FIntRect());		CommandList.CopyToResolveTarget(Texture2DRHI, TextureRHI, true, FResolveParams());		LastClearColor = Owner->ClearColor;		Cleared = true;	}}

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 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 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 FinishOcclusionTerm(FRHICommandList& RHICmdList, const FViewInfo& View, const FLightSceneInfo* const LightSceneInfo, TRefCountPtr<IPooledRenderTarget>& LightShaftsSource, TRefCountPtr<IPooledRenderTarget>& LightShaftsDest){	TShaderMapRef<FScreenVS> ScreenVertexShader(View.ShaderMap);	const FIntPoint BufferSize = FSceneRenderTargets::Get(RHICmdList).GetBufferSizeXY();	const uint32 DownsampleFactor	= GetLightShaftDownsampleFactor();	const FIntPoint FilterBufferSize = BufferSize / DownsampleFactor;	const FIntPoint DownSampledXY = View.ViewRect.Min / DownsampleFactor;	const uint32 DownsampledSizeX = View.ViewRect.Width() / DownsampleFactor;	const uint32 DownsampledSizeY = View.ViewRect.Height() / DownsampleFactor;	SetRenderTarget(RHICmdList, LightShaftsDest->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());	RHICmdList.SetViewport(0, 0, 0.0f, FilterBufferSize.X, FilterBufferSize.Y, 1.0f);	RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	TShaderMapRef<FFinishOcclusionPixelShader> MaskOcclusionTermPixelShader(View.ShaderMap);	SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), AccumulateTermBoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *ScreenVertexShader, *MaskOcclusionTermPixelShader);	/// ?	MaskOcclusionTermPixelShader->SetParameters(RHICmdList, LightSceneInfo, View, LightShaftsSource);	{		// Apply a radial blur to the bloom and occlusion mask		DrawRectangle( 			RHICmdList,			DownSampledXY.X, DownSampledXY.Y, 			DownsampledSizeX, DownsampledSizeY,			DownSampledXY.X, DownSampledXY.Y, 			DownsampledSizeX, DownsampledSizeY,			FilterBufferSize, FilterBufferSize,			*ScreenVertexShader,			EDRF_UseTriangleOptimization);	}	RHICmdList.CopyToResolveTarget(LightShaftsDest->GetRenderTargetItem().TargetableTexture, LightShaftsDest->GetRenderTargetItem().ShaderResourceTexture, false, FResolveParams());}

void DownsamplePass(FRHICommandListImmediate& RHICmdList, const FViewInfo& View, const FLightSceneInfo* LightSceneInfo, TRefCountPtr<IPooledRenderTarget>& LightShaftsSource, TRefCountPtr<IPooledRenderTarget>& LightShaftsDest){	const FIntPoint BufferSize = FSceneRenderTargets::Get(RHICmdList).GetBufferSizeXY();	const uint32 DownsampleFactor	= GetLightShaftDownsampleFactor();	const FIntPoint FilterBufferSize = BufferSize / DownsampleFactor;	const FIntPoint DownSampledXY = View.ViewRect.Min / DownsampleFactor;	const uint32 DownsampledSizeX = View.ViewRect.Width() / DownsampleFactor;	const uint32 DownsampledSizeY = View.ViewRect.Height() / DownsampleFactor;	SetRenderTarget(RHICmdList, LightShaftsDest->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());	RHICmdList.SetViewport(DownSampledXY.X, DownSampledXY.Y, 0.0f, DownSampledXY.X + DownsampledSizeX, DownSampledXY.Y + DownsampledSizeY, 1.0f);	// Set shaders and texture	TShaderMapRef<FDownsampleLightShaftsVertexShader> DownsampleLightShaftsVertexShader(View.ShaderMap);	TRefCountPtr<IPooledRenderTarget> UnusedRT;	switch(LightSceneInfo->Proxy->GetLightType())	{	case LightType_Directional:		{			TShaderMapRef<TDownsampleLightShaftsPixelShader<LightType_Directional, bDownsampleOcclusion> > DownsampleLightShaftsPixelShader(View.ShaderMap);			SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), DownsampleDirectionalLightShaftsBoundShaderState[bDownsampleOcclusion], GFilterVertexDeclaration.VertexDeclarationRHI, *DownsampleLightShaftsVertexShader, *DownsampleLightShaftsPixelShader);			DownsampleLightShaftsPixelShader->SetParameters(RHICmdList, LightSceneInfo, View, UnusedRT);		}		break;	case LightType_Spot:		{			TShaderMapRef<TDownsampleLightShaftsPixelShader<LightType_Spot, bDownsampleOcclusion> > DownsampleLightShaftsPixelShader(View.ShaderMap);			SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), DownsampleSpotLightShaftsBoundShaderState[bDownsampleOcclusion], GFilterVertexDeclaration.VertexDeclarationRHI, *DownsampleLightShaftsVertexShader, *DownsampleLightShaftsPixelShader);			DownsampleLightShaftsPixelShader->SetParameters(RHICmdList, LightSceneInfo, View, UnusedRT);		}		break;	default:	case LightType_Point:		{			TShaderMapRef<TDownsampleLightShaftsPixelShader<LightType_Point, bDownsampleOcclusion> > DownsampleLightShaftsPixelShader(View.ShaderMap);			SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), DownsamplePointLightShaftsBoundShaderState[bDownsampleOcclusion], GFilterVertexDeclaration.VertexDeclarationRHI, *DownsampleLightShaftsVertexShader, *DownsampleLightShaftsPixelShader);			DownsampleLightShaftsPixelShader->SetParameters(RHICmdList, LightSceneInfo, View, UnusedRT);		}		break;	}	DownsampleLightShaftsVertexShader->SetParameters(RHICmdList, View);	// No depth tests, no backface culling.	RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	RHICmdList.SetRasterizerState(TStaticRasterizerState<FM_Solid, CM_None>::GetRHI());	RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	// Downsample scene color and depth, and convert them into a bloom term and an occlusion masking term	DrawRectangle( 		RHICmdList,		0, 0, 		DownsampledSizeX, DownsampledSizeY,		View.ViewRect.Min.X, View.ViewRect.Min.Y, 		View.ViewRect.Width(), View.ViewRect.Height(),		FIntPoint(DownsampledSizeX, DownsampledSizeY), 		BufferSize,		*DownsampleLightShaftsVertexShader,		EDRF_UseTriangleOptimization);	RHICmdList.CopyToResolveTarget(LightShaftsDest->GetRenderTargetItem().TargetableTexture, LightShaftsDest->GetRenderTargetItem().ShaderResourceTexture, false, FResolveParams());	Swap(LightShaftsSource, LightShaftsDest);}

//.........这里部分代码省略.........	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<FPostProcessTestImagePS> 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(),		GSceneRenderTargets.GetBufferSizeXY(),		*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, Context.GetFeatureLevel());		float X = 30;		float Y = 8;		const float YStep = 14;		const float ColumnWidth = 250;		FString Line;		Line = FString::Printf(TEXT("Top bars:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Moving bars using FrameTime"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Black and white raster, Pixel sized, Watch for Moire pattern"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Black and white raster, 2x2 block sized"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("Bottom bars:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   8 bars near white, 4 right bars should appear as one (HDTV)"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   8 bars near black, 4 left bars should appear as one (HDTV)"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Linear Greyscale in sRGB from 0 to 255"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("Color bars:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Red, Green, Blue"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("Outside:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Moving bars using FrameNumber, Tearing without VSync"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("Circles:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   Should be round and centered"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("Border:"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Line = FString::Printf(TEXT("   4 white pixel sized lines (only visible without overscan)"));		Canvas.DrawShadowedString( X, Y += YStep, *Line, GetStatsFont(), FLinearColor(1, 1, 1));		Canvas.Flush_RenderThread(Context.RHICmdList);	}	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FShotThumbnail::CopyTextureIn(FSlateRenderTargetRHI* InTexture){	ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER( ReadTexture,		FSlateRenderTargetRHI*, RenderTarget, InTexture,		FSlateTexture2DRHIRef*, TargetTexture, Texture,	{		RHICopyToResolveTarget(RenderTarget->GetRHIRef(), TargetTexture->GetTypedResource(), false, FResolveParams());	});

void RendererGPUBenchmark(FSynthBenchmarkResults& InOut, const FSceneView& View, uint32 WorkScale, bool bDebugOut){	check(IsInRenderingThread());		// two RT to ping pong so we force the GPU to flush it's pipeline	TRefCountPtr<IPooledRenderTarget> RTItems[3];	{		FPooledRenderTargetDesc Desc(FPooledRenderTargetDesc::Create2DDesc(FIntPoint(GBenchmarkResolution, GBenchmarkResolution), PF_B8G8R8A8, TexCreate_None, TexCreate_RenderTargetable | TexCreate_ShaderResource, false));		GRenderTargetPool.FindFreeElement(Desc, RTItems[0], TEXT("Benchmark0"));		GRenderTargetPool.FindFreeElement(Desc, RTItems[1], TEXT("Benchmark1"));		Desc.Extent = FIntPoint(1, 1);		Desc.Flags = TexCreate_CPUReadback;	// needs TexCreate_ResolveTargetable?		Desc.TargetableFlags = TexCreate_None;		GRenderTargetPool.FindFreeElement(Desc, RTItems[2], TEXT("BenchmarkReadback"));	}	// set the state	RHISetBlendState(TStaticBlendState<>::GetRHI());	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	{		// larger number means more accuracy but slower, some slower GPUs might timeout with a number to large		const uint32 IterationCount = 70;		const uint32 MethodCount = ARRAY_COUNT(InOut.GPUStats);		// 0 / 1		uint32 DestRTIndex = 0;		const uint32 TimerSampleCount = IterationCount * MethodCount + 1;		static FRenderQueryRHIRef TimerQueries[TimerSampleCount];		static uint32 PassCount[IterationCount];		for(uint32  i = 0; i < TimerSampleCount; ++i)		{			TimerQueries[i] = GTimerQueryPool.AllocateQuery();		}		if(!TimerQueries[0])		{			UE_LOG(LogSynthBenchmark, Warning, TEXT("GPU driver does not support timer queries."));		}		// TimingValues are in Seconds per GPixel		FTimingSeries TimingSeries[MethodCount];				for(uint32 MethodIterator = 0; MethodIterator < MethodCount; ++MethodIterator)		{			TimingSeries[MethodIterator].Init(IterationCount);		}		check(MethodCount == 5);		InOut.GPUStats[0] = FSynthBenchmarkStat(TEXT("ALUHeavyNoise"), 1.0f / 4.601f, TEXT("s/GigaPix"));		InOut.GPUStats[1] = FSynthBenchmarkStat(TEXT("TexHeavy"), 1.0f / 7.447f, TEXT("s/GigaPix"));		InOut.GPUStats[2] = FSynthBenchmarkStat(TEXT("DepTexHeavy"), 1.0f / 3.847f, TEXT("s/GigaPix"));		InOut.GPUStats[3] = FSynthBenchmarkStat(TEXT("FillOnly"), 1.0f / 25.463f, TEXT("s/GigaPix"));		InOut.GPUStats[4] = FSynthBenchmarkStat(TEXT("Bandwidth"), 1.0f / 1.072f, TEXT("s/GigaPix"));		// e.g. on NV670: Method3 (mostly fill rate )-> 26GP/s (seems realistic)		// reference: http://en.wikipedia.org/wiki/Comparison_of_Nvidia_graphics_processing_units theoretical: 29.3G/s		RHIEndRenderQuery(TimerQueries[0]);		// multiple iterations to see how trust able the values are		for(uint32 Iteration = 0; Iteration < IterationCount; ++Iteration)		{			for(uint32 MethodIterator = 0; MethodIterator < MethodCount; ++MethodIterator)			{				// alternate between forward and backward (should give the same number)				//			uint32 MethodId = (Iteration % 2) ? MethodIterator : (MethodCount - 1 - MethodIterator);				uint32 MethodId = MethodIterator;				uint32 QueryIndex = 1 + Iteration * MethodCount + MethodId;				// 0 / 1				const uint32 SrcRTIndex = 1 - DestRTIndex;				GRenderTargetPool.VisualizeTexture.SetCheckPoint(RTItems[DestRTIndex]);				RHISetRenderTarget(RTItems[DestRTIndex]->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());					// decide how much work we do in this pass				PassCount[Iteration] = (Iteration / 10 + 1) * WorkScale;				RunBenchmarkShader(View, MethodId, RTItems[SrcRTIndex], PassCount[Iteration]);				RHICopyToResolveTarget(RTItems[DestRTIndex]->GetRenderTargetItem().TargetableTexture, RTItems[DestRTIndex]->GetRenderTargetItem().ShaderResourceTexture, false, FResolveParams());				/*if(bGPUCPUSync)				{					// more consistent timing but strangely much faster to the level that is unrealistic					FResolveParams Param;					Param.Rect = FResolveRect(0, 0, 1, 1);					RHICopyToResolveTarget(						RTItems[DestRTIndex]->GetRenderTargetItem().TargetableTexture,//.........这里部分代码省略.........

void FRCPassPostProcessSubsurfaceRecombine::Process(FRenderingCompositePassContext& Context){	FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(Context.RHICmdList);	const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0);	check(InputDesc);	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntPoint SrcSize = InputDesc->Extent;	FIntPoint DestSize = SceneContext.GetBufferSizeXY();	check(DestSize.X);	check(DestSize.Y);	check(SrcSize.X);	check(SrcSize.Y);	FIntRect SrcRect = FIntRect(0, 0, InputDesc->Extent.X, InputDesc->Extent.Y);	FIntRect DestRect = View.ViewRect;	TRefCountPtr<IPooledRenderTarget>& SceneColor = SceneContext.GetSceneColor();	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	CopyOverOtherViewportsIfNeeded(Context, View);	Context.SetViewportAndCallRHI(0, 0, 0.0f, DestSize.X, DestSize.Y, 1.0f );	TShaderMapRef<FPostProcessVS> VertexShader(Context.GetShaderMap());	if(GetInput(ePId_Input1))	{		if(bHalfRes)		{			SetSubsurfaceRecombineShader<1>(Context, VertexShader);		}		else		{			SetSubsurfaceRecombineShader<0>(Context, VertexShader);		}	}	else	{		// needed for Scalability		SetSubsurfaceRecombineShader<2>(Context, VertexShader);	}	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());	// replace the current SceneColor with this one	SceneContext.SetSceneColor(PassOutputs[0].PooledRenderTarget);	PassOutputs[0].PooledRenderTarget.SafeRelease();}

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());}

//.........这里部分代码省略.........		SetRenderTarget(RHICmdList, DestRenderTarget.TargetableTexture, SceneContext.GetSceneDepthSurface(), ESimpleRenderTargetMode::EUninitializedColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilWrite);		Context.SetViewportAndCallRHI(View.ViewRect);		// Clear stencil to 0		RHICmdList.Clear(false, FLinearColor::White, false, (float)ERHIZBuffer::FarPlane, true, 0, View.ViewRect);				// bind shader		static FGlobalBoundShaderState BoundShaderState;		SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);		VertexShader->SetParameters(Context);		PixelShader->SetParameters(Context, SSRQuality, true);				// Clobers the stencil to pixel that should not compute SSR		RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always, true, CF_Always, SO_Replace, SO_Replace, SO_Replace>::GetRHI(), 0x80);		// Set rasterizer state to solid		RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());		// disable blend mode		RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());			// Draw a quad mapping scene color to the view's render target to set stencil to set the stencil mask where it needs to be		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(),			SceneContext.GetBufferSizeXY(),			*VertexShader,			EDRF_UseTriangleOptimization);	} // ScreenSpaceReflectionsStencil draw event	{ // ScreenSpaceReflections draw event		SCOPED_DRAW_EVENT(Context.RHICmdList, ScreenSpaceReflections);		if (SSRStencilPrePass)		{			// set up the stencil test to match 0, meaning FPostProcessScreenSpaceReflectionsStencilPS has been discarded			RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always, true, CF_Equal, SO_Keep, SO_Keep, SO_Keep>::GetRHI(), 0);		}		else		{			// bind only the dest render target			SetRenderTarget(RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());			Context.SetViewportAndCallRHI(View.ViewRect);			RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());		}		// clear DestRenderTarget only outside of the view's rectangle		RHICmdList.Clear(true, FLinearColor::Black, false, (float)ERHIZBuffer::FarPlane, false, 0, View.ViewRect);				// set the state		RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());		RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());		TShaderMapRef< FPostProcessVS > VertexShader(Context.GetShaderMap());		#define CASE(A, B) /			case (A + 2 * (B + 3 * 0 )): /			{ /				TShaderMapRef< FPostProcessScreenSpaceReflectionsPS<A, B> > PixelShader(Context.GetShaderMap()); /				static FGlobalBoundShaderState BoundShaderState; /				SetGlobalBoundShaderState(RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader); /				VertexShader->SetParameters(Context); /				PixelShader->SetParameters(Context); /			}; /			break		switch (iPreFrame + 2 * (SSRQuality + 3 * 0))		{			CASE(0,0);			CASE(0,1);	CASE(1,1);			CASE(0,2);	CASE(1,2);			CASE(0,3);	CASE(1,3);			CASE(0,4);	CASE(1,4);			CASE(0,5);	CASE(1,5); //SSRConeQuality			default:				check(!"Missing case in FRCPassPostProcessScreenSpaceReflections");		}		#undef CASE		// Draw a quad mapping scene color to the view's render target		DrawRectangle( 			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);		RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());	} // ScreenSpaceReflections}

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);	// Draw a quad mapping scene color to the view's render target	DrawRectangle(		Context.RHICmdList,		0, 0,		DestSize.X, DestSize.Y,		0, 0,		SrcSize.X, 0,		DestSize,		SrcSize,		*VertexShader,		EDRF_UseTriangleOptimization);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

void FRCPassPostProcessScreenSpaceReflections::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(Context.RHICmdList, ScreenSpaceReflections, DEC_SCENE_ITEMS);	const FSceneView& View = Context.View;	const auto FeatureLevel = Context.GetFeatureLevel();	const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context);	// Set the view family's render target/viewport.	SetRenderTarget(Context.RHICmdList, DestRenderTarget.TargetableTexture, FTextureRHIRef());	Context.RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 1.0f, false, 0, FIntRect());	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());	int SSRQuality = ComputeSSRQuality(View.FinalPostProcessSettings.ScreenSpaceReflectionQuality);	SSRQuality = FMath::Clamp(SSRQuality, 1, 4);		uint32 iPreFrame = bPrevFrame ? 1 : 0;	if (View.Family->EngineShowFlags.VisualizeSSR)	{		iPreFrame = 0;		SSRQuality = 0;	}	TShaderMapRef< FPostProcessVS > VertexShader(Context.GetShaderMap());	#define CASE(A, B) /		case (A + 2 * (B + 3 * 0 )): /		{ /			TShaderMapRef< FPostProcessScreenSpaceReflectionsPS<A, B> > PixelShader(Context.GetShaderMap()); /			static FGlobalBoundShaderState BoundShaderState; /			SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader); /			VertexShader->SetParameters(Context); /			PixelShader->SetParameters(Context); /		}; /		break	switch (iPreFrame + 2 * (SSRQuality + 3 * 0))	{		CASE(0,0);		CASE(0,1);	CASE(1,1);		CASE(0,2);	CASE(1,2);		CASE(0,3);	CASE(1,3);		CASE(0,4);	CASE(1,4);		default:			check(!"Missing case in FRCPassPostProcessScreenSpaceReflections");	}	#undef CASE	// 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(),		GSceneRenderTargets.GetBufferSizeXY(),		*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 FAtmosphereTextures::InitDynamicRHI(){	check(PrecomputeParams != NULL);	// Allocate atmosphere precompute textures...	{		// todo: Expose		// Transmittance		FIntPoint GTransmittanceTexSize(PrecomputeParams->TransmittanceTexWidth, PrecomputeParams->TransmittanceTexHeight);		FPooledRenderTargetDesc TransmittanceDesc(FPooledRenderTargetDesc::Create2DDesc(GTransmittanceTexSize, PF_FloatRGBA, FClearValueBinding::None, TexCreate_None, TexCreate_RenderTargetable, false));		GRenderTargetPool.FindFreeElement(TransmittanceDesc, AtmosphereTransmittance, TEXT("AtmosphereTransmittance"));		FRHICommandListImmediate& RHICmdList = FRHICommandListExecutor::GetImmediateCommandList();		SetRenderTarget(RHICmdList, AtmosphereTransmittance->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());		RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 0, false, 0, FIntRect());		RHICmdList.CopyToResolveTarget(AtmosphereTransmittance->GetRenderTargetItem().TargetableTexture, AtmosphereTransmittance->GetRenderTargetItem().ShaderResourceTexture, true, FResolveParams());		// Irradiance		FIntPoint GIrradianceTexSize(PrecomputeParams->IrradianceTexWidth, PrecomputeParams->IrradianceTexHeight);		FPooledRenderTargetDesc IrradianceDesc(FPooledRenderTargetDesc::Create2DDesc(GIrradianceTexSize, PF_FloatRGBA, FClearValueBinding::Black, TexCreate_None, TexCreate_RenderTargetable, false));		GRenderTargetPool.FindFreeElement(IrradianceDesc, AtmosphereIrradiance, TEXT("AtmosphereIrradiance"));		SetRenderTarget(RHICmdList, AtmosphereIrradiance->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());		RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 0, false, 0, FIntRect());		RHICmdList.CopyToResolveTarget(AtmosphereIrradiance->GetRenderTargetItem().TargetableTexture, AtmosphereIrradiance->GetRenderTargetItem().ShaderResourceTexture, true, FResolveParams());		// DeltaE		GRenderTargetPool.FindFreeElement(IrradianceDesc, AtmosphereDeltaE, TEXT("AtmosphereDeltaE"));		// 3D Texture		// Inscatter		FPooledRenderTargetDesc InscatterDesc(FPooledRenderTargetDesc::CreateVolumeDesc(PrecomputeParams->InscatterMuSNum * PrecomputeParams->InscatterNuNum, PrecomputeParams->InscatterMuNum, PrecomputeParams->InscatterAltitudeSampleNum, PF_FloatRGBA, FClearValueBinding::None, TexCreate_None, TexCreate_ShaderResource | TexCreate_RenderTargetable, false));		GRenderTargetPool.FindFreeElement(InscatterDesc, AtmosphereInscatter, TEXT("AtmosphereInscatter"));		// DeltaSR		GRenderTargetPool.FindFreeElement(InscatterDesc, AtmosphereDeltaSR, TEXT("AtmosphereDeltaSR"));		// DeltaSM		GRenderTargetPool.FindFreeElement(InscatterDesc, AtmosphereDeltaSM, TEXT("AtmosphereDeltaSM"));		// DeltaJ		GRenderTargetPool.FindFreeElement(InscatterDesc, AtmosphereDeltaJ, TEXT("AtmosphereDeltaJ"));	}}

void FRCPassPostProcessLpvIndirect::Process(FRenderingCompositePassContext& Context){	SCOPED_DRAW_EVENT(PostProcessLpvIndirect, DEC_SCENE_ITEMS);	const FPostProcessSettings& PostprocessSettings = Context.View.FinalPostProcessSettings;	const FSceneView& View = Context.View;	const FSceneViewFamily& ViewFamily = *(View.Family);	FIntRect SrcRect = View.ViewRect;	// todo: view size should scale with input texture size so we can do SSAO in half resolution as well	FIntRect DestRect = View.ViewRect;	FIntPoint DestSize = DestRect.Size();	uint32 NumReflectionCaptures = ViewFamily.Scene->GetRenderScene()->ReflectionSceneData.RegisteredReflectionCaptures.Num();	const FSceneRenderTargetItem& DestColorRenderTarget = GSceneRenderTargets.SceneColor->GetRenderTargetItem();	// Set the view family's render target/viewport.	FTextureRHIParamRef RenderTargets[] =	{		DestColorRenderTarget.TargetableTexture,	};	// Set the view family's render target/viewport.	RHISetRenderTargets(1, RenderTargets, GSceneRenderTargets.GetSceneDepthSurface(), 0, NULL);	Context.SetViewportAndCallRHI(View.ViewRect);	// set the state	if ( ViewFamily.EngineShowFlags.LpvLightingOnly )	{		RHISetBlendState( TStaticBlendState<>::GetRHI() );	}	else	{		// additive blending		RHISetBlendState(TStaticBlendState<CW_RGB,BO_Add,BF_One,BF_One>::GetRHI());	}	RHISetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHISetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());	TShaderMapRef<FPostProcessVS> VertexShader(GetGlobalShaderMap());	FSceneViewState* ViewState = (FSceneViewState*)View.State;	FLightPropagationVolume* Lpv = NULL;	bool bUseLpv = false;	if ( ViewState )	{		Lpv = ViewState->GetLightPropagationVolume();		bUseLpv = Lpv && PostprocessSettings.LPVIntensity > 0.0f;	}	if ( !bUseLpv )	{		return;	}	TShaderMapRef<FPostProcessLpvIndirectPS> PixelShader(GetGlobalShaderMap());	static FGlobalBoundShaderState BoundShaderState;	// call it once after setting up the shader data to avoid the warnings in the function	SetGlobalBoundShaderState(BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader);	FLpvReadUniformBufferParameters	LpvReadUniformBufferParams;	FLpvReadUniformBufferRef LpvReadUniformBuffer;	LpvReadUniformBufferParams = Lpv->GetReadUniformBufferParams();	LpvReadUniformBuffer = FLpvReadUniformBufferRef::CreateUniformBufferImmediate( LpvReadUniformBufferParams, UniformBuffer_SingleUse ); #if LPV_VOLUME_TEXTURE	FTextureRHIParamRef LpvBufferSrvs[7];	for ( int i = 0; i < 7; i++ ) 	{		LpvBufferSrvs[i] = Lpv->GetLpvBufferSrv(i);	}	PixelShader->SetParameters(LpvBufferSrvs, LpvReadUniformBuffer, Context );#else	FShaderResourceViewRHIParamRef LpvBufferSrv = Lpv->GetLpvBufferSrv();	PixelShader->SetParameters(LpvBufferSrv, LpvReadUniformBuffer, Context );#endif	// Draw a quad mapping scene color to the view's render target	DrawRectangle( 		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(),		GSceneRenderTargets.SceneColor->GetDesc().Extent);	RHICopyToResolveTarget(DestColorRenderTarget.TargetableTexture, DestColorRenderTarget.ShaderResourceTexture, false, FResolveParams());}

//.........这里部分代码省略.........	// 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	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);	FLinearColor LabelColor(1, 1, 0);	for (auto It = Labels.CreateConstIterator(); It; ++It)	{		Canvas.DrawShadowedString(It->LocationX, It->LocationY, *It->Label, GetStatsFont(), LabelColor);	}	Canvas.Flush();	RHICopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

//.........这里部分代码省略.........	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	{		float YOffset = bDoFastBlur ? -(InvSrcSize.Y * 0.5f) : 0.0f;		for (uint32 i = 0; i < NumSamples; ++i)		{			BlurOffsets[i] = FVector2D(0, InvSrcSize.Y * OffsetAndWeight[i].X + YOffset);		}	}	FShader* VertexShader = nullptr;	SetFilterShaders(		Context.RHICmdList,		FeatureLevel,		TStaticSamplerState<SF_Bilinear,AM_Border,AM_Border,AM_Clamp>::GetRHI(),		FilterTexture,		AdditiveTexture,		CombineMethodInt,		BlurOffsets,		BlurWeights,		NumSamples,		&VertexShader		);	bool bRequiresClear = true;	// check if we have to clear the whole surface.	// Otherwise perform the clear when the dest rectangle has been computed.	if (FeatureLevel == ERHIFeatureLevel::ES2 || FeatureLevel == ERHIFeatureLevel::ES3_1)	{		Context.RHICmdList.Clear(true, FLinearColor(0, 0, 0, 0), false, 1.0f, false, 0, FIntRect());		bRequiresClear = false;	}	FIntRect SrcRect =  FIntRect::DivideAndRoundUp(View.ViewRect, SrcScaleFactor);	FIntRect DestRect = FIntRect::DivideAndRoundUp(View.ViewRect, DstScaleFactor);	DrawQuad(Context.RHICmdList, bDoFastBlur, SrcRect, DestRect, bRequiresClear, DestSize, SrcSize, VertexShader);	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

/** Applies screen space radial blur passes. */void ApplyRadialBlurPasses(	FRHICommandListImmediate& RHICmdList,	const FViewInfo& View, 	const FLightSceneInfo* const LightSceneInfo, 	/** First pass source - this will not be overwritten. */	TRefCountPtr<IPooledRenderTarget>& FirstPassSource, 	/** Subsequent pass source, will also contain the final result. */	TRefCountPtr<IPooledRenderTarget>& LightShaftsSource, 	/** First pass dest. */	TRefCountPtr<IPooledRenderTarget>& LightShaftsDest){	TShaderMapRef<FScreenVS> ScreenVertexShader(View.ShaderMap);	const FIntPoint BufferSize = FSceneRenderTargets::Get(RHICmdList).GetBufferSizeXY();	const uint32 DownsampleFactor	= GetLightShaftDownsampleFactor();	const FIntPoint FilterBufferSize = BufferSize / DownsampleFactor;	const FIntPoint DownSampledXY = View.ViewRect.Min / DownsampleFactor;	const uint32 DownsampledSizeX = View.ViewRect.Width() / DownsampleFactor;	const uint32 DownsampledSizeY = View.ViewRect.Height() / DownsampleFactor;	const uint32 NumPasses = FMath::Max(GLightShaftBlurPasses, 0);	for (uint32 PassIndex = 0; PassIndex < NumPasses; PassIndex++)	{		SetRenderTarget(RHICmdList, LightShaftsDest->GetRenderTargetItem().TargetableTexture, FTextureRHIRef());		RHICmdList.SetViewport(0, 0, 0.0f, FilterBufferSize.X, FilterBufferSize.Y, 1.0f);		RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());		RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());		RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());		TShaderMapRef<FBlurLightShaftsPixelShader> BlurLightShaftsPixelShader(View.ShaderMap);		SetGlobalBoundShaderState(RHICmdList, View.GetFeatureLevel(), BlurLightShaftsBoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *ScreenVertexShader, *BlurLightShaftsPixelShader);		TRefCountPtr<IPooledRenderTarget>& EffectiveSource = PassIndex == 0 ? FirstPassSource : LightShaftsSource;		/// ?		BlurLightShaftsPixelShader->SetParameters(RHICmdList, LightSceneInfo, View, PassIndex, EffectiveSource);		{			// Apply a radial blur to the bloom and occlusion mask			DrawRectangle( 				RHICmdList,				DownSampledXY.X, DownSampledXY.Y, 				DownsampledSizeX, DownsampledSizeY,				DownSampledXY.X, DownSampledXY.Y, 				DownsampledSizeX, DownsampledSizeY,				FilterBufferSize, FilterBufferSize,				*ScreenVertexShader,				EDRF_UseTriangleOptimization);		}		RHICmdList.CopyToResolveTarget(LightShaftsDest->GetRenderTargetItem().TargetableTexture, LightShaftsDest->GetRenderTargetItem().ShaderResourceTexture, false, FResolveParams());		// Swap input and output for the next pass		Swap(LightShaftsSource, LightShaftsDest);	}}

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 FScene::UpdateSceneCaptureContents(USceneCaptureComponent2D* CaptureComponent){	check(CaptureComponent);	if (CaptureComponent->TextureTarget)	{		const FTransform& Transform = CaptureComponent->GetComponentToWorld();		FMatrix ViewMatrix = Transform.ToInverseMatrixWithScale();		FVector ViewLocation = Transform.GetTranslation();		// swap axis st. x=z,y=x,z=y (unreal coord space) so that z is up		ViewMatrix = ViewMatrix * FMatrix(			FPlane(0,	0,	1,	0),			FPlane(1,	0,	0,	0),			FPlane(0,	1,	0,	0),			FPlane(0,	0,	0,	1));		const float FOV = CaptureComponent->FOVAngle * (float)PI / 360.0f;		const bool bUseSceneColorTexture = CaptureComponent->CaptureSource == SCS_SceneColorHDR;		FSceneRenderer* SceneRenderer = CreateSceneRenderer(CaptureComponent, CaptureComponent->TextureTarget, ViewMatrix , ViewLocation, FOV, CaptureComponent->MaxViewDistanceOverride, bUseSceneColorTexture, &CaptureComponent->PostProcessSettings, CaptureComponent->PostProcessBlendWeight);		FTextureRenderTargetResource* TextureRenderTarget = CaptureComponent->TextureTarget->GameThread_GetRenderTargetResource();		const FName OwnerName = CaptureComponent->GetOwner() ? CaptureComponent->GetOwner()->GetFName() : NAME_None;		ENQUEUE_UNIQUE_RENDER_COMMAND_FOURPARAMETER( 			CaptureCommand,			FSceneRenderer*, SceneRenderer, SceneRenderer,			FTextureRenderTargetResource*, TextureRenderTarget, TextureRenderTarget,			FName, OwnerName, OwnerName,			bool, bUseSceneColorTexture, bUseSceneColorTexture,		{			UpdateSceneCaptureContent_RenderThread(RHICmdList, SceneRenderer, TextureRenderTarget, OwnerName, FResolveParams(), bUseSceneColorTexture);		});	}

//.........这里部分代码省略.........	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;		Line = FString::Printf(TEXT("%g%% .. %g%%"), View.FinalPostProcessSettings.AutoExposureLowPercent, View.FinalPostProcessSettings.AutoExposureHighPercent);	Canvas.DrawShadowedString( X, Y += YStep, TEXT("EyeAdaptationPercent Low/High:"), GetStatsFont(), FLinearColor(1, 1, 1));	Canvas.DrawShadowedString( X + ColumnWidth, Y, *Line, GetStatsFont(), FLinearColor(1, 1, 1));	Line = FString::Printf(TEXT("%g .. %g"), View.FinalPostProcessSettings.AutoExposureMinBrightness, View.FinalPostProcessSettings.AutoExposureMaxBrightness);	Canvas.DrawShadowedString( X, Y += YStep, TEXT("EyeAdaptationBrightness Min/Max:"), GetStatsFont(), FLinearColor(1, 1, 1));	Canvas.DrawShadowedString( X + ColumnWidth, Y, *Line, GetStatsFont(), FLinearColor(0.3f, 0.3f, 1));	Line = FString::Printf(TEXT("%g / %g"), View.FinalPostProcessSettings.AutoExposureSpeedUp, View.FinalPostProcessSettings.AutoExposureSpeedDown);	Canvas.DrawShadowedString( X, Y += YStep, TEXT("EyeAdaptionSpeed Up/Down:"), GetStatsFont(), FLinearColor(1, 1, 1));	Canvas.DrawShadowedString( X + ColumnWidth, Y, *Line, GetStatsFont(), FLinearColor(1, 1, 1));	Line = FString::Printf(TEXT("%g"), View.FinalPostProcessSettings.AutoExposureBias);	Canvas.DrawShadowedString( X, Y += YStep, TEXT("Exposure Offset: "), GetStatsFont(), FLinearColor(1, 1, 1));	Canvas.DrawShadowedString( X + ColumnWidth, Y, *Line, GetStatsFont(), FLinearColor(1, 0.3f, 0.3f));	Line = FString::Printf(TEXT("%g .. %g (log2)"),		View.FinalPostProcessSettings.HistogramLogMin, View.FinalPostProcessSettings.HistogramLogMax);	Canvas.DrawShadowedString( X, Y += YStep, TEXT("HistogramLog Min/Max:"), GetStatsFont(), FLinearColor(1, 1, 1));	Canvas.DrawShadowedString( X + ColumnWidth, Y, *Line, GetStatsFont(), FLinearColor(1, 0.3f, 0.3f));	Line = FString::Printf(TEXT("%s .. %s (Value)"),		*LogToString(View.FinalPostProcessSettings.HistogramLogMin), *LogToString(View.FinalPostProcessSettings.HistogramLogMax));	Canvas.DrawShadowedString( X + ColumnWidth, Y+= YStep, *Line, GetStatsFont(), FLinearColor(0.3f, 0.3f, 1));	Canvas.Flush();	RHICopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.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());}

//.........这里部分代码省略.........	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)		{			FLinearColor FlareColor = Context.View.FinalPostProcessSettings.LensFlareTints[i % 8];			float NormalizedAlpha = FlareColor.A;			float Alpha = NormalizedAlpha * 7.0f - 3.5f; 			// scale to blur outside of the view (only if we use LensBlur)			Alpha *= SizeScale;						// set the individual flare color			SetShaderValue(Context.RHICmdList, PixelShader->GetPixelShader(), PixelShader->FlareColor, FlareColor * LensFlareHDRColor);			// Draw a quad mapping scene color to the view's render target			DrawRectangle(				Context.RHICmdList,				Center.X - 0.5f * ViewSize1.X * Alpha, Center.Y - 0.5f * ViewSize1.Y * Alpha,				ViewSize1.X * Alpha, ViewSize1.Y * Alpha,				ViewRect2.Min.X, ViewRect2.Min.Y,				ViewSize2.X, ViewSize2.Y,				ViewSize1,				TexSize2,				*VertexShader,				EDRF_Default);		}	}	Context.RHICmdList.CopyToResolveTarget(DestRenderTarget.TargetableTexture, DestRenderTarget.ShaderResourceTexture, false, FResolveParams());}

//.........这里部分代码省略.........				FDecalDepthState LastDecalDepthState;				int32 LastDecalBlendMode = -1;				int32 LastDecalHasNormal = -1; // Decal state can change based on its normal property.(SM5)							FDecalRenderingCommon::ERenderTargetMode LastRenderTargetMode = FDecalRenderingCommon::RTM_Unknown;				const ERHIFeatureLevel::Type SMFeatureLevel = Context.GetFeatureLevel();				SCOPED_DRAW_EVENT(RHICmdList, Decals);				INC_DWORD_STAT_BY(STAT_Decals, SortedDecals.Num());				for (int32 DecalIndex = 0, DecalCount = SortedDecals.Num(); DecalIndex < DecalCount; DecalIndex++)				{					const FTransientDecalRenderData& DecalData = SortedDecals[DecalIndex];					const FDeferredDecalProxy& DecalProxy = *DecalData.DecalProxy;					const FMatrix ComponentToWorldMatrix = DecalProxy.ComponentTrans.ToMatrixWithScale();					const FMatrix FrustumComponentToClip = FDecalRendering::ComputeComponentToClipMatrix(View, ComponentToWorldMatrix);					EDecalBlendMode DecalBlendMode = DecalData.DecalBlendMode;					EDecalRenderStage LocalDecalStage = FDecalRenderingCommon::ComputeRenderStage(View.GetShaderPlatform(), DecalBlendMode);					bool bStencilThisDecal = IsStencilOptimizationAvailable(LocalDecalStage);					FDecalRenderingCommon::ERenderTargetMode CurrentRenderTargetMode = FDecalRenderingCommon::ComputeRenderTargetMode(View.GetShaderPlatform(), DecalBlendMode, DecalData.bHasNormal);					if (bShaderComplexity)					{						CurrentRenderTargetMode = FDecalRenderingCommon::RTM_SceneColor;						// we want additive blending for the ShaderComplexity mode						DecalBlendMode = DBM_Emissive;					}					// Here we assume that GBuffer can only be WorldNormal since it is the only GBufferTarget handled correctly.					if (RenderTargetManager.bGufferADirty && DecalData.MaterialResource->NeedsGBuffer())					{ 						RHICmdList.CopyToResolveTarget(SceneContext.GBufferA->GetRenderTargetItem().TargetableTexture, SceneContext.GBufferA->GetRenderTargetItem().TargetableTexture, true, FResolveParams());						RenderTargetManager.TargetsToResolve[FDecalRenderTargetManager::GBufferAIndex] =  nullptr;						RenderTargetManager.bGufferADirty = false;					}					// fewer rendertarget switches if possible					if (CurrentRenderTargetMode != LastRenderTargetMode)					{						LastRenderTargetMode = CurrentRenderTargetMode;						RenderTargetManager.SetRenderTargetMode(CurrentRenderTargetMode, DecalData.bHasNormal);						Context.SetViewportAndCallRHI(Context.View.ViewRect);					}					bool bThisDecalUsesStencil = false;					if (bStencilThisDecal && bStencilSizeThreshold)					{						// note this is after a SetStreamSource (in if CurrentRenderTargetMode != LastRenderTargetMode) call as it needs to get the VB input						bThisDecalUsesStencil = RenderPreStencil(Context, ComponentToWorldMatrix, FrustumComponentToClip);						LastDecalRasterizerState = DRS_Undefined;						LastDecalDepthState = FDecalDepthState();						LastDecalBlendMode = -1;					}					const bool bBlendStateChange = DecalBlendMode != LastDecalBlendMode;// Has decal mode changed.					const bool bDecalNormalChanged = GSupportsSeparateRenderTargetBlendState && // has normal changed for SM5 stain/translucent decals?						(DecalBlendMode == DBM_Translucent || DecalBlendMode == DBM_Stain) &&						(int32)DecalData.bHasNormal != LastDecalHasNormal;					// fewer blend state changes if possible					if (bBlendStateChange || bDecalNormalChanged)