UE4 SkyLight 记录

谁践踏了优雅 2022-09-15 11:44 337阅读 0赞

背景：

想了解一下，UE4如何使用HDR图，作为环境光，官方有个插件HDRIBackdrop，主要就是使用SkyLight进行，因此重点看了一下SkyLight，记录一下。

现在主要是记录过程，后面整理一个框架。

流程：

从Recapture入手，刚好转换的流程执行一遍。

  1. D:\UnrealEngine426\Engine\Source\Runtime\Engine\Private\Components\SkyLightComponent.cpp

    1. FAutoConsoleCommandWithWorld CaptureConsoleCommand(
      1. TEXT("r.SkylightRecapture"),
      2. TEXT("Updates all stationary and movable skylights, useful for debugging the capture pipeline"),
      3. FConsoleCommandWithWorldDelegate::CreateStatic(OnUpdateSkylights)
      4. );
    2. void OnUpdateSkylights(UWorld* InWorld)
      {
      1. for (TObjectIterator<USkyLightComponent> It; It; ++It)
      2. {
      3.     USkyLightComponent* SkylightComponent = *It;
      4.     if (InWorld->ContainsActor(SkylightComponent->GetOwner()) && !SkylightComponent->IsPendingKill())
      5.     {            
      6.         SkylightComponent->SetCaptureIsDirty();            
      7.     }
      8. }
      9. USkyLightComponent::UpdateSkyCaptureContents(InWorld);
      }

    3. void USkyLightComponent::UpdateSkyCaptureContents(UWorld* WorldToUpdate)
      {

      1. if (WorldToUpdate->Scene)
      2. {
      3.     QUICK_SCOPE_CYCLE_COUNTER(STAT_SkylightCaptures);
      5.     if (GUpdateSkylightsEveryFrame)
      6.     {
      7.         for (TObjectIterator<USkyLightComponent> It; It; ++It)
      8.         {
      9.             USkyLightComponent* SkylightComponent = *It;
      10.             if (WorldToUpdate->ContainsActor(SkylightComponent->GetOwner()) && !SkylightComponent->IsPendingKill())
      11.             {            
      12.                 SkylightComponent->SetCaptureIsDirty();            
      13.             }
      14.         }
      15.     }
      17.     if (SkyCapturesToUpdate.Num() > 0)
      18.     {
      19.         FScopeLock Lock(&SkyCapturesToUpdateLock);
      20.         UpdateSkyCaptureContentsArray(WorldToUpdate, SkyCapturesToUpdate, true);
      21.     }
      23.     if (SkyCapturesToUpdateBlendDestinations.Num() > 0)
      24.     {
      25.         UpdateSkyCaptureContentsArray(WorldToUpdate, SkyCapturesToUpdateBlendDestinations, false);
      26.     }
      27. }

      }

    4. void USkyLightComponent::UpdateSkyCaptureContentsArray(UWorld WorldToUpdate, TArray<USkyLightComponent>& ComponentArray, bool bOperateOnBlendSource)
      {

      1. const bool bIsCompilingShaders = GShaderCompilingManager != NULL && GShaderCompilingManager->IsCompiling();
      3. // Iterate backwards so we can remove elements without changing the index
      4. for (int32 CaptureIndex = ComponentArray.Num() - 1; CaptureIndex >= 0; CaptureIndex--)
      5. {
      6.     USkyLightComponent* CaptureComponent = ComponentArray[CaptureIndex];
      7.     AActor* Owner = CaptureComponent->GetOwner();
      9.     if (((!Owner || !Owner->GetLevel() || Owner->GetLevel()->bIsVisible) && CaptureComponent->GetWorld() == WorldToUpdate)
      10.         // Only process sky capture requests once async shader compiling completes, otherwise we will capture the scene with temporary shaders
      11.         && (!bIsCompilingShaders || CaptureComponent->SourceType == SLS_SpecifiedCubemap))
      12.     {
      13.         // Only capture valid sky light components
      14.         if (CaptureComponent->SourceType != SLS_SpecifiedCubemap || CaptureComponent->Cubemap)
      15.         {

      if WITH_EDITOR

      1.             FStaticLightingSystemInterface::OnLightComponentUnregistered.Broadcast(CaptureComponent);

      endif

      1.             if (bOperateOnBlendSource)
      2.             {
      3.                 ensure(!CaptureComponent->ProcessedSkyTexture || CaptureComponent->ProcessedSkyTexture->GetSizeX() == CaptureComponent->ProcessedSkyTexture->GetSizeY());
      5.                 // Allocate the needed texture on first capture
      6.                 if (!CaptureComponent->ProcessedSkyTexture || CaptureComponent->ProcessedSkyTexture->GetSizeX() != CaptureComponent->CubemapResolution)
      7.                 {
      8.                     CaptureComponent->ProcessedSkyTexture = new FSkyTextureCubeResource();
      9.                     CaptureComponent->ProcessedSkyTexture->SetupParameters(CaptureComponent->CubemapResolution, FMath::CeilLogTwo(CaptureComponent->CubemapResolution) + 1, SKYLIGHT_CUBEMAP_FORMAT);
      10.                     BeginInitResource(CaptureComponent->ProcessedSkyTexture);
      11.                     CaptureComponent->MarkRenderStateDirty();
      12.                 }
      14.                 WorldToUpdate->Scene->UpdateSkyCaptureContents(CaptureComponent, CaptureComponent->bCaptureEmissiveOnly, CaptureComponent->Cubemap, CaptureComponent->ProcessedSkyTexture, CaptureComponent->AverageBrightness, CaptureComponent->IrradianceEnvironmentMap, NULL);
      15.                 CaptureComponent->UpdateImportanceSamplingData();
      16.             }
      17.             else
      18.             {
      19.                 ensure(!CaptureComponent->BlendDestinationProcessedSkyTexture || CaptureComponent->BlendDestinationProcessedSkyTexture->GetSizeX() == CaptureComponent->BlendDestinationProcessedSkyTexture->GetSizeY());
      21.                 // Allocate the needed texture on first capture
      22.                 if (!CaptureComponent->BlendDestinationProcessedSkyTexture || CaptureComponent->BlendDestinationProcessedSkyTexture->GetSizeX() != CaptureComponent->CubemapResolution)
      23.                 {
      24.                     CaptureComponent->BlendDestinationProcessedSkyTexture = new FSkyTextureCubeResource();
      25.                     CaptureComponent->BlendDestinationProcessedSkyTexture->SetupParameters(CaptureComponent->CubemapResolution, FMath::CeilLogTwo(CaptureComponent->CubemapResolution) + 1, SKYLIGHT_CUBEMAP_FORMAT);
      26.                     BeginInitResource(CaptureComponent->BlendDestinationProcessedSkyTexture);
      27.                     CaptureComponent->MarkRenderStateDirty(); 
      28.                 }
      30.                 WorldToUpdate->Scene->UpdateSkyCaptureContents(CaptureComponent, CaptureComponent->bCaptureEmissiveOnly, CaptureComponent->BlendDestinationCubemap, CaptureComponent->BlendDestinationProcessedSkyTexture, CaptureComponent->BlendDestinationAverageBrightness, CaptureComponent->BlendDestinationIrradianceEnvironmentMap, NULL);
      31.                 CaptureComponent->UpdateImportanceSamplingData();
      32.             }
      34.             CaptureComponent->IrradianceMapFence.BeginFence();
      35.             CaptureComponent->bHasEverCaptured = true;
      36.             CaptureComponent->MarkRenderStateDirty();

      if WITH_EDITOR

      1.             FStaticLightingSystemInterface::OnLightComponentRegistered.Broadcast(CaptureComponent);

      endif

      1.         }
      3.         // Only remove queued update requests if we processed it for the right world
      4.         ComponentArray.RemoveAt(CaptureIndex);
      5.     }
      6. }

      }

  2. D:\UnrealEngine426\Engine\Source\Runtime\Renderer\Private\ReflectionEnvironmentCapture.cpp

    1. // Warning: returns before writes to OutIrradianceEnvironmentMap have completed, as they are queued on the rendering thread
      void FScene::UpdateSkyCaptureContents(

      1. const USkyLightComponent* CaptureComponent, 
      2. bool bCaptureEmissiveOnly, 
      3. UTextureCube* SourceCubemap, 
      4. FTexture* OutProcessedTexture, 
      5. float& OutAverageBrightness, 
      6. FSHVectorRGB3& OutIrradianceEnvironmentMap,
      7. TArray<FFloat16Color>* OutRadianceMap)

      { 

      1. if (GSupportsRenderTargetFormat_PF_FloatRGBA || GetFeatureLevel() >= ERHIFeatureLevel::SM5)
      2. {
      3.     QUICK_SCOPE_CYCLE_COUNTER(STAT_UpdateSkyCaptureContents);
      4.     {
      5.         World = GetWorld();
      6.         if (World)
      7.         {
      8.             //guarantee that all render proxies are up to date before kicking off this render
      9.             World->SendAllEndOfFrameUpdates();
      10.         }
      11.     }
      12.     {
      13.         int32 CubemapSize = CaptureComponent->CubemapResolution;
      14.         ENQUEUE_RENDER_COMMAND(ClearCommand)(
      15.             [CubemapSize](FRHICommandListImmediate& RHICmdList)
      16.             {
      17.                 ClearScratchCubemaps(RHICmdList, CubemapSize);
      18.             });
      19.     }
      21.     if (CaptureComponent->SourceType == SLS_CapturedScene)
      22.     {
      23.         bool bStaticSceneOnly = CaptureComponent->Mobility == EComponentMobility::Static;
      24.         bool bCapturingForMobile = false;
      25.         CaptureSceneIntoScratchCubemap(this, CaptureComponent->GetComponentLocation(), CaptureComponent->CubemapResolution, true, bStaticSceneOnly, CaptureComponent->SkyDistanceThreshold, CaptureComponent->bLowerHemisphereIsBlack, bCaptureEmissiveOnly, CaptureComponent->LowerHemisphereColor, bCapturingForMobile);
      26.     }
      27.     else if (CaptureComponent->SourceType == SLS_SpecifiedCubemap)
      28.     {
      29.         int32 CubemapSize = CaptureComponent->CubemapResolution;
      30.         bool bLowerHemisphereIsBlack = CaptureComponent->bLowerHemisphereIsBlack;
      31.         float SourceCubemapRotation = CaptureComponent->SourceCubemapAngle * (PI / 180.f);
      32.         ERHIFeatureLevel::Type InnerFeatureLevel = FeatureLevel;
      33.         FLinearColor LowerHemisphereColor = CaptureComponent->LowerHemisphereColor;
      34.         ENQUEUE_RENDER_COMMAND(CopyCubemapCommand)(
      35.             [SourceCubemap, CubemapSize, bLowerHemisphereIsBlack, SourceCubemapRotation, InnerFeatureLevel, LowerHemisphereColor](FRHICommandListImmediate& RHICmdList)
      36.             {
      37.                 CopyCubemapToScratchCubemap(RHICmdList, InnerFeatureLevel, SourceCubemap, CubemapSize, true, bLowerHemisphereIsBlack, SourceCubemapRotation, LowerHemisphereColor);
      38.             });
      39.     }
      40.     else if (CaptureComponent->IsRealTimeCaptureEnabled())
      41.     {
      42.         ensureMsgf(false, TEXT("A sky light with RealTimeCapture enabled cannot be scheduled for a cubemap update. This will be done dynamically each frame by the renderer."));
      43.         return;
      44.     }
      45.     else
      46.     {
      47.         check(0);
      48.     }
      50.     if (OutRadianceMap)
      51.     {
      52.         int32 CubemapSize = CaptureComponent->CubemapResolution;
      53.         ENQUEUE_RENDER_COMMAND(ReadbackCommand)(
      54.             [CubemapSize, OutRadianceMap](FRHICommandListImmediate& RHICmdList)
      55.             {
      56.                 ReadbackRadianceMap(RHICmdList, CubemapSize, *OutRadianceMap);
      57.             });
      58.     }
      60.     {
      61.         int32 CubemapSize = CaptureComponent->CubemapResolution;
      62.         float* AverageBrightness = &OutAverageBrightness;
      63.         FSHVectorRGB3* IrradianceEnvironmentMap = &OutIrradianceEnvironmentMap;
      64.         ERHIFeatureLevel::Type InFeatureLevel = GetFeatureLevel();
      65.         ENQUEUE_RENDER_COMMAND(FilterCommand)(
      66.             [CubemapSize, AverageBrightness, IrradianceEnvironmentMap, InFeatureLevel](FRHICommandListImmediate& RHICmdList)
      67.             {
      68.                 if (InFeatureLevel <= ERHIFeatureLevel::ES3_1)
      69.                 {
      70.                     MobileReflectionEnvironmentCapture::ComputeAverageBrightness(RHICmdList, InFeatureLevel, CubemapSize, *AverageBrightness);
      71.                     MobileReflectionEnvironmentCapture::FilterReflectionEnvironment(RHICmdList, InFeatureLevel, CubemapSize, IrradianceEnvironmentMap);
      72.                 }
      73.                 else
      74.                 {
      75.                     ComputeAverageBrightness(RHICmdList, InFeatureLevel, CubemapSize, *AverageBrightness);
      76.                     FilterReflectionEnvironment(RHICmdList, InFeatureLevel, CubemapSize, IrradianceEnvironmentMap);
      77.                 }
      78.             });
      79.     }
      81.     // Optionally copy the filtered mip chain to the output texture
      82.     if (OutProcessedTexture)
      83.     {
      84.         FScene* Scene = this;
      85.         ERHIFeatureLevel::Type InFeatureLevel = GetFeatureLevel();
      86.         ENQUEUE_RENDER_COMMAND(CopyCommand)(
      87.             [Scene, OutProcessedTexture, InFeatureLevel](FRHICommandListImmediate& RHICmdList)
      88.             {
      89.                 if (InFeatureLevel <= ERHIFeatureLevel::ES3_1)
      90.                 {
      91.                     MobileReflectionEnvironmentCapture::CopyToSkyTexture(RHICmdList, Scene, OutProcessedTexture);
      92.                 }
      93.                 else
      94.                 {
      95.                     CopyToSkyTexture(RHICmdList, Scene, OutProcessedTexture);
      96.                 }
      97.             });
      98.     }
      100.     if (!!GFreeReflectionScratchAfterUse)
      101.     {
      102.         ENQUEUE_RENDER_COMMAND(FreeReflectionScratch)(
      103.             [](FRHICommandListImmediate& RHICmdList)
      104.         {
      105.             FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
      106.             SceneContext.FreeReflectionScratchRenderTargets();
      107.             GRenderTargetPool.FreeUnusedResources();
      108.         });
      109.     }
      110. }

      }

    2. void CopyCubemapToScratchCubemap(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, UTextureCube* SourceCubemap, int32 CubemapSize, bool bIsSkyLight, bool bLowerHemisphereIsBlack, float SourceCubemapRotation, const FLinearColor& LowerHemisphereColorValue)
      {

      1. SCOPED_DRAW_EVENT(RHICmdList, CopyCubemapToScratchCubemap);
      2. check(SourceCubemap);
      4. const FTexture* SourceCubemapResource = SourceCubemap->Resource;
      5. if (SourceCubemapResource == nullptr)
      6. {
      7.     UE_LOG(LogEngine, Warning, TEXT("Unable to copy from cubemap %s, it's RHI resource is null"), *SourceCubemap->GetPathName());
      8.     return;
      9. }
      11. FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
      13. FMemMark Mark(FMemStack::Get());
      14. FRDGBuilder GraphBuilder(RHICmdList);
      16. FRDGTextureRef OutputTexture = GraphBuilder.RegisterExternalTexture(SceneContext.ReflectionColorScratchCubemap[0], TEXT("ReflectionColorScratchCubemap"));
      18. for (uint32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
      19. {
      20.     auto* PassParameters = GraphBuilder.AllocParameters<FCopyCubemapToCubeFacePS::FParameters>();
      21.     PassParameters->RenderTargets[0] = FRenderTargetBinding(OutputTexture, ERenderTargetLoadAction::ENoAction, 0, CubeFace);
      22.     PassParameters->LowerHemisphereColor = LowerHemisphereColorValue;
      23.     PassParameters->SkyLightCaptureParameters = FVector(bIsSkyLight ? 1.0f : 0.0f, 0.0f, bLowerHemisphereIsBlack ? 1.0f : 0.0f);
      24.     PassParameters->SourceCubemapSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
      25.     PassParameters->SourceCubemapTexture = SourceCubemapResource->TextureRHI;
      26.     PassParameters->SinCosSourceCubemapRotation = FVector2D(FMath::Sin(SourceCubemapRotation), FMath::Cos(SourceCubemapRotation));
      27.     PassParameters->CubeFace = CubeFace;
      29.     const int32 EffectiveSize = CubemapSize;
      31.     GraphBuilder.AddPass(
      32.         RDG_EVENT_NAME("CopyCubemapToCubeFace"),
      33.         PassParameters,
      34.         ERDGPassFlags::Raster,
      35.         [EffectiveSize, &SceneContext, SourceCubemapResource, PassParameters, FeatureLevel](FRHICommandList& InRHICmdList)
      36.     {
      37.         const FIntPoint SourceDimensions(SourceCubemapResource->GetSizeX(), SourceCubemapResource->GetSizeY());
      38.         const FIntRect ViewRect(0, 0, EffectiveSize, EffectiveSize);
      39.         InRHICmdList.SetViewport(0.0f, 0.0f, 0.0f, (float)EffectiveSize, (float)EffectiveSize, 1.0f);
      41.         FGraphicsPipelineStateInitializer GraphicsPSOInit;
      42.         InRHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
      43.         GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
      44.         GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
      45.         GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
      47.         TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
      48.         TShaderMapRef<FCopyCubemapToCubeFacePS> PixelShader(GetGlobalShaderMap(FeatureLevel));
      50.         GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
      51.         GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
      52.         GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
      53.         GraphicsPSOInit.PrimitiveType = PT_TriangleList;
      55.         SetGraphicsPipelineState(InRHICmdList, GraphicsPSOInit);
      56.         SetShaderParameters(InRHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
      58.         DrawRectangle(
      59.             InRHICmdList,
      60.             ViewRect.Min.X, ViewRect.Min.Y,
      61.             ViewRect.Width(), ViewRect.Height(),
      62.             0, 0,
      63.             SourceDimensions.X, SourceDimensions.Y,
      64.             FIntPoint(ViewRect.Width(), ViewRect.Height()),
      65.             SourceDimensions,
      66.             VertexShader);
      67.     });
      68. }
      70. GraphBuilder.Execute();

      }

    3. class FCopyToCubeFaceShader : public FGlobalShader
      {
      public:

      1. static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
      2. {
      3.     return true;
      4. }
      6. FCopyToCubeFaceShader() = default;
      7. FCopyToCubeFaceShader(const CompiledShaderInitializerType& Initializer)
      8.     : FGlobalShader(Initializer)
      9. {}

      };

      /* Pixel shader used when copying a cubemap into a face of a reflection capture cubemap. /
      class FCopyCubemapToCubeFacePS : public FCopyToCubeFaceShader
      {
      public:

      1. DECLARE_GLOBAL_SHADER(FCopyCubemapToCubeFacePS);
      2. SHADER_USE_PARAMETER_STRUCT(FCopyCubemapToCubeFacePS, FCopyToCubeFaceShader);
      4. BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
      5.     SHADER_PARAMETER_TEXTURE(TextureCube, SourceCubemapTexture)
      6.     SHADER_PARAMETER_SAMPLER(SamplerState, SourceCubemapSampler)
      7.     SHADER_PARAMETER(FVector, SkyLightCaptureParameters)
      8.     SHADER_PARAMETER(int32, CubeFace)
      9.     SHADER_PARAMETER(FVector4, LowerHemisphereColor)
      10.     SHADER_PARAMETER(FVector2D, SinCosSourceCubemapRotation)
      11.     RENDER_TARGET_BINDING_SLOTS()
      12. END_SHADER_PARAMETER_STRUCT()

      };

      IMPLEMENT_GLOBAL_SHADER(FCopyCubemapToCubeFacePS, “/Engine/Private/ReflectionEnvironmentShaders.usf”, “CopyCubemapToCubeFaceColorPS”, SF_Pixel);

      1. D:\UnrealEngine426\Engine\Shaders\Private\ReflectionEnvironmentShaders.usf

      2. int CubeFace;

        float3 GetCubemapVector(float2 ScaledUVs, int InCubeFace)
        {

        1. float3 CubeCoordinates;
        3. //@todo - this could be a 3x3 matrix multiply
        4. if (InCubeFace == 0)
        5. {
        6.     CubeCoordinates = float3(1, -ScaledUVs.y, -ScaledUVs.x);
        7. }
        8. else if (InCubeFace == 1)
        9. {
        10.     CubeCoordinates = float3(-1, -ScaledUVs.y, ScaledUVs.x);
        11. }
        12. else if (InCubeFace == 2)
        13. {
        14.     CubeCoordinates = float3(ScaledUVs.x, 1, ScaledUVs.y);
        15. }
        16. else if (InCubeFace == 3)
        17. {
        18.     CubeCoordinates = float3(ScaledUVs.x, -1, -ScaledUVs.y);
        19. }
        20. else if (InCubeFace == 4)
        21. {
        22.     CubeCoordinates = float3(ScaledUVs.x, -ScaledUVs.y, 1);
        23. }
        24. else
        25. {
        26.     CubeCoordinates = float3(-ScaledUVs.x, -ScaledUVs.y, -1);
        27. }
        29. return CubeCoordinates;

        }

  1.                 TextureCube SourceCubemapTexture;
  2.                 SamplerState SourceCubemapSampler;
  3.                 float2 SinCosSourceCubemapRotation;
  5.                 void CopyCubemapToCubeFaceColorPS(
  6.                     FScreenVertexOutput Input,
  7.                     out float4 OutColor : SV_Target0
  8.                     )
  9.                 { 
  10.                     float2 ScaledUVs = Input.UV * 2 - 1;
  11.                     float3 CubeCoordinates = GetCubemapVector(ScaledUVs, CubeFace);
  12.                     // Rotate around Z axis
  13.                     CubeCoordinates.xy = float2(dot(CubeCoordinates.xy, float2(SinCosSourceCubemapRotation.y, -SinCosSourceCubemapRotation.x)), dot(CubeCoordinates.xy, SinCosSourceCubemapRotation));
  14.                     OutColor = TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, CubeCoordinates, 0);
  16.                     if (SkyLightCaptureParameters.x > 0)
  17.                     {
  18.                         // Assuming we're on a planet and no sky lighting is coming from below the horizon
  19.                         // This is important to avoid leaking from below since we are integrating incoming lighting and shadowing separately
  20.                         if (CubeCoordinates.z < 0 && SkyLightCaptureParameters.z >= 1)
  21.                         {
  22.                             OutColor.rgb = lerp(OutColor.rgb, LowerHemisphereColor.rgb, LowerHemisphereColor.a);
  23.                         }
  24.                     }
  26.                     OutColor.a = 1;
  27.                 }
  28. 4.  D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Engine\\Public\\ScreenRendering.h
  30.     1.      /**
  31.              * A vertex shader for rendering a textured screen element.
  32.              */
  33.             class FScreenVS : public FGlobalShader
  34.             {
  35.                 DECLARE_EXPORTED_SHADER_TYPE(FScreenVS,Global,ENGINE_API);
  36.             public:
  38.                 static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return true; }
  40.                 FScreenVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer):
  41.                     FGlobalShader(Initializer)
  42.                 {
  43.                 }
  44.                 FScreenVS() {}
  46.                 void SetParameters(FRHICommandList& RHICmdList, FRHIUniformBuffer* ViewUniformBuffer)
  47.                 {
  48.                     FGlobalShader::SetParameters<FViewUniformShaderParameters>(RHICmdList, RHICmdList.GetBoundVertexShader(), ViewUniformBuffer);
  49.                 }
  50.             };
  51.     2.  D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Engine\\Private\\ScreenRendering.cpp
  53.         1.      // Copyright Epic Games, Inc. All Rights Reserved.
  55.                 /*=============================================================================
  56.                     ScreenRendering.cpp: Screen rendering implementation.
  57.                 =============================================================================*/
  59.                 #include "ScreenRendering.h"
  61.                 /** Vertex declaration for screen-space rendering. */
  62.                 TGlobalResource<FScreenVertexDeclaration> GScreenVertexDeclaration;
  64.                 // Shader implementations.
  65.                 IMPLEMENT_SHADER_TYPE(, FScreenPS, TEXT("/Engine/Private/ScreenPixelShader.usf"), TEXT("Main"), SF_Pixel);
  66.                 IMPLEMENT_SHADER_TYPE(,FScreenPSInvertAlpha,TEXT("/Engine/Private/ScreenPixelShader.usf"),TEXT("MainInvertAlpha"),SF_Pixel);
  67.                 IMPLEMENT_SHADER_TYPE(,FScreenPSsRGBSource, TEXT("/Engine/Private/ScreenPixelShader.usf"), TEXT("MainsRGBSource"), SF_Pixel);
  68.                 IMPLEMENT_SHADER_TYPE(,FScreenPSMipLevel, TEXT("/Engine/Private/ScreenPixelShader.usf"), TEXT("MainMipLevel"), SF_Pixel);
  69.                 IMPLEMENT_SHADER_TYPE(,FScreenPSsRGBSourceMipLevel, TEXT("/Engine/Private/ScreenPixelShader.usf"), TEXT("MainsRGBSourceMipLevel"), SF_Pixel);
  70.                 IMPLEMENT_SHADER_TYPE(,FScreenVS,TEXT("/Engine/Private/ScreenVertexShader.usf"),TEXT("Main"),SF_Vertex);
  71.                 IMPLEMENT_SHADER_TYPE(,FScreenPS_OSE,TEXT("/Engine/Private/ScreenPixelShaderOES.usf"),TEXT("Main"),SF_Pixel);
  72.         2.  /Private/ScreenVertexShader.usf
  74.             1.      void Main(
  75.                         float2 InPosition : ATTRIBUTE0,
  76.                         float2 InUV       : ATTRIBUTE1,
  77.                         out FScreenVertexOutput Output
  78.                         )
  79.                     {
  80.                         DrawRectangle( float4( InPosition, 0, 1 ), InUV, Output.Position, Output.UV);
  81.                     }
  82.             2.  /Private/Common.ush
  84.                 1.      /** Used for calculating vertex positions and UVs when drawing with DrawRectangle */
  85.                         void DrawRectangle(
  86.                             in float4 InPosition,
  87.                             in float2 InTexCoord,
  88.                             out float4 OutPosition,
  89.                             out float2 OutTexCoord)
  90.                         {
  91.                             OutPosition = InPosition;
  92.                             OutPosition.xy = -1.0f + 2.0f * (DrawRectangleParameters.PosScaleBias.zw + (InPosition.xy * DrawRectangleParameters.PosScaleBias.xy)) * DrawRectangleParameters.InvTargetSizeAndTextureSize.xy;
  93.                             OutPosition.xy *= float2( 1, -1 );
  94.                             OutTexCoord.xy = (DrawRectangleParameters.UVScaleBias.zw + (InTexCoord.xy * DrawRectangleParameters.UVScaleBias.xy)) * DrawRectangleParameters.InvTargetSizeAndTextureSize.zw;
  95.                         }
  96. 5.  D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\PostProcess\\SceneFilterRendering.h
  98.     1.      /**
  99.              * Draws a quad with the given vertex positions and UVs in denormalized pixel/texel coordinates.
  100.              * The platform-dependent mapping from pixels to texels is done automatically.
  101.              * Note that the positions are affected by the current viewport.
  102.              * NOTE: DrawRectangle should be used in the vertex shader to calculate the correct position and uv for vertices.
  103.              * NOTE2: Assumes previously set PSO has PrimitiveType = PT_TriangleList
  104.              *
  105.              * X, Y                            Position in screen pixels of the top left corner of the quad
  106.              * SizeX, SizeY                    Size in screen pixels of the quad
  107.              * U, V                            Position in texels of the top left corner of the quad's UV's
  108.              * SizeU, SizeV                    Size in texels of the quad's UV's
  109.              * TargetSizeX, TargetSizeY        Size in screen pixels of the target surface
  110.              * TextureSize                  Size in texels of the source texture
  111.              * VertexShader                    The vertex shader used for rendering
  112.              * Flags                        see EDrawRectangleFlags
  113.              * InstanceCount                Number of instances of rectangle
  114.              */
  115.             extern RENDERER_API void DrawRectangle(
  116.                 FRHICommandList& RHICmdList,
  117.                 float X,
  118.                 float Y,
  119.                 float SizeX,
  120.                 float SizeY,
  121.                 float U,
  122.                 float V,
  123.                 float SizeU,
  124.                 float SizeV,
  125.                 FIntPoint TargetSize,
  126.                 FIntPoint TextureSize,
  127.                 const TShaderRef<FShader>& VertexShader,
  128.                 EDrawRectangleFlags Flags = EDRF_Default,
  129.                 uint32 InstanceCount = 1
  130.                 );
  132.             /** Uniform buffer for computing the vertex positional and UV adjustments in the vertex shader. */
  133.             BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT( FDrawRectangleParameters, RENDERER_API)
  134.                 SHADER_PARAMETER( FVector4, PosScaleBias )
  135.                 SHADER_PARAMETER( FVector4, UVScaleBias )
  136.                 SHADER_PARAMETER( FVector4, InvTargetSizeAndTextureSize )
  137.             END_GLOBAL_SHADER_PARAMETER_STRUCT()
  138.     2.  D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\PostProcess\\SceneFilterRendering.cpp
  140.         1.      void DrawRectangle(
  141.                     FRHICommandList& RHICmdList,
  142.                     float X,
  143.                     float Y,
  144.                     float SizeX,
  145.                     float SizeY,
  146.                     float U,
  147.                     float V,
  148.                     float SizeU,
  149.                     float SizeV,
  150.                     FIntPoint TargetSize,
  151.                     FIntPoint TextureSize,
  152.                     const TShaderRef<FShader>& VertexShader,
  153.                     EDrawRectangleFlags Flags,
  154.                     uint32 InstanceCount
  155.                 )
  156.                 {
  157.                     InternalDrawRectangle(RHICmdList, X, Y, SizeX, SizeY, U, V, SizeU, SizeV, TargetSize, TextureSize, VertexShader, Flags, InstanceCount);
  158.                 }
  160.                 template <typename TRHICommandList>
  161.                 static inline void InternalDrawRectangle(
  162.                     TRHICommandList& RHICmdList,
  163.                     float X,
  164.                     float Y,
  165.                     float SizeX,
  166.                     float SizeY,
  167.                     float U,
  168.                     float V,
  169.                     float SizeU,
  170.                     float SizeV,
  171.                     FIntPoint TargetSize,
  172.                     FIntPoint TextureSize,
  173.                     const TShaderRef<FShader>& VertexShader,
  174.                     EDrawRectangleFlags Flags,
  175.                     uint32 InstanceCount
  176.                     )
  177.                 {
  178.                     float ClipSpaceQuadZ = 0.0f;
  180.                     DoDrawRectangleFlagOverride(Flags);
  182.                     // triangle if extending to left and top of the given rectangle, if it's not left top of the viewport it can cause artifacts
  183.                     if(X > 0.0f || Y > 0.0f)
  184.                     {
  185.                         // don't use triangle optimization
  186.                         Flags = EDRF_Default;
  187.                     }
  189.                     // Set up vertex uniform parameters for scaling and biasing the rectangle.
  190.                     // Note: Use DrawRectangle in the vertex shader to calculate the correct vertex position and uv.
  192.                     FDrawRectangleParameters Parameters;
  193.                     Parameters.PosScaleBias = FVector4(SizeX, SizeY, X, Y);
  194.                     Parameters.UVScaleBias = FVector4(SizeU, SizeV, U, V);
  196.                     Parameters.InvTargetSizeAndTextureSize = FVector4(
  197.                         1.0f / TargetSize.X, 1.0f / TargetSize.Y,
  198.                         1.0f / TextureSize.X, 1.0f / TextureSize.Y);
  200.                     SetUniformBufferParameterImmediate(RHICmdList, VertexShader.GetVertexShader(), VertexShader->GetUniformBufferParameter<FDrawRectangleParameters>(), Parameters);
  202.                     if(Flags == EDRF_UseTesselatedIndexBuffer)
  203.                     {
  204.                         // no vertex buffer needed as we compute it in VS
  205.                         RHICmdList.SetStreamSource(0, NULL, 0);
  207.                         RHICmdList.DrawIndexedPrimitive(
  208.                             GTesselatedScreenRectangleIndexBuffer.IndexBufferRHI,
  209.                             /*BaseVertexIndex=*/ 0,
  210.                             /*MinIndex=*/ 0,
  211.                             /*NumVertices=*/ GTesselatedScreenRectangleIndexBuffer.NumVertices(),
  212.                             /*StartIndex=*/ 0,
  213.                             /*NumPrimitives=*/ GTesselatedScreenRectangleIndexBuffer.NumPrimitives(),
  214.                             /*NumInstances=*/ InstanceCount
  215.                             );
  216.                     }
  217.                     else
  218.                     {
  219.                         if (Flags == EDRF_UseTriangleOptimization)
  220.                         {
  221.                             FPixelShaderUtils::DrawFullscreenTriangle(RHICmdList, InstanceCount);
  222.                         }
  223.                         else
  224.                         {
  225.                             FPixelShaderUtils::DrawFullscreenQuad(RHICmdList, InstanceCount);
  226.                         }
  227.                     }
  228.                 }
  229.         2.  D:\\UnrealEngine426\\Engine\\Source\\Runtime\\RenderCore\\Private\\PixelShaderUtils.cpp
  231.             1.      // static
  232.                     void FPixelShaderUtils::DrawFullscreenQuad(FRHICommandList& RHICmdList, uint32 InstanceCount)
  233.                     {
  234.                         RHICmdList.SetStreamSource(0, GScreenRectangleVertexBuffer.VertexBufferRHI, 0);
  236.                         RHICmdList.DrawIndexedPrimitive(
  237.                             GScreenRectangleIndexBuffer.IndexBufferRHI,
  238.                             /*BaseVertexIndex=*/ 0,
  239.                             /*MinIndex=*/ 0,
  240.                             /*NumVertices=*/ 4,
  241.                             /*StartIndex=*/ 0,
  242.                             /*NumPrimitives=*/ 2,
  243.                             /*NumInstances=*/ InstanceCount);
  244.                     }
  245. 6.  ComputeAverageBrightness()
  247.     1.      void ComputeAverageBrightness(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, int32 CubmapSize, float& OutAverageBrightness)
  248.             {
  249.                 SCOPED_DRAW_EVENT(RHICmdList, ComputeAverageBrightness);
  251.                 const int32 EffectiveTopMipSize = CubmapSize;
  252.                 const int32 NumMips = FMath::CeilLogTwo(EffectiveTopMipSize) + 1;
  254.                 // necessary to resolve the clears which touched all the mips.  scene rendering only resolves mip 0.
  255.                 FullyResolveReflectionScratchCubes(RHICmdList);    
  257.                 FSceneRenderTargetItem& DownSampledCube = FSceneRenderTargets::Get(RHICmdList).ReflectionColorScratchCubemap[0]->GetRenderTargetItem();
  258.                 CreateCubeMips( RHICmdList, FeatureLevel, NumMips, DownSampledCube );
  260.                 OutAverageBrightness = ComputeSingleAverageBrightnessFromCubemap(RHICmdList, FeatureLevel, CubmapSize, DownSampledCube);
  261.             }
  262.     2.      void CreateCubeMips( FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, int32 NumMips, FSceneRenderTargetItem& Cubemap )
  263.             {    
  264.                 SCOPED_DRAW_EVENT(RHICmdList, CreateCubeMips);
  266.                 FRHITexture* CubeRef = Cubemap.TargetableTexture.GetReference();
  268.                 auto* ShaderMap = GetGlobalShaderMap(FeatureLevel);
  270.                 TArray<TPair<FRHITextureSRVCreateInfo, TRefCountPtr<FRHIShaderResourceView>>> SRVs;
  271.                 SRVs.Empty(NumMips);
  273.                 for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
  274.                 {
  275.                     FRHITextureSRVCreateInfo SRVDesc;
  276.                     SRVDesc.MipLevel = MipIndex;
  277.                     SRVs.Emplace(SRVDesc, RHICreateShaderResourceView(Cubemap.ShaderResourceTexture, SRVDesc));
  278.                 }
  280.                 FGraphicsPipelineStateInitializer GraphicsPSOInit;
  281.                 GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
  282.                 GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
  283.                 GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
  285.                 // Downsample all the mips, each one reads from the mip above it
  286.                 for (int32 MipIndex = 1; MipIndex < NumMips; MipIndex++)
  287.                 {
  288.                     // For the first iteration, we don't know what the previous state
  289.                     // of the source mip was, but we *do* for all the other iterations...
  290.                     ERHIAccess Previous = MipIndex == 1
  291.                         ? ERHIAccess::Unknown
  292.                         : ERHIAccess::RTV;
  294.                     FRHITransitionInfo Transitions[] =
  295.                     {
  296.                         // Make the source mip readable (SRVGraphics)
  297.                         FRHITransitionInfo(CubeRef, Previous, ERHIAccess::SRVGraphics, EResourceTransitionFlags::None, uint32(MipIndex - 1)),
  299.                         // Make the destination mip writable (RTV)
  300.                         FRHITransitionInfo(CubeRef, ERHIAccess::Unknown, ERHIAccess::RTV, EResourceTransitionFlags::None, uint32(MipIndex))
  301.                     };
  302.                     RHICmdList.Transition(Transitions);
  304.                     const int32 MipSize = 1 << (NumMips - MipIndex - 1);
  305.                     SCOPED_DRAW_EVENT(RHICmdList, CreateCubeMipsPerFace);
  306.                     for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
  307.                     {
  308.                         FRHIRenderPassInfo RPInfo(Cubemap.TargetableTexture, ERenderTargetActions::DontLoad_Store, nullptr, MipIndex, CubeFace);
  309.                         RHICmdList.BeginRenderPass(RPInfo, TEXT("CreateCubeMips"));
  310.                         RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  312.                         const FIntRect ViewRect(0, 0, MipSize, MipSize);
  313.                         RHICmdList.SetViewport(0.0f, 0.0f, 0.0f, (float)MipSize, (float)MipSize, 1.0f);
  316.                         TShaderMapRef<FScreenVS> VertexShader(ShaderMap);
  317.                         TShaderMapRef<FCubeFilterPS> PixelShader(ShaderMap);
  319.                         GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  320.                         GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  321.                         GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  322.                         GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  324.                         SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  326.                         {
  327.                             FRHIPixelShader* ShaderRHI = PixelShader.GetPixelShader();
  329.                             SetShaderValue(RHICmdList, ShaderRHI, PixelShader->CubeFace, CubeFace);
  330.                             SetShaderValue(RHICmdList, ShaderRHI, PixelShader->MipIndex, MipIndex);
  332.                             SetShaderValue(RHICmdList, ShaderRHI, PixelShader->NumMips, NumMips);
  334.                             check(SRVs.IsValidIndex(MipIndex - 1) && SRVs[MipIndex - 1].Key.MipLevel == MipIndex - 1);
  335.                             SetSRVParameter(RHICmdList, ShaderRHI, PixelShader->SourceCubemapTexture, SRVs[MipIndex - 1].Value);
  336.                             SetSamplerParameter(RHICmdList, ShaderRHI, PixelShader->SourceCubemapSampler, TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI());
  337.                         }
  339.                         DrawRectangle(
  340.                             RHICmdList,
  341.                             ViewRect.Min.X, ViewRect.Min.Y,
  342.                             ViewRect.Width(), ViewRect.Height(),
  343.                             ViewRect.Min.X, ViewRect.Min.Y,
  344.                             ViewRect.Width(), ViewRect.Height(),
  345.                             FIntPoint(ViewRect.Width(), ViewRect.Height()),
  346.                             FIntPoint(MipSize, MipSize),
  347.                             VertexShader);
  349.                         RHICmdList.EndRenderPass();
  350.                     }
  351.                 }
  353.                 RHICmdList.Transition(FRHITransitionInfo(CubeRef, ERHIAccess::Unknown, ERHIAccess::SRVMask));
  355.                 SRVs.Empty();
  356.             }
  358.         1.      void DownsamplePS(
  359.                     FScreenVertexOutput Input,
  360.                     out float4 OutColor : SV_Target0
  361.                     )
  362.                 { 
  363.                     float2 ScaledUVs = Input.UV * 2 - 1;
  364.                     const int SelectedCubeFace = CubeFace;
  365.                 #endif // USE_COMPUTE
  366.                     float3 CubeCoordinates = GetCubemapVector(ScaledUVs, SelectedCubeFace);
  368.                     uint MipSize = 1 << ( NumMips - MipIndex - 1 );
  370.                     float3 TangentZ = normalize( CubeCoordinates );
  371.                     float3 TangentX = normalize( cross( GetCubemapVector( ScaledUVs + float2(0,1), SelectedCubeFace), TangentZ ) );
  372.                     float3 TangentY = cross( TangentZ, TangentX );
  374.                     const float SampleOffset = 2.0 * 2 / MipSize;
  376.                     float2 Offsets[] =
  377.                     {
  378.                         float2(-1, -1) * 0.7,
  379.                         float2( 1, -1) * 0.7,
  380.                         float2(-1,  1) * 0.7,
  381.                         float2( 1,  1) * 0.7,
  383.                         float2( 0, -1),
  384.                         float2(-1,  0),
  385.                         float2( 1,  0),
  386.                         float2( 0,  1),
  387.                     };
  389.                     OutColor = SourceCubemapTexture.SampleLevel(SourceCubemapSampler, CubeCoordinates, 0 );
  391.                     UNROLL
  392.                     for( uint i = 0; i < 8; i++ )
  393.                     {
  394.                         float Weight = 0.375;
  396.                         float3 SampleDir = CubeCoordinates;
  397.                         SampleDir += TangentX * ( Offsets[i].x * SampleOffset );
  398.                         SampleDir += TangentY * ( Offsets[i].y * SampleOffset );
  399.                         OutColor += SourceCubemapTexture.SampleLevel(SourceCubemapSampler, SampleDir, 0 ) * Weight;
  400.                     }
  402.                     OutColor *= rcp( 1.0 + 1.0 + 2.0 );
  404.                 #ifdef USE_COMPUTE
  405.                     OutTextureMipColor[uint3(FaceCoord, SelectedCubeFace)] = OutColor;
  406.                 #endif
  407.                 }
  408.     3.      /** Computes the average brightness of the given reflection capture and stores it in the scene. */
  409.             float ComputeSingleAverageBrightnessFromCubemap(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, int32 TargetSize, FSceneRenderTargetItem& Cubemap)
  410.             {
  411.                 SCOPED_DRAW_EVENT(RHICmdList, ComputeSingleAverageBrightnessFromCubemap);
  413.                 TRefCountPtr<IPooledRenderTarget> ReflectionBrightnessTarget;
  414.                 FPooledRenderTargetDesc Desc(FPooledRenderTargetDesc::Create2DDesc(FIntPoint(1, 1), PF_FloatRGBA, FClearValueBinding::None, TexCreate_None, TexCreate_RenderTargetable, false));
  415.                 GRenderTargetPool.FindFreeElement(RHICmdList, Desc, ReflectionBrightnessTarget, TEXT("ReflectionBrightness"));
  417.                 FTextureRHIRef& BrightnessTarget = ReflectionBrightnessTarget->GetRenderTargetItem().TargetableTexture;
  419.                 FRHIRenderPassInfo RPInfo(BrightnessTarget, ERenderTargetActions::Load_Store);
  420.                 TransitionRenderPassTargets(RHICmdList, RPInfo);
  421.                 RHICmdList.BeginRenderPass(RPInfo, TEXT("ReflectionBrightness"));
  422.                 {
  423.                     FGraphicsPipelineStateInitializer GraphicsPSOInit;
  424.                     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  425.                     GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
  426.                     GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
  427.                     GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
  429.                     auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
  430.                     TShaderMapRef<FPostProcessVS> VertexShader(ShaderMap);
  431.                     TShaderMapRef<FComputeBrightnessPS> PixelShader(ShaderMap);
  433.                     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  434.                     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  435.                     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  436.                     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  438.                     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  440.                     PixelShader->SetParameters(RHICmdList, TargetSize, Cubemap);
  442.                     DrawRectangle(
  443.                         RHICmdList,
  444.                         0, 0,
  445.                         1, 1,
  446.                         0, 0,
  447.                         1, 1,
  448.                         FIntPoint(1, 1),
  449.                         FIntPoint(1, 1),
  450.                         VertexShader);
  451.                 }
  452.                 RHICmdList.EndRenderPass();
  453.                 RHICmdList.CopyToResolveTarget(BrightnessTarget, BrightnessTarget, FResolveParams());
  455.                 FSceneRenderTargetItem& EffectiveRT = ReflectionBrightnessTarget->GetRenderTargetItem();
  456.                 check(EffectiveRT.ShaderResourceTexture->GetFormat() == PF_FloatRGBA);
  458.                 TArray<FFloat16Color> SurfaceData;
  459.                 RHICmdList.ReadSurfaceFloatData(EffectiveRT.ShaderResourceTexture, FIntRect(0, 0, 1, 1), SurfaceData, CubeFace_PosX, 0, 0);
  461.                 // Shader outputs luminance to R
  462.                 float AverageBrightness = SurfaceData[0].R.GetFloat();
  463.                 return AverageBrightness;
  464.             }
  466.         1.      int NumCaptureArrayMips;
  468.                 /** Cube map array of reflection captures. */
  469.                 TextureCube ReflectionEnvironmentColorTexture;
  470.                 SamplerState ReflectionEnvironmentColorSampler;
  472.                 #if COMPUTEBRIGHTNESS_PIXELSHADER
  474.                 void ComputeBrightnessMain(
  475.                     in float4 UVAndScreenPos : TEXCOORD0, 
  476.                     out float4 OutColor : SV_Target0
  477.                     )
  478.                 { 
  479.                     // Sample the 6 1x1 cube faces and average
  480.                     float3 AverageColor = TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(1, 0, 0), NumCaptureArrayMips - 1).rgb;
  481.                     AverageColor += TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(-1, 0, 0), NumCaptureArrayMips - 1).rgb;
  482.                     AverageColor += TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(0, 1, 0), NumCaptureArrayMips - 1).rgb;
  483.                     AverageColor += TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(0, -1, 0), NumCaptureArrayMips - 1).rgb;
  484.                     AverageColor += TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(0, 0, 1), NumCaptureArrayMips - 1).rgb;
  485.                     AverageColor += TextureCubeSampleLevel(ReflectionEnvironmentColorTexture, ReflectionEnvironmentColorSampler, float3(0, 0, -1), NumCaptureArrayMips - 1).rgb;
  487.                     OutColor = dot(AverageColor / 6, .3333f); 
  488.                 }
  490.                 #endif
  491. 7.  FilterReflectionEnvironment()
  493.     1.      /** Generates mips for glossiness and filters the cubemap for a given reflection. */
  494.             void FilterReflectionEnvironment(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, int32 CubmapSize, FSHVectorRGB3* OutIrradianceEnvironmentMap)
  495.             {
  496.                 SCOPED_DRAW_EVENT(RHICmdList, FilterReflectionEnvironment);
  498.                 const int32 EffectiveTopMipSize = CubmapSize;
  499.                 const int32 NumMips = FMath::CeilLogTwo(EffectiveTopMipSize) + 1;
  501.                 FSceneRenderTargetItem& EffectiveColorRT = FSceneRenderTargets::Get(RHICmdList).ReflectionColorScratchCubemap[0]->GetRenderTargetItem();
  503.                 FGraphicsPipelineStateInitializer GraphicsPSOInit;
  504.                 GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
  505.                 GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
  506.                 GraphicsPSOInit.BlendState = TStaticBlendState<CW_RGBA, BO_Add, BF_Zero, BF_DestAlpha, BO_Add, BF_Zero, BF_One>::GetRHI();
  508.                 RHICmdList.Transition(FRHITransitionInfo(EffectiveColorRT.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  510.                 // Premultiply alpha in-place using alpha blending
  511.                 for (uint32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
  512.                 {
  513.                     FRHIRenderPassInfo RPInfo(EffectiveColorRT.TargetableTexture, ERenderTargetActions::Load_Store, nullptr, 0, CubeFace);
  514.                     RHICmdList.BeginRenderPass(RPInfo, TEXT("FilterReflectionEnvironmentRP"));
  515.                     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  517.                     const FIntPoint SourceDimensions(CubmapSize, CubmapSize);
  518.                     const FIntRect ViewRect(0, 0, EffectiveTopMipSize, EffectiveTopMipSize);
  519.                     RHICmdList.SetViewport(0, 0, 0.0f, EffectiveTopMipSize, EffectiveTopMipSize, 1.0f);
  521.                     TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
  522.                     TShaderMapRef<FOneColorPS> PixelShader(GetGlobalShaderMap(FeatureLevel));
  524.                     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  525.                     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  526.                     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  527.                     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  529.                     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  531.                     FLinearColor UnusedColors[1] = { FLinearColor::Black };
  532.                     PixelShader->SetColors(RHICmdList, UnusedColors, UE_ARRAY_COUNT(UnusedColors));
  534.                     DrawRectangle(
  535.                         RHICmdList,
  536.                         ViewRect.Min.X, ViewRect.Min.Y, 
  537.                         ViewRect.Width(), ViewRect.Height(),
  538.                         0, 0, 
  539.                         SourceDimensions.X, SourceDimensions.Y,
  540.                         FIntPoint(ViewRect.Width(), ViewRect.Height()),
  541.                         SourceDimensions,
  542.                         VertexShader);
  544.                     RHICmdList.EndRenderPass();
  545.                 }
  547.                 RHICmdList.Transition(FRHITransitionInfo(EffectiveColorRT.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::SRVMask));
  549.                 auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
  550.                 FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  552.                 FSceneRenderTargetItem& DownSampledCube = FSceneRenderTargets::Get(RHICmdList).ReflectionColorScratchCubemap[0]->GetRenderTargetItem();
  553.                 FSceneRenderTargetItem& FilteredCube = FSceneRenderTargets::Get(RHICmdList).ReflectionColorScratchCubemap[1]->GetRenderTargetItem();
  555.                 CreateCubeMips( RHICmdList, FeatureLevel, NumMips, DownSampledCube );
  557.                 if (OutIrradianceEnvironmentMap)
  558.                 {
  559.                     SCOPED_DRAW_EVENT(RHICmdList, ComputeDiffuseIrradiance);
  561.                     const int32 NumDiffuseMips = FMath::CeilLogTwo( GDiffuseIrradianceCubemapSize ) + 1;
  562.                     const int32 DiffuseConvolutionSourceMip = FMath::Max(0, NumMips - NumDiffuseMips);
  564.                     ComputeDiffuseIrradiance(RHICmdList, FeatureLevel, DownSampledCube.ShaderResourceTexture, DiffuseConvolutionSourceMip, OutIrradianceEnvironmentMap);
  565.                 }
  567.                 FilterCubeMap(RHICmdList, FeatureLevel, NumMips, DownSampledCube, FilteredCube);
  568.                 RHICmdList.CopyToResolveTarget(FilteredCube.TargetableTexture, FilteredCube.ShaderResourceTexture, FResolveParams());
  569.             }
  571.         1.  ComputeDiffuseIrradiance() D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\ReflectionEnvironmentDiffuseIrradiance.cpp
  573.             1.      void ComputeDiffuseIrradiance(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, FTextureRHIRef LightingSource, int32 LightingSourceMipIndex, FSHVectorRGB3* OutIrradianceEnvironmentMap)
  574.                     {
  575.                         auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
  576.                         FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  578.                         FGraphicsPipelineStateInitializer GraphicsPSOInit;
  579.                         GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
  580.                         GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
  581.                         GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
  583.                         for (int32 CoefficientIndex = 0; CoefficientIndex < FSHVector3::MaxSHBasis; CoefficientIndex++)
  584.                         {
  585.                             // Copy the starting mip from the lighting texture, apply texel area weighting and appropriate SH coefficient
  586.                             {
  587.                                 const int32 MipIndex = 0;
  588.                                 const int32 MipSize = GDiffuseIrradianceCubemapSize;
  589.                                 FSceneRenderTargetItem& EffectiveRT = GetEffectiveDiffuseIrradianceRenderTarget(SceneContext, MipIndex);            
  591.                                 RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  593.                                 for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
  594.                                 {
  595.                                     FRHIRenderPassInfo RPInfo(EffectiveRT.TargetableTexture, ERenderTargetActions::DontLoad_Store, nullptr, 0, CubeFace);
  596.                                     RHICmdList.BeginRenderPass(RPInfo, TEXT("CopyDiffuseIrradianceRP"));
  597.                                     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  599.                                     const FIntRect ViewRect(0, 0, MipSize, MipSize);
  600.                                     RHICmdList.SetViewport(0.0f, 0.0f, 0.0f, (float)MipSize, (float)MipSize, 1.0f);
  601.                                     TShaderMapRef<FCopyDiffuseIrradiancePS> PixelShader(ShaderMap);
  603.                                     TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
  605.                                     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  606.                                     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  607.                                     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  608.                                     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  610.                                     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  612.                                     PixelShader->SetParameters(RHICmdList, CubeFace, LightingSourceMipIndex, CoefficientIndex, MipSize, LightingSource);
  614.                                     DrawRectangle(
  615.                                         RHICmdList,
  616.                                         ViewRect.Min.X, ViewRect.Min.Y,
  617.                                         ViewRect.Width(), ViewRect.Height(),
  618.                                         ViewRect.Min.X, ViewRect.Min.Y,
  619.                                         ViewRect.Width(), ViewRect.Height(),
  620.                                         FIntPoint(ViewRect.Width(), ViewRect.Height()),
  621.                                         FIntPoint(MipSize, MipSize),
  622.                                         VertexShader);
  624.                                     RHICmdList.EndRenderPass();
  625.                                 }
  627.                                 RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::RTV, ERHIAccess::SRVGraphics));
  628.                             }
  630.                             const int32 NumMips = FMath::CeilLogTwo(GDiffuseIrradianceCubemapSize) + 1;
  632.                             {
  633.                                 // Accumulate all the texel values through downsampling to 1x1 mip
  634.                                 for (int32 MipIndex = 1; MipIndex < NumMips; MipIndex++)
  635.                                 {
  636.                                     const int32 SourceMipIndex = FMath::Max(MipIndex - 1, 0);
  637.                                     const int32 MipSize = 1 << (NumMips - MipIndex - 1);
  639.                                     FSceneRenderTargetItem& EffectiveRT = GetEffectiveDiffuseIrradianceRenderTarget(SceneContext, MipIndex);
  640.                                     FSceneRenderTargetItem& EffectiveSource = GetEffectiveDiffuseIrradianceSourceTexture(SceneContext, MipIndex);
  641.                                     check(EffectiveRT.TargetableTexture != EffectiveSource.ShaderResourceTexture);
  643.                                     RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  645.                                     for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
  646.                                     {
  647.                                         FRHIRenderPassInfo RPInfo(EffectiveRT.TargetableTexture, ERenderTargetActions::Load_Store, nullptr, MipIndex, CubeFace);
  648.                                         RHICmdList.BeginRenderPass(RPInfo, TEXT("AccumulateDiffuseIrradianceRP"));
  649.                                         RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  651.                                         const FIntRect ViewRect(0, 0, MipSize, MipSize);
  652.                                         RHICmdList.SetViewport(0.0f, 0.0f, 0.0f, (float)MipSize, (float)MipSize, 1.0f);
  653.                                         TShaderMapRef<FAccumulateDiffuseIrradiancePS> PixelShader(ShaderMap);
  655.                                         TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
  657.                                         GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  658.                                         GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  659.                                         GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  660.                                         GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  662.                                         SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  664.                                         PixelShader->SetParameters(RHICmdList, CubeFace, NumMips, SourceMipIndex, CoefficientIndex, EffectiveSource.ShaderResourceTexture);
  666.                                         DrawRectangle(
  667.                                             RHICmdList,
  668.                                             ViewRect.Min.X, ViewRect.Min.Y,
  669.                                             ViewRect.Width(), ViewRect.Height(),
  670.                                             ViewRect.Min.X, ViewRect.Min.Y,
  671.                                             ViewRect.Width(), ViewRect.Height(),
  672.                                             FIntPoint(ViewRect.Width(), ViewRect.Height()),
  673.                                             FIntPoint(MipSize, MipSize),
  674.                                             VertexShader);
  676.                                         RHICmdList.EndRenderPass();
  677.                                     }                
  679.                                     RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::RTV, ERHIAccess::SRVGraphics));
  680.                                 }
  681.                             }
  683.                             {
  684.                                 // Gather the cubemap face results and normalize, copy this coefficient to FSceneRenderTargets::Get(RHICmdList).SkySHIrradianceMap
  685.                                 FSceneRenderTargetItem& EffectiveRT = FSceneRenderTargets::Get(RHICmdList).SkySHIrradianceMap->GetRenderTargetItem();
  687.                                 //load/store actions so we don't lose results as we render one pixel at a time on tile renderers.
  688.                                 RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  689.                                 FRHIRenderPassInfo RPInfo(EffectiveRT.TargetableTexture, ERenderTargetActions::Load_Store, nullptr);
  690.                                 RHICmdList.BeginRenderPass(RPInfo, TEXT("GatherCoeffRP"));
  691.                                 RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  693.                                 const FIntRect ViewRect(CoefficientIndex, 0, CoefficientIndex + 1, 1);
  694.                                 RHICmdList.SetViewport(0.0f, 0.0f, 0.0f, (float)FSHVector3::MaxSHBasis, 1.0f, 1.0f);
  696.                                 TShaderMapRef<FScreenVS> VertexShader(ShaderMap);
  697.                                 TShaderMapRef<FAccumulateCubeFacesPS> PixelShader(ShaderMap);
  699.                                 GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  700.                                 GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  701.                                 GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  702.                                 GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  704.                                 SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  706.                                 const int32 SourceMipIndex = NumMips - 1;
  707.                                 const int32 MipSize = 1;
  708.                                 FSceneRenderTargetItem& EffectiveSource = GetEffectiveDiffuseIrradianceRenderTarget(SceneContext, SourceMipIndex);
  709.                                 PixelShader->SetParameters(RHICmdList, SourceMipIndex, EffectiveSource.ShaderResourceTexture);
  711.                                 DrawRectangle( 
  712.                                     RHICmdList,
  713.                                     ViewRect.Min.X, ViewRect.Min.Y, 
  714.                                     ViewRect.Width(), ViewRect.Height(),
  715.                                     0, 0, 
  716.                                     MipSize, MipSize,
  717.                                     FIntPoint(FSHVector3::MaxSHBasis, 1),
  718.                                     FIntPoint(MipSize, MipSize),
  719.                                     VertexShader);
  721.                                 RHICmdList.EndRenderPass();
  722.                                 RHICmdList.Transition(FRHITransitionInfo(EffectiveRT.TargetableTexture, ERHIAccess::RTV, ERHIAccess::SRVGraphics));
  723.                             }
  724.                         }
  726.                         {
  727.                             // Read back the completed SH environment map
  728.                             FSceneRenderTargetItem& EffectiveRT = FSceneRenderTargets::Get(RHICmdList).SkySHIrradianceMap->GetRenderTargetItem();
  729.                             check(EffectiveRT.ShaderResourceTexture->GetFormat() == PF_FloatRGBA);
  731.                             TArray<FFloat16Color> SurfaceData;
  732.                             RHICmdList.ReadSurfaceFloatData(EffectiveRT.ShaderResourceTexture, FIntRect(0, 0, FSHVector3::MaxSHBasis, 1), SurfaceData, CubeFace_PosX, 0, 0);
  733.                             check(SurfaceData.Num() == FSHVector3::MaxSHBasis);
  735.                             for (int32 CoefficientIndex = 0; CoefficientIndex < FSHVector3::MaxSHBasis; CoefficientIndex++)
  736.                             {
  737.                                 const FLinearColor CoefficientValue(SurfaceData[CoefficientIndex]);
  738.                                 OutIrradianceEnvironmentMap->R.V[CoefficientIndex] = CoefficientValue.R;
  739.                                 OutIrradianceEnvironmentMap->G.V[CoefficientIndex] = CoefficientValue.G;
  740.                                 OutIrradianceEnvironmentMap->B.V[CoefficientIndex] = CoefficientValue.B;
  741.                             }
  742.                         }
  743.                     }
  745.                 D:\\UnrealEngine426\\Engine\\Shaders\\Private\\ReflectionEnvironmentShaders.usf
  747.                 1.      float4 CoefficientMask0;
  748.                         float4 CoefficientMask1;
  749.                         float CoefficientMask2;
  750.                         int NumSamples;
  752.                         void DiffuseIrradianceCopyPS(
  753.                             FScreenVertexOutput Input,
  754.                             out float4 OutColor : SV_Target0
  755.                             )
  756.                         { 
  757.                             float2 ScaledUVs = Input.UV * 2 - 1;
  758.                             float3 CubeCoordinates = normalize(GetCubemapVector(ScaledUVs, CubeFace));
  760.                             float SquaredUVs = 1 + dot(ScaledUVs, ScaledUVs);
  761.                             // Dividing by NumSamples here to keep the sum in the range of fp16, once we get down to the 1x1 mip
  762.                             float TexelWeight = 4 / (sqrt(SquaredUVs) * SquaredUVs);
  764.                             FThreeBandSHVector SHCoefficients = SHBasisFunction3(CubeCoordinates);
  765.                             float CurrentSHCoefficient = dot(SHCoefficients.V0, CoefficientMask0) + dot(SHCoefficients.V1, CoefficientMask1) + SHCoefficients.V2 * CoefficientMask2;
  766.                             float3 TexelLighting = SampleCubemap(CubeCoordinates).rgb;
  768.                             OutColor = float4(TexelLighting * CurrentSHCoefficient * TexelWeight, TexelWeight);
  769.                         }
  771.                         float4 Sample01;
  772.                         float4 Sample23;
  774.                         void DiffuseIrradianceAccumulatePS(
  775.                             FScreenVertexOutput Input,
  776.                             out float4 OutColor : SV_Target0
  777.                             )
  778.                         { 
  779.                             float4 AccumulatedValue = 0;
  781.                             {
  782.                                 float2 ScaledUVs = saturate(Input.UV + Sample01.xy) * 2 - 1;
  783.                                 float3 CubeCoordinates = GetCubemapVector(ScaledUVs, CubeFace);
  784.                                 AccumulatedValue += SampleCubemap(CubeCoordinates);
  785.                             }
  787.                             {
  788.                                 float2 ScaledUVs = saturate(Input.UV + Sample01.zw) * 2 - 1;
  789.                                 float3 CubeCoordinates = GetCubemapVector(ScaledUVs, CubeFace);
  790.                                 AccumulatedValue += SampleCubemap(CubeCoordinates);
  791.                             }
  793.                             {
  794.                                 float2 ScaledUVs = saturate(Input.UV + Sample23.xy) * 2 - 1;
  795.                                 float3 CubeCoordinates = GetCubemapVector(ScaledUVs, CubeFace);
  796.                                 AccumulatedValue += SampleCubemap(CubeCoordinates);
  797.                             }
  799.                             {
  800.                                 float2 ScaledUVs = saturate(Input.UV + Sample23.zw) * 2 - 1;
  801.                                 float3 CubeCoordinates = GetCubemapVector(ScaledUVs, CubeFace);
  802.                                 AccumulatedValue += SampleCubemap(CubeCoordinates);
  803.                             }
  805.                             OutColor = float4(AccumulatedValue.rgb / 4.0f, AccumulatedValue.a / 4.0f);
  806.                         }
  808.                         void AccumulateCubeFacesPS(
  809.                             FScreenVertexOutput Input,
  810.                             out float4 OutColor : SV_Target0
  811.                             )
  812.                         {
  813.                             float4 AccumulatedValue; 
  814.                             AccumulatedValue  = TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(1, 0, 0), SourceMipIndex);
  815.                             AccumulatedValue += TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(-1, 0, 0), SourceMipIndex);
  816.                             AccumulatedValue += TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(0, 1, 0), SourceMipIndex);
  817.                             AccumulatedValue += TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(0, -1, 0), SourceMipIndex);
  818.                             AccumulatedValue += TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(0, 0, 1), SourceMipIndex);
  819.                             AccumulatedValue += TextureCubeSampleLevel(SourceCubemapTexture, SourceCubemapSampler, float3(0, 0, -1), SourceMipIndex);
  820.                             OutColor = float4(4 * PI * AccumulatedValue.rgb / ( max(AccumulatedValue.a, .00001f)), 0);    
  821.                         }
  823.                     D:\\UnrealEngine426\\Engine\\Shaders\\Private\\SHCommon.ush
  824.                 2.      FThreeBandSHVector SHBasisFunction3(half3 InputVector)
  825.                         {
  826.                             FThreeBandSHVector Result;
  827.                             // These are derived from simplifying SHBasisFunction in C++
  828.                             Result.V0.x = 0.282095f; 
  829.                             Result.V0.y = -0.488603f * InputVector.y;
  830.                             Result.V0.z = 0.488603f * InputVector.z;
  831.                             Result.V0.w = -0.488603f * InputVector.x;
  833.                             half3 VectorSquared = InputVector * InputVector;
  834.                             Result.V1.x = 1.092548f * InputVector.x * InputVector.y;
  835.                             Result.V1.y = -1.092548f * InputVector.y * InputVector.z;
  836.                             Result.V1.z = 0.315392f * (3.0f * VectorSquared.z - 1.0f);
  837.                             Result.V1.w = -1.092548f * InputVector.x * InputVector.z;
  838.                             Result.V2 = 0.546274f * (VectorSquared.x - VectorSquared.y);
  840.                             return Result;
  841.                         }
  842.         2.  FilterCubeMap()
  844.             1.      void FilterCubeMap(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel, int32 NumMips, 
  845.                         FSceneRenderTargetItem& DownSampledCube, FSceneRenderTargetItem& FilteredCube)
  846.                     {
  847.                         SCOPED_DRAW_EVENT(RHICmdList, FilterCubeMap);
  848.                         auto ShaderMap = GetGlobalShaderMap(FeatureLevel);
  850.                         FGraphicsPipelineStateInitializer GraphicsPSOInit;
  851.                         GraphicsPSOInit.RasterizerState = TStaticRasterizerState<FM_Solid, CM_None>::GetRHI();
  852.                         GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always>::GetRHI();
  853.                         GraphicsPSOInit.BlendState = TStaticBlendState<>::GetRHI();
  855.                         RHICmdList.Transition(FRHITransitionInfo(FilteredCube.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  857.                         // Filter all the mips
  858.                         for (int32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
  859.                         {
  860.                             const int32 MipSize = 1 << (NumMips - MipIndex - 1);
  862.                             for (int32 CubeFace = 0; CubeFace < CubeFace_MAX; CubeFace++)
  863.                             {
  864.                                 FRHIRenderPassInfo RPInfo(FilteredCube.TargetableTexture, ERenderTargetActions::DontLoad_Store, nullptr, MipIndex, CubeFace);
  865.                                 RHICmdList.Transition(FRHITransitionInfo(FilteredCube.TargetableTexture, ERHIAccess::Unknown, ERHIAccess::RTV));
  866.                                 RHICmdList.BeginRenderPass(RPInfo, TEXT("FilterMips"));
  868.                                 RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  870.                                 const FIntRect ViewRect(0, 0, MipSize, MipSize);
  871.                                 RHICmdList.SetViewport(0, 0, 0.0f, MipSize, MipSize, 1.0f);
  873.                                 //TShaderMapRef<TCubeFilterPS<1>> CaptureCubemapArrayPixelShader(GetGlobalShaderMap(FeatureLevel));
  875.                                 TShaderMapRef<FScreenVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
  876.                                 TShaderMapRef<TCubeFilterPS<0>> PixelShader(GetGlobalShaderMap(FeatureLevel));
  877.                                 GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  878.                                 GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  879.                                 GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  880.                                 GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  882.                                 SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  884.                                 {
  885.                                     FRHIPixelShader* ShaderRHI = PixelShader.GetPixelShader();
  887.                                     SetShaderValue(RHICmdList, ShaderRHI, PixelShader->CubeFace, CubeFace);
  888.                                     SetShaderValue(RHICmdList, ShaderRHI, PixelShader->MipIndex, MipIndex);
  890.                                     SetShaderValue(RHICmdList, ShaderRHI, PixelShader->NumMips, NumMips);
  892.                                     SetTextureParameter(
  893.                                         RHICmdList,
  894.                                         ShaderRHI,
  895.                                         PixelShader->SourceCubemapTexture,
  896.                                         PixelShader->SourceCubemapSampler,
  897.                                         TStaticSamplerState<SF_Trilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI(),
  898.                                         DownSampledCube.ShaderResourceTexture);
  899.                                 }
  901.                                 DrawRectangle(
  902.                                     RHICmdList,
  903.                                     ViewRect.Min.X, ViewRect.Min.Y,
  904.                                     ViewRect.Width(), ViewRect.Height(),
  905.                                     ViewRect.Min.X, ViewRect.Min.Y,
  906.                                     ViewRect.Width(), ViewRect.Height(),
  907.                                     FIntPoint(ViewRect.Width(), ViewRect.Height()),
  908.                                     FIntPoint(MipSize, MipSize),
  909.                                     VertexShader);
  911.                                 RHICmdList.EndRenderPass();
  912.                             }
  913.                         }
  914.                     }
  916.                 D:\\UnrealEngine426\\Engine\\Shaders\\Private\\ReflectionEnvironmentShaders.usf
  918.                 1.      #ifdef USE_COMPUTE
  919.                         int CubeFaceOffset;
  920.                         [numthreads(THREADGROUP_SIZE, THREADGROUP_SIZE, 1)]
  921.                         void FilterCS(uint3 ThreadId : SV_DispatchThreadID)
  922.                         {
  923.                             const uint2 FaceCoord = uint2(ThreadId.x % uint(FaceThreadGroupSize), ThreadId.y);
  924.                             if (any(FaceCoord >= uint2(ValidDispatchCoord)))
  925.                             {
  926.                                 return;
  927.                             }
  928.                             const int SelectedCubeFace = CubeFaceOffset + int(ThreadId.x) / FaceThreadGroupSize;
  929.                             float2 ScaledUVs = ((float2(FaceCoord) + 0.5f) / float2(ValidDispatchCoord)) * 2.0f - 1.0f;
  930.                             float4 OutColor;
  931.                         #else // USE_COMPUTE
  932.                         void FilterPS(
  933.                             FScreenVertexOutput Input,
  934.                             out float4 OutColor : SV_Target0
  935.                             )
  936.                         { 
  937.                             float2 ScaledUVs = Input.UV * 2 - 1;
  938.                             const int SelectedCubeFace = CubeFace;
  939.                         #endif // USE_COMPUTE
  940.                             float3 CubeCoordinates = GetCubemapVector(ScaledUVs, SelectedCubeFace);
  942.                             float3 N = normalize(CubeCoordinates);
  943.                             float3x3 TangentToWorld = GetTangentBasis( N );
  945.                             float Roughness = ComputeReflectionCaptureRoughnessFromMip( MipIndex, NumMips - 1 );
  947.                             if( Roughness < 0.01 )
  948.                             {
  949.                                 OutColor = SourceCubemapTexture.SampleLevel(SourceCubemapSampler, CubeCoordinates, 0 );
  950.                             #ifdef USE_COMPUTE
  951.                                 OutTextureMipColor[uint3(FaceCoord, SelectedCubeFace)] = OutColor;
  952.                             #endif
  953.                                 return;
  954.                             }
  956.                             uint CubeSize = 1 << ( NumMips - 1 );
  957.                             const float SolidAngleTexel = 4*PI / ( 6 * CubeSize * CubeSize ) * 2;
  959.                             //const uint NumSamples = 1024;
  960.                             const uint NumSamples = Roughness < 0.1 ? 32 : 64;
  962.                             float4 FilteredColor = 0;
  963.                             BRANCH
  964.                             if( Roughness > 0.99 )
  965.                             {
  966.                                 // Roughness=1, GGX is constant. Use cosine distribution instead
  968.                                 LOOP
  969.                                 for( uint i = 0; i < NumSamples; i++ )
  970.                                 {
  971.                                     float2 E = Hammersley( i, NumSamples, 0 );
  973.                                     float3 L = CosineSampleHemisphere( E ).xyz;
  975.                                     float NoL = L.z;
  977.                                     float PDF = NoL / PI;
  978.                                     float SolidAngleSample = 1.0 / ( NumSamples * PDF );
  979.                                     float Mip = 0.5 * log2( SolidAngleSample / SolidAngleTexel );
  981.                                     L = mul( L, TangentToWorld );
  982.                                     FilteredColor += SourceCubemapTexture.SampleLevel(SourceCubemapSampler, L, Mip );
  983.                                 }
  985.                                 OutColor = FilteredColor / NumSamples;
  986.                             }
  987.                             else
  988.                             {
  989.                                 float Weight = 0;
  991.                                 LOOP
  992.                                 for( uint i = 0; i < NumSamples; i++ )
  993.                                 {
  994.                                     float2 E = Hammersley( i, NumSamples, 0 );
  996.                                     // 6x6 Offset rows. Forms uniform star pattern
  997.                                     //uint2 Index = uint2( i % 6, i / 6 );
  998.                                     //float2 E = ( Index + 0.5 ) / 5.8;
  999.                                     //E.x = frac( E.x + (Index.y & 1) * (0.5 / 6.0) );
  1001.                                     E.y *= 0.995;
  1003.                                     float3 H = ImportanceSampleGGX( E, Pow4(Roughness) ).xyz;
  1004.                                     float3 L = 2 * H.z * H - float3(0,0,1);
  1006.                                     float NoL = L.z;
  1007.                                     float NoH = H.z;
  1009.                                     if( NoL > 0 )
  1010.                                     {
  1011.                                         //float TexelWeight = CubeTexelWeight( L );
  1012.                                         //float SolidAngleTexel = SolidAngleAvgTexel * TexelWeight;
  1014.                                         //float PDF = D_GGX( Pow4(Roughness), NoH ) * NoH / (4 * VoH);
  1015.                                         float PDF = D_GGX( Pow4(Roughness), NoH ) * 0.25;
  1016.                                         float SolidAngleSample = 1.0 / ( NumSamples * PDF );
  1017.                                         float Mip = 0.5 * log2( SolidAngleSample / SolidAngleTexel );
  1019.                                         float ConeAngle = acos( 1 - SolidAngleSample / (2*PI) );
  1021.                                         L = mul( L, TangentToWorld );
  1022.                                         FilteredColor += SourceCubemapTexture.SampleLevel(SourceCubemapSampler, L, Mip ) * NoL;
  1023.                                         Weight += NoL;
  1024.                                     }
  1025.                                 }
  1027.                                 OutColor = FilteredColor / Weight;
  1028.                             }
  1030.                         #ifdef USE_COMPUTE
  1031.                             OutTextureMipColor[uint3(FaceCoord, SelectedCubeFace)] = OutColor;
  1032.                         #endif
  1033.                         }
  1035.                     D:\\UnrealEngine426\\Engine\\Shaders\\Private\\MonteCarlo.ush
  1037.                     1.      float2 Hammersley( uint Index, uint NumSamples, uint2 Random )
  1038.                             {
  1039.                                 float E1 = frac( (float)Index / NumSamples + float( Random.x & 0xffff ) / (1<<16) );
  1040.                                 float E2 = float( ReverseBits32(Index) ^ Random.y ) * 2.3283064365386963e-10;
  1041.                                 return float2( E1, E2 );
  1042.                             }
  1044.                             float4 CosineSampleHemisphere( float2 E )
  1045.                             {
  1046.                                 float Phi = 2 * PI * E.x;
  1047.                                 float CosTheta = sqrt( E.y );
  1048.                                 float SinTheta = sqrt( 1 - CosTheta * CosTheta );
  1050.                                 float3 H;
  1051.                                 H.x = SinTheta * cos( Phi );
  1052.                                 H.y = SinTheta * sin( Phi );
  1053.                                 H.z = CosTheta;
  1055.                                 float PDF = CosTheta * (1.0 /  PI);
  1057.                                 return float4( H, PDF );
  1058.                             }
  1060.                             float4 ImportanceSampleGGX( float2 E, float a2 )
  1061.                             {
  1062.                                 float Phi = 2 * PI * E.x;
  1063.                                 float CosTheta = sqrt( (1 - E.y) / ( 1 + (a2 - 1) * E.y ) );
  1064.                                 float SinTheta = sqrt( 1 - CosTheta * CosTheta );
  1066.                                 float3 H;
  1067.                                 H.x = SinTheta * cos( Phi );
  1068.                                 H.y = SinTheta * sin( Phi );
  1069.                                 H.z = CosTheta;
  1071.                                 float d = ( CosTheta * a2 - CosTheta ) * CosTheta + 1;
  1072.                                 float D = a2 / ( PI*d*d );
  1073.                                 float PDF = D * CosTheta;
  1075.                                 return float4( H, PDF );
  1076.                             }
  1077.                     2.  D:\\UnrealEngine426\\Engine\\Shaders\\Private\\BRDF.ush
  1079.                         1.      // GGX / Trowbridge-Reitz
  1080.                                 // [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
  1081.                                 float D_GGX( float a2, float NoH )
  1082.                                 {
  1083.                                     float d = ( NoH * a2 - NoH ) * NoH + 1;    // 2 mad
  1084.                                     return a2 / ( PI*d*d );                    // 4 mul, 1 rcp
  1085.                                 }

发表评论

表情：
评论列表 （有 0 条评论，337人围观）

还没有评论，来说两句吧...

相关阅读

    相关 UE4 SkyLight 记录

    背景： 想了解一下，UE4如何使用HDR图，作为环境光，官方有个插件HDRIBackdrop，主要就是使用SkyLight进行，因此重点看了一下SkyLight，记录一下。

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 338 阅读