UE4 SkyLight SH转换

你的名字 2022-09-16 14:18 184阅读 0赞

D:\\UnrealEngine426\\Engine\\Shaders\\Private\\ReflectionEnvironmentShared.ush

#if (FEATURE_LEVEL <= FEATURE_LEVEL_ES3_1)
    #define SkyIrradianceEnvironmentMap		View.MobileSkyIrradianceEnvironmentMap
    #else
    #define SkyIrradianceEnvironmentMap		View.SkyIrradianceEnvironmentMap
    #endif
    
    /** 
     * Computes sky diffuse lighting from the SH irradiance map.  
     * This has the SH basis evaluation and diffuse convolution weights combined for minimal ALU's - see "Stupid Spherical Harmonics (SH) Tricks" 
     */
    float3 GetSkySHDiffuse(float3 Normal)
    {
    	float4 NormalVector = float4(Normal, 1.0f); 
    
    	float3 Intermediate0, Intermediate1, Intermediate2;
    	Intermediate0.x = dot(SkyIrradianceEnvironmentMap[0], NormalVector);
    	Intermediate0.y = dot(SkyIrradianceEnvironmentMap[1], NormalVector);
    	Intermediate0.z = dot(SkyIrradianceEnvironmentMap[2], NormalVector);
    
    	float4 vB = NormalVector.xyzz * NormalVector.yzzx;
    	Intermediate1.x = dot(SkyIrradianceEnvironmentMap[3], vB);
    	Intermediate1.y = dot(SkyIrradianceEnvironmentMap[4], vB);
    	Intermediate1.z = dot(SkyIrradianceEnvironmentMap[5], vB);
    
    	float vC = NormalVector.x * NormalVector.x - NormalVector.y * NormalVector.y;
    	Intermediate2 = SkyIrradianceEnvironmentMap[6].xyz * vC;
    
    	// max to not get negative colors
    	return max(0, Intermediate0 + Intermediate1 + Intermediate2);
    }

D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Engine\\Public\\SceneView.h

// View uniform buffer member declarations
    #define VIEW_UNIFORM_BUFFER_MEMBER_TABLE \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, TranslatedWorldToClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, WorldToClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ClipToWorld)  \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, TranslatedWorldToView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ViewToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, TranslatedWorldToCameraView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, CameraViewToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ViewToClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ViewToClipNoAA) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ClipToView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ClipToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, SVPositionToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ScreenToWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ScreenToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, MobileMultiviewShadowTransform) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, ViewForward, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, ViewUp, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, ViewRight, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, HMDViewNoRollUp, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, HMDViewNoRollRight, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, InvDeviceZToWorldZTransform) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4, ScreenPositionScaleBias, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, WorldCameraOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, TranslatedWorldCameraOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, WorldViewOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, PreViewTranslation) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevProjection) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevViewProj) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevViewRotationProj) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevViewToClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevClipToView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevTranslatedWorldToClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevTranslatedWorldToView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevViewToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevTranslatedWorldToCameraView) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevCameraViewToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, PrevWorldCameraOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, PrevWorldViewOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, PrevPreViewTranslation) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevInvViewProj) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, PrevScreenToTranslatedWorld) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, ClipToPrevClip) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, TemporalAAJitter) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, GlobalClippingPlane) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector2D, FieldOfViewWideAngles) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector2D, PrevFieldOfViewWideAngles) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4, ViewRectMin, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, ViewSizeAndInvSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, LightProbeSizeRatioAndInvSizeRatio) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, BufferSizeAndInvSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, BufferBilinearUVMinMax) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, ScreenToViewSpace) \
    	VIEW_UNIFORM_BUFFER_MEMBER(int32, NumSceneColorMSAASamples) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, PreExposure) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, OneOverPreExposure) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4, DiffuseOverrideParameter, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4, SpecularOverrideParameter, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4, NormalOverrideParameter, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector2D, RoughnessOverrideParameter, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, PrevFrameGameTime) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, PrevFrameRealTime) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, OutOfBoundsMask, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, WorldCameraMovementSinceLastFrame) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, CullingSign) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, NearPlane, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, AdaptiveTessellationFactor) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, GameTime) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, RealTime) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DeltaTime) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MaterialTextureMipBias) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MaterialTextureDerivativeMultiply) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, Random) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, FrameNumber) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, StateFrameIndexMod8) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, StateFrameIndex) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, DebugViewModeMask) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, CameraCut, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, UnlitViewmodeMask, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FLinearColor, DirectionalLightColor, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector, DirectionalLightDirection, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, TranslucencyLightingVolumeMin, [TVC_MAX]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, TranslucencyLightingVolumeInvSize, [TVC_MAX]) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, TemporalAAParams) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, CircleDOFParams) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, ForceDrawAllVelocities) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldSensorWidth) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalDistance) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldScale) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalLength) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalRegion) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldNearTransitionRegion) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFarTransitionRegion) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MotionBlurNormalizedToPixel) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, bSubsurfacePostprocessEnabled) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, GeneralPurposeTweak) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, DemosaicVposOffset, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, IndirectLightingColorScale) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogSunPower, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogPower, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogDensityScale, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogDensityOffset, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogGroundOffset, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogDistanceScale, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogAltitudeScale, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogHeightScaleRayleigh, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogStartDistance, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogDistanceOffset, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, AtmosphericFogSunDiscScale, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, AtmosphereLightDirection, [NUM_ATMOSPHERE_LIGHTS]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightColor, [NUM_ATMOSPHERE_LIGHTS]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightColorGlobalPostTransmittance, [NUM_ATMOSPHERE_LIGHTS]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightDiscLuminance, [NUM_ATMOSPHERE_LIGHTS]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, AtmosphereLightDiscCosHalfApexAngle, [NUM_ATMOSPHERE_LIGHTS]) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, SkyViewLutSizeAndInvSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, SkyWorldCameraOrigin) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, SkyPlanetCenterAndViewHeight) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, SkyViewLutReferential) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, SkyAtmosphereSkyLuminanceFactor) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmospherePresentInScene) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereHeightFogContribution) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereBottomRadiusKm) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereTopRadiusKm) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, SkyAtmosphereCameraAerialPerspectiveVolumeSizeAndInvSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereAerialPerspectiveStartDepthKm) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolution) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolutionInv) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKm) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKmInv) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereApplyCameraAerialPerspectiveVolume) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, AtmosphericFogRenderMask) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, AtmosphericFogInscatterAltitudeSampleNum) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, NormalCurvatureToRoughnessScaleBias) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, RenderingReflectionCaptureMask) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, RealTimeReflectionCapture) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, RealTimeReflectionCapturePreExposure) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, AmbientCubemapTint) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, AmbientCubemapIntensity) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightApplyPrecomputedBentNormalShadowingFlag) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightAffectReflectionFlag) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightAffectGlobalIlluminationFlag) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, SkyLightColor) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, MobileSkyIrradianceEnvironmentMap, [7]) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MobilePreviewMode) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, HMDEyePaddingOffset) \
    	VIEW_UNIFORM_BUFFER_MEMBER_EX(float, ReflectionCubemapMaxMip, EShaderPrecisionModifier::Half) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, ShowDecalsMask) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, DistanceFieldAOSpecularOcclusionMode) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, IndirectCapsuleSelfShadowingIntensity) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight) \
    	VIEW_UNIFORM_BUFFER_MEMBER(int32, StereoPassIndex) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, GlobalVolumeCenterAndExtent, [GMaxGlobalDistanceFieldClipmaps]) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, GlobalVolumeWorldToUVAddAndMul, [GMaxGlobalDistanceFieldClipmaps]) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalVolumeDimension) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalVolumeTexelSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MaxGlobalDistance) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FIntPoint, CursorPosition) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, bCheckerboardSubsurfaceProfileRendering) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricFogInvGridSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricFogGridZParams) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector2D, VolumetricFogSVPosToVolumeUV) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, VolumetricFogMaxDistance) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricLightmapWorldToUVScale) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricLightmapWorldToUVAdd) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricLightmapIndirectionTextureSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, VolumetricLightmapBrickSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector, VolumetricLightmapBrickTexelSize) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, StereoIPD) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, IndirectLightingCacheShowFlag) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, EyeToPixelSpreadAngle) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FMatrix, WorldToVirtualTexture) \
    	VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4, XRPassthroughCameraUVs, [2]) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackStride) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, RuntimeVirtualTextureMipLevel) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector2D, RuntimeVirtualTexturePackHeight) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, RuntimeVirtualTextureDebugParams) \
    	VIEW_UNIFORM_BUFFER_MEMBER(int32, FarShadowStaticMeshLODBias) \
    	VIEW_UNIFORM_BUFFER_MEMBER(float, MinRoughness) \
    	VIEW_UNIFORM_BUFFER_MEMBER(FVector4, HairRenderInfo) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, EnableSkyLight) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, HairRenderInfoBits) \
    	VIEW_UNIFORM_BUFFER_MEMBER(uint32, HairComponents) \
    
    #define VIEW_UNIFORM_BUFFER_MEMBER(type, identifier) \
    	SHADER_PARAMETER(type, identifier)
    
    #define VIEW_UNIFORM_BUFFER_MEMBER_EX(type, identifier, precision) \
    	SHADER_PARAMETER_EX(type, identifier, precision)
    
    #define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(type, identifier, dimension) \
    	SHADER_PARAMETER_ARRAY(type, identifier, dimension)
    
    /** The uniform shader parameters associated with a view. */
    BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FViewUniformShaderParameters, ENGINE_API)
    
    	VIEW_UNIFORM_BUFFER_MEMBER_TABLE
    
    	// Same as Wrap_WorldGroupSettings and Clamp_WorldGroupSettings, but with mipbias=MaterialTextureMipBias.
    	SHADER_PARAMETER_SAMPLER(SamplerState, MaterialTextureBilinearWrapedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, MaterialTextureBilinearClampedSampler)
    
    	SHADER_PARAMETER_TEXTURE(Texture3D<uint4>, VolumetricLightmapIndirectionTexture) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickAmbientVector) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients0) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients1) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients2) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients3) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients4) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients5) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, SkyBentNormalBrickTexture) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_TEXTURE(Texture3D, DirectionalLightShadowingBrickTexture) // FPrecomputedVolumetricLightmapLightingPolicy
    
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapBrickAmbientVectorSampler) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler0) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler1) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler2) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler3) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler4) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler5) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, SkyBentNormalTextureSampler) // FPrecomputedVolumetricLightmapLightingPolicy
    	SHADER_PARAMETER_SAMPLER(SamplerState, DirectionalLightShadowingTextureSampler) // FPrecomputedVolumetricLightmapLightingPolicy
    
    	SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldTexture0)
    	SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldSampler0)
    	SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldTexture1)
    	SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldSampler1)
    	SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldTexture2)
    	SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldSampler2)
    	SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldTexture3)
    	SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldSampler3)
    
    	SHADER_PARAMETER_TEXTURE(Texture2D, AtmosphereTransmittanceTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereTransmittanceTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D, AtmosphereIrradianceTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereIrradianceTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture3D, AtmosphereInscatterTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereInscatterTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D, PerlinNoiseGradientTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, PerlinNoiseGradientTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture3D, PerlinNoise3DTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, PerlinNoise3DTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D<uint>, SobolSamplingTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedPointWrappedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedPointClampedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedBilinearWrappedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedBilinearClampedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedTrilinearWrappedSampler)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SharedTrilinearClampedSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D, PreIntegratedBRDF)
    	SHADER_PARAMETER_SAMPLER(SamplerState, PreIntegratedBRDFSampler)
    	SHADER_PARAMETER_SRV(StructuredBuffer<float4>, PrimitiveSceneData)
    	SHADER_PARAMETER_TEXTURE(Texture2D<float4>, PrimitiveSceneDataTexture)
    	SHADER_PARAMETER_SRV(StructuredBuffer<float4>, LightmapSceneData)
    	SHADER_PARAMETER_SRV(StructuredBuffer<float4>, SkyIrradianceEnvironmentMap)
    
    	SHADER_PARAMETER_TEXTURE(Texture2D, TransmittanceLutTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, TransmittanceLutTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D, SkyViewLutTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, SkyViewLutTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture2D, DistantSkyLightLutTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, DistantSkyLightLutTextureSampler)
    	SHADER_PARAMETER_TEXTURE(Texture3D, CameraAerialPerspectiveVolume)
    	SHADER_PARAMETER_SAMPLER(SamplerState, CameraAerialPerspectiveVolumeSampler)
    
    	SHADER_PARAMETER_TEXTURE(Texture3D, HairScatteringLUTTexture)
    	SHADER_PARAMETER_SAMPLER(SamplerState, HairScatteringLUTSampler)
    
    	SHADER_PARAMETER_SRV(StructuredBuffer<float4>, WaterIndirection)
    	SHADER_PARAMETER_SRV(StructuredBuffer<float4>, WaterData)
    
    	SHADER_PARAMETER_UAV(RWBuffer<uint>, VTFeedbackBuffer)
    	SHADER_PARAMETER_UAV(RWTexture2D<uint>, QuadOverdraw)
    
    END_GLOBAL_SHADER_PARAMETER_STRUCT()
    
    /** Copy of the view uniform shader parameters associated with a view for instanced stereo. */
    BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FInstancedViewUniformShaderParameters, ENGINE_API)
    	VIEW_UNIFORM_BUFFER_MEMBER_TABLE
    END_GLOBAL_SHADER_PARAMETER_STRUCT()
    
    #undef VIEW_UNIFORM_BUFFER_MEMBER_TABLE
    #undef VIEW_UNIFORM_BUFFER_MEMBER
    #undef VIEW_UNIFORM_BUFFER_MEMBER_EX
    #undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY

D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\SceneRendering.cpp

void FViewInfo::InitRHIResources()
    {
    	FBox VolumeBounds[TVC_MAX];
    
    	check(IsInRenderingThread());
    
    	CachedViewUniformShaderParameters = MakeUnique<FViewUniformShaderParameters>();
    
    	FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(FRHICommandListExecutor::GetImmediateCommandList());
    
    	SetupUniformBufferParameters(
    		SceneContext,
    		VolumeBounds,
    		TVC_MAX,
    		*CachedViewUniformShaderParameters);
    
    	ViewUniformBuffer = TUniformBufferRef<FViewUniformShaderParameters>::CreateUniformBufferImmediate(*CachedViewUniformShaderParameters, UniformBuffer_SingleFrame);
    
    	const int32 TranslucencyLightingVolumeDim = GetTranslucencyLightingVolumeDim();
    
    	// Reset CachedView when CachedViewUniformShaderParameters change.
    	FScene* Scene = Family->Scene ? Family->Scene->GetRenderScene() : nullptr;
    	if (Scene)
    	{
    		Scene->UniformBuffers.InvalidateCachedView();
    	}
    
    	for (int32 CascadeIndex = 0; CascadeIndex < TVC_MAX; CascadeIndex++)
    	{
    		TranslucencyLightingVolumeMin[CascadeIndex] = VolumeBounds[CascadeIndex].Min;
    		TranslucencyVolumeVoxelSize[CascadeIndex] = (VolumeBounds[CascadeIndex].Max.X - VolumeBounds[CascadeIndex].Min.X) / TranslucencyLightingVolumeDim;
    		TranslucencyLightingVolumeSize[CascadeIndex] = VolumeBounds[CascadeIndex].Max - VolumeBounds[CascadeIndex].Min;
    	}
    }
    
    
    
    /** Creates the view's uniform buffers given a set of view transforms. */
    void FViewInfo::SetupUniformBufferParameters(
    	FSceneRenderTargets& SceneContext,
    	const FViewMatrices& InViewMatrices,
    	const FViewMatrices& InPrevViewMatrices,
    	FBox* OutTranslucentCascadeBoundsArray,
    	int32 NumTranslucentCascades,
    	FViewUniformShaderParameters& ViewUniformShaderParameters) const
    {
    	check(Family);
    
    	// Create the view's uniform buffer.
    
    	// Mobile multi-view is not side by side
    	const FIntRect EffectiveViewRect = (bIsMobileMultiViewEnabled) ? FIntRect(0, 0, ViewRect.Width(), ViewRect.Height()) : ViewRect;
    
    	// Scene render targets may not be created yet; avoids NaNs.
    	FIntPoint EffectiveBufferSize = SceneContext.GetBufferSizeXY();
    	EffectiveBufferSize.X = FMath::Max(EffectiveBufferSize.X, 1);
    	EffectiveBufferSize.Y = FMath::Max(EffectiveBufferSize.Y, 1);
    
    	// TODO: We should use a view and previous view uniform buffer to avoid code duplication and keep consistency
    	SetupCommonViewUniformBufferParameters(
    		ViewUniformShaderParameters,
    		EffectiveBufferSize,
    		SceneContext.GetMSAACount(),
    		EffectiveViewRect,
    		InViewMatrices,
    		InPrevViewMatrices
    	);
    
    	const bool bCheckerboardSubsurfaceRendering = IsSubsurfaceCheckerboardFormat(SceneContext.GetSceneColorFormat());
    	ViewUniformShaderParameters.bCheckerboardSubsurfaceProfileRendering = bCheckerboardSubsurfaceRendering ? 1.0f : 0.0f;
    
    	ViewUniformShaderParameters.IndirectLightingCacheShowFlag = Family->EngineShowFlags.IndirectLightingCache;
    
    	FScene* Scene = nullptr;
    
    	if (Family->Scene)
    	{
    		Scene = Family->Scene->GetRenderScene();
    	}
    
    	const FVector DefaultSunDirection(0.0f, 0.0f, 1.0f); // Up vector so that the AtmosphericLightVector node always output a valid direction.
    	auto ClearAtmosphereLightData = [&](uint32 Index)
    	{
    		check(Index < NUM_ATMOSPHERE_LIGHTS);
    		ViewUniformShaderParameters.AtmosphereLightDiscCosHalfApexAngle[Index] = FVector4(1.0f);
    		ViewUniformShaderParameters.AtmosphereLightDiscLuminance[Index] = FLinearColor::Black;
    		ViewUniformShaderParameters.AtmosphereLightColor[Index] = FLinearColor::Black;
    		ViewUniformShaderParameters.AtmosphereLightColor[Index].A = 0.0f;
    		ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index] = FLinearColor::Black;
    		ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index].A = 0.0f;
    		ViewUniformShaderParameters.AtmosphereLightDirection[Index] = DefaultSunDirection;
    	};
    
    	bool bShouldRenderAtmosphericFog = false;
    	if (Scene)
    	{
    		bShouldRenderAtmosphericFog = ShouldRenderAtmosphere(*Family) && Scene->AtmosphericFog;
    		if (Scene->SimpleDirectionalLight)
    		{
    			ViewUniformShaderParameters.DirectionalLightColor = Scene->SimpleDirectionalLight->Proxy->GetTransmittanceFactor() * Scene->SimpleDirectionalLight->Proxy->GetColor() / PI;
    			ViewUniformShaderParameters.DirectionalLightDirection = -Scene->SimpleDirectionalLight->Proxy->GetDirection();
    		}
    		else
    		{
    			ViewUniformShaderParameters.DirectionalLightColor = FLinearColor::Black;
    			ViewUniformShaderParameters.DirectionalLightDirection = FVector::ZeroVector;
    		}
    
    		// Atmospheric fog parameters
    		FLightSceneInfo* SunLight = Scene->AtmosphereLights[0];	// Atmospheric fog only takes into account the a single sun light with index 0.
    		const float SunLightDiskHalfApexAngleRadian = SunLight ? SunLight->Proxy->GetSunLightHalfApexAngleRadian() : FLightSceneProxy::GetSunOnEarthHalfApexAngleRadian();
    		if (bShouldRenderAtmosphericFog)
    		{
    			ViewUniformShaderParameters.AtmosphericFogSunPower = Scene->AtmosphericFog->SunMultiplier;
    			ViewUniformShaderParameters.AtmosphericFogPower = Scene->AtmosphericFog->FogMultiplier;
    			ViewUniformShaderParameters.AtmosphericFogDensityScale = Scene->AtmosphericFog->InvDensityMultiplier;
    			ViewUniformShaderParameters.AtmosphericFogDensityOffset = Scene->AtmosphericFog->DensityOffset;
    			ViewUniformShaderParameters.AtmosphericFogGroundOffset = Scene->AtmosphericFog->GroundOffset;
    			ViewUniformShaderParameters.AtmosphericFogDistanceScale = Scene->AtmosphericFog->DistanceScale;
    			ViewUniformShaderParameters.AtmosphericFogAltitudeScale = Scene->AtmosphericFog->AltitudeScale;
    			ViewUniformShaderParameters.AtmosphericFogHeightScaleRayleigh = Scene->AtmosphericFog->RHeight;
    			ViewUniformShaderParameters.AtmosphericFogStartDistance = Scene->AtmosphericFog->StartDistance;
    			ViewUniformShaderParameters.AtmosphericFogDistanceOffset = Scene->AtmosphericFog->DistanceOffset;
    			ViewUniformShaderParameters.AtmosphericFogSunDiscScale = Scene->AtmosphericFog->SunDiscScale;
    			ViewUniformShaderParameters.AtmosphericFogRenderMask = uint32(Scene->AtmosphericFog->RenderFlag & (EAtmosphereRenderFlag::E_DisableGroundScattering | EAtmosphereRenderFlag::E_DisableSunDisk));
    			ViewUniformShaderParameters.AtmosphericFogInscatterAltitudeSampleNum = Scene->AtmosphericFog->InscatterAltitudeSampleNum;
    			ViewUniformShaderParameters.AtmosphereLightDiscCosHalfApexAngle[0] = FVector4(FMath::Cos(Scene->AtmosphericFog->SunDiscScale * SunLightDiskHalfApexAngleRadian));
    			ViewUniformShaderParameters.AtmosphereLightDiscLuminance[0] = SunLight ? SunLight->Proxy->GetOuterSpaceLuminance() : FLinearColor::White;
    			ViewUniformShaderParameters.AtmosphereLightColor[0] = SunLight ? SunLight->Proxy->GetColor() : Scene->AtmosphericFog->DefaultSunColor; // Sun light color unaffected by atmosphere transmittance
    			ViewUniformShaderParameters.AtmosphereLightColor[0].A = 1.0f;
    			ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[0] = ViewUniformShaderParameters.AtmosphereLightColor[0];
    			ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[0].A = 0.0f;
    			ViewUniformShaderParameters.AtmosphereLightDirection[0] = SunLight ? -SunLight->Proxy->GetDirection() : -Scene->AtmosphericFog->DefaultSunDirection;
    		}
    		else
    		{
    			ViewUniformShaderParameters.AtmosphericFogSunPower = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogPower = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogDensityScale = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogDensityOffset = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogGroundOffset = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogDistanceScale = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogAltitudeScale = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogHeightScaleRayleigh = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogStartDistance = FLT_MAX;
    			ViewUniformShaderParameters.AtmosphericFogDistanceOffset = 0.f;
    			ViewUniformShaderParameters.AtmosphericFogSunDiscScale = 1.f;
    			ViewUniformShaderParameters.AtmosphericFogRenderMask = (uint32)EAtmosphereRenderFlag::E_EnableAll;
    			ViewUniformShaderParameters.AtmosphericFogInscatterAltitudeSampleNum = 0;
    			ViewUniformShaderParameters.AtmosphereLightDiscCosHalfApexAngle[0] = FVector4(FMath::Cos(SunLightDiskHalfApexAngleRadian));
    			//Added check so atmospheric light color and vector can use a directional light without needing an atmospheric fog actor in the scene
    			ViewUniformShaderParameters.AtmosphereLightDiscLuminance[0] = SunLight ? SunLight->Proxy->GetOuterSpaceLuminance() : FLinearColor::Black;
    			ViewUniformShaderParameters.AtmosphereLightColor[0] = SunLight ? SunLight->Proxy->GetColor() : FLinearColor::Black;
    			ViewUniformShaderParameters.AtmosphereLightColor[0].A = 1.0f;
    			ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[0] = ViewUniformShaderParameters.AtmosphereLightColor[0];
    			ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[0].A = 0.0f;
    			ViewUniformShaderParameters.AtmosphereLightDirection[0] = SunLight ? -SunLight->Proxy->GetDirection() : DefaultSunDirection;
    		}
    
    		// Do not clear the first AtmosphereLight data, it has been setup above
    		for (uint8 Index = 1; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
    		{
    			ClearAtmosphereLightData(Index);
    		}
    	}
    	else
    	{
    		// Atmospheric fog parameters
    		ViewUniformShaderParameters.AtmosphericFogSunPower = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogPower = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogDensityScale = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogDensityOffset = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogGroundOffset = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogDistanceScale = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogAltitudeScale = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogHeightScaleRayleigh = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogStartDistance = FLT_MAX;
    		ViewUniformShaderParameters.AtmosphericFogDistanceOffset = 0.f;
    		ViewUniformShaderParameters.AtmosphericFogSunDiscScale = 1.f;
    		ViewUniformShaderParameters.AtmosphericFogRenderMask = (uint32)EAtmosphereRenderFlag::E_EnableAll;
    		ViewUniformShaderParameters.AtmosphericFogInscatterAltitudeSampleNum = 0;
    	}
    
    	FRHITexture* TransmittanceLutTextureFound = nullptr;
    	FRHITexture* SkyViewLutTextureFound = nullptr;
    	FRHITexture* CameraAerialPerspectiveVolumeFound = nullptr;
    	FRHITexture* DistantSkyLightLutTextureFound = nullptr;
    	if (ShouldRenderSkyAtmosphere(Scene, Family->EngineShowFlags))
    	{
    		ViewUniformShaderParameters.SkyAtmospherePresentInScene = 1.0f;
    
    		FSkyAtmosphereRenderSceneInfo* SkyAtmosphere = Scene->SkyAtmosphere;
    		const FSkyAtmosphereSceneProxy& SkyAtmosphereSceneProxy = SkyAtmosphere->GetSkyAtmosphereSceneProxy();
    
    		// Get access to texture resource if we have valid pointer.
    		// (Valid pointer checks are needed because some resources might not have been initialized when coming from FCanvasTileRendererItem or FCanvasTriangleRendererItem)
    
    		const TRefCountPtr<IPooledRenderTarget>& PooledTransmittanceLutTexture = SkyAtmosphere->GetTransmittanceLutTexture();
    		if (PooledTransmittanceLutTexture.IsValid())
    		{
    			TransmittanceLutTextureFound = PooledTransmittanceLutTexture->GetRenderTargetItem().ShaderResourceTexture;
    		}
    		const TRefCountPtr<IPooledRenderTarget>& PooledDistantSkyLightLutTexture = SkyAtmosphere->GetDistantSkyLightLutTexture();
    		if (PooledDistantSkyLightLutTexture.IsValid())
    		{
    			DistantSkyLightLutTextureFound = PooledDistantSkyLightLutTexture->GetRenderTargetItem().ShaderResourceTexture;
    		}
    
    		if (this->SkyAtmosphereCameraAerialPerspectiveVolume.IsValid())
    		{
    			CameraAerialPerspectiveVolumeFound = this->SkyAtmosphereCameraAerialPerspectiveVolume->GetRenderTargetItem().ShaderResourceTexture;
    		}
    
    		float SkyViewLutWidth = 1.0f;
    		float SkyViewLutHeight = 1.0f;
    		if (this->SkyAtmosphereViewLutTexture.IsValid())
    		{
    			SkyViewLutTextureFound = this->SkyAtmosphereViewLutTexture->GetRenderTargetItem().ShaderResourceTexture;
    			SkyViewLutWidth = float(this->SkyAtmosphereViewLutTexture->GetDesc().GetSize().X);
    			SkyViewLutHeight = float(this->SkyAtmosphereViewLutTexture->GetDesc().GetSize().Y);
    		}
    		ViewUniformShaderParameters.SkyViewLutSizeAndInvSize = FVector4(SkyViewLutWidth, SkyViewLutHeight, 1.0f / SkyViewLutWidth, 1.0f / SkyViewLutHeight);
    
    		// Now initialize remaining view parameters.
    
    		const FAtmosphereSetup& AtmosphereSetup = SkyAtmosphereSceneProxy.GetAtmosphereSetup();
    		ViewUniformShaderParameters.SkyAtmosphereBottomRadiusKm = AtmosphereSetup.BottomRadiusKm;
    		ViewUniformShaderParameters.SkyAtmosphereTopRadiusKm = AtmosphereSetup.TopRadiusKm;
    
    		FSkyAtmosphereViewSharedUniformShaderParameters OutParameters;
    		SetupSkyAtmosphereViewSharedUniformShaderParameters(*this, SkyAtmosphereSceneProxy, OutParameters);
    		ViewUniformShaderParameters.SkyAtmosphereAerialPerspectiveStartDepthKm = OutParameters.AerialPerspectiveStartDepthKm;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeSizeAndInvSize = OutParameters.CameraAerialPerspectiveVolumeSizeAndInvSize;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolution = OutParameters.CameraAerialPerspectiveVolumeDepthResolution;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolutionInv = OutParameters.CameraAerialPerspectiveVolumeDepthResolutionInv;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKm = OutParameters.CameraAerialPerspectiveVolumeDepthSliceLengthKm;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKmInv = OutParameters.CameraAerialPerspectiveVolumeDepthSliceLengthKmInv;
    		ViewUniformShaderParameters.SkyAtmosphereApplyCameraAerialPerspectiveVolume = OutParameters.ApplyCameraAerialPerspectiveVolume;
    		ViewUniformShaderParameters.SkyAtmosphereSkyLuminanceFactor = SkyAtmosphereSceneProxy.GetSkyLuminanceFactor();
    		ViewUniformShaderParameters.SkyAtmosphereHeightFogContribution = SkyAtmosphereSceneProxy.GetHeightFogContribution();
    
    		// Fill atmosphere lights shader parameters
    		for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
    		{
    			FLightSceneInfo* Light = Scene->AtmosphereLights[Index];
    			if (Light)
    			{
    				ViewUniformShaderParameters.AtmosphereLightDiscCosHalfApexAngle[Index] = FVector4(FMath::Cos(Light->Proxy->GetSunLightHalfApexAngleRadian()));
    				ViewUniformShaderParameters.AtmosphereLightDiscLuminance[Index] = Light->Proxy->GetOuterSpaceLuminance();
    				ViewUniformShaderParameters.AtmosphereLightColor[Index] = Light->Proxy->GetColor();
    				ViewUniformShaderParameters.AtmosphereLightColor[Index].A = 1.0f;
    				ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index] = Light->Proxy->GetColor() * Light->Proxy->GetTransmittanceFactor();
    				ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index].A = 1.0f;
    				ViewUniformShaderParameters.AtmosphereLightDirection[Index] = SkyAtmosphereSceneProxy.GetAtmosphereLightDirection(Index, -Light->Proxy->GetDirection());
    			}
    			else
    			{
    				ClearAtmosphereLightData(Index);
    			}
    		}
    
    		// Regular view sampling of the SkyViewLUT. This is only changed when sampled from a sky material for the real time reflection capture around sky light position)
    		AtmosphereSetup.ComputeViewData(ViewUniformShaderParameters.WorldCameraOrigin, ViewUniformShaderParameters.ViewForward, ViewUniformShaderParameters.ViewRight,
    			ViewUniformShaderParameters.SkyWorldCameraOrigin, ViewUniformShaderParameters.SkyPlanetCenterAndViewHeight, ViewUniformShaderParameters.SkyViewLutReferential);
    	}
    	else
    	{
    		ViewUniformShaderParameters.SkyAtmospherePresentInScene = 0.0f;
    		ViewUniformShaderParameters.SkyAtmosphereHeightFogContribution = 0.0f;
    		ViewUniformShaderParameters.SkyViewLutSizeAndInvSize = FVector4(1.0f, 1.0f, 1.0f, 1.0f);
    		ViewUniformShaderParameters.SkyAtmosphereBottomRadiusKm = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereTopRadiusKm = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereSkyLuminanceFactor = FLinearColor::White;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeSizeAndInvSize = FVector4(1.0f, 1.0f, 1.0f, 1.0f);
    		ViewUniformShaderParameters.SkyAtmosphereAerialPerspectiveStartDepthKm = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolution = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolutionInv = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKm = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKmInv = 1.0f;
    		ViewUniformShaderParameters.SkyAtmosphereApplyCameraAerialPerspectiveVolume = 0.0f;
    		ViewUniformShaderParameters.SkyWorldCameraOrigin = ViewUniformShaderParameters.WorldCameraOrigin;
    		ViewUniformShaderParameters.SkyPlanetCenterAndViewHeight = FVector4(ForceInitToZero);
    		ViewUniformShaderParameters.SkyViewLutReferential = FMatrix::Identity;
    
    		if(!bShouldRenderAtmosphericFog && Scene)
    		{
    			// Fill atmosphere lights shader parameters even without any SkyAtmosphere nor AtmosphericFog component.
    			// This is to always make these parameters usable, for instance by the VolumetricCloud component.
    			for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
    			{
    				FLightSceneInfo* Light = Scene->AtmosphereLights[Index];
    				if (Light)
    				{
    					ViewUniformShaderParameters.AtmosphereLightDiscCosHalfApexAngle[Index] = FVector4(1.0f);
    					ViewUniformShaderParameters.AtmosphereLightDiscLuminance[Index] = FLinearColor::Black;
    					ViewUniformShaderParameters.AtmosphereLightColor[Index] = Light->Proxy->GetColor();
    					ViewUniformShaderParameters.AtmosphereLightColor[Index].A = 1.0f;
    					ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index] = Light->Proxy->GetColor();
    					ViewUniformShaderParameters.AtmosphereLightColorGlobalPostTransmittance[Index].A = 0.0f; // no interactions with HeightFogComponent
    					ViewUniformShaderParameters.AtmosphereLightDirection[Index] = -Light->Proxy->GetDirection();
    				}
    				else
    				{
    					ClearAtmosphereLightData(Index);
    				}
    			}
    		}
    		else if (!Scene)
    		{
    			for (uint8 Index = 0; Index < NUM_ATMOSPHERE_LIGHTS; ++Index)
    			{
    				ClearAtmosphereLightData(Index);
    			}
    		}
    	}
    
    	ViewUniformShaderParameters.TransmittanceLutTexture = OrWhite2DIfNull(TransmittanceLutTextureFound);
    	ViewUniformShaderParameters.TransmittanceLutTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    	ViewUniformShaderParameters.DistantSkyLightLutTexture = OrBlack2DIfNull(DistantSkyLightLutTextureFound);
    	ViewUniformShaderParameters.DistantSkyLightLutTextureSampler = TStaticSamplerState<SF_Point, AM_Wrap, AM_Wrap>::GetRHI();
    	ViewUniformShaderParameters.SkyViewLutTexture = OrBlack2DIfNull(SkyViewLutTextureFound);
    	ViewUniformShaderParameters.SkyViewLutTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    	ViewUniformShaderParameters.CameraAerialPerspectiveVolume = OrBlack3DAlpha1IfNull(CameraAerialPerspectiveVolumeFound);
    	ViewUniformShaderParameters.CameraAerialPerspectiveVolumeSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    
    	ViewUniformShaderParameters.AtmosphereTransmittanceTexture = OrBlack2DIfNull(AtmosphereTransmittanceTexture);
    	ViewUniformShaderParameters.AtmosphereIrradianceTexture = OrBlack2DIfNull(AtmosphereIrradianceTexture);
    	ViewUniformShaderParameters.AtmosphereInscatterTexture = OrBlack3DIfNull(AtmosphereInscatterTexture);
    
    	ViewUniformShaderParameters.AtmosphereTransmittanceTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    	ViewUniformShaderParameters.AtmosphereIrradianceTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    	ViewUniformShaderParameters.AtmosphereInscatterTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
    
    	// This should probably be in SetupCommonViewUniformBufferParameters, but drags in too many dependencies
    	UpdateNoiseTextureParameters(ViewUniformShaderParameters);
    
    	SetupDefaultGlobalDistanceFieldUniformBufferParameters(ViewUniformShaderParameters);
    
    	SetupVolumetricFogUniformBufferParameters(ViewUniformShaderParameters);
    
    	SetupPrecomputedVolumetricLightmapUniformBufferParameters(Scene, Family->EngineShowFlags, ViewUniformShaderParameters);
    
    	// Setup view's shared sampler for material texture sampling.
    	{
    		const float GlobalMipBias = UTexture2D::GetGlobalMipMapLODBias();
    
    		float FinalMaterialTextureMipBias = GlobalMipBias;
    
    		if (bIsValidWorldTextureGroupSamplerFilter && !FMath::IsNearlyZero(MaterialTextureMipBias))
    		{
    			ViewUniformShaderParameters.MaterialTextureMipBias = MaterialTextureMipBias;
    			ViewUniformShaderParameters.MaterialTextureDerivativeMultiply = FMath::Pow(2.0f, MaterialTextureMipBias);
    
    			FinalMaterialTextureMipBias += MaterialTextureMipBias;
    		}
    
    		FSamplerStateRHIRef WrappedSampler = nullptr;
    		FSamplerStateRHIRef ClampedSampler = nullptr;
    
    		if (FMath::Abs(FinalMaterialTextureMipBias - GlobalMipBias) < KINDA_SMALL_NUMBER)
    		{
    			WrappedSampler = Wrap_WorldGroupSettings->SamplerStateRHI;
    			ClampedSampler = Clamp_WorldGroupSettings->SamplerStateRHI;
    		}
    		else if (ViewState && FMath::Abs(ViewState->MaterialTextureCachedMipBias - FinalMaterialTextureMipBias) < KINDA_SMALL_NUMBER)
    		{
    			WrappedSampler = ViewState->MaterialTextureBilinearWrapedSamplerCache;
    			ClampedSampler = ViewState->MaterialTextureBilinearClampedSamplerCache;
    		}
    		else
    		{
    			check(bIsValidWorldTextureGroupSamplerFilter);
    
    			WrappedSampler = RHICreateSamplerState(FSamplerStateInitializerRHI(WorldTextureGroupSamplerFilter, AM_Wrap,  AM_Wrap,  AM_Wrap,  FinalMaterialTextureMipBias));
    			ClampedSampler = RHICreateSamplerState(FSamplerStateInitializerRHI(WorldTextureGroupSamplerFilter, AM_Clamp, AM_Clamp, AM_Clamp, FinalMaterialTextureMipBias));
    		}
    
    		// At this point, a sampler must be set.
    		check(WrappedSampler.IsValid());
    		check(ClampedSampler.IsValid());
    
    		ViewUniformShaderParameters.MaterialTextureBilinearWrapedSampler = WrappedSampler;
    		ViewUniformShaderParameters.MaterialTextureBilinearClampedSampler = ClampedSampler;
    
    		// Update view state's cached sampler.
    		if (ViewState && ViewState->MaterialTextureBilinearWrapedSamplerCache != WrappedSampler)
    		{
    			ViewState->MaterialTextureCachedMipBias = FinalMaterialTextureMipBias;
    			ViewState->MaterialTextureBilinearWrapedSamplerCache = WrappedSampler;
    			ViewState->MaterialTextureBilinearClampedSamplerCache = ClampedSampler;
    		}
    	}
    
    	{
    		ensureMsgf(TemporalJitterSequenceLength == 1 || AntiAliasingMethod == AAM_TemporalAA,
    			TEXT("TemporalJitterSequenceLength = %i is invalid"), TemporalJitterSequenceLength);
    		ensureMsgf(TemporalJitterIndex >= 0 && TemporalJitterIndex < TemporalJitterSequenceLength,
    			TEXT("TemporalJitterIndex = %i is invalid (TemporalJitterSequenceLength = %i)"), TemporalJitterIndex, TemporalJitterSequenceLength);
    		ViewUniformShaderParameters.TemporalAAParams = FVector4(
    			TemporalJitterIndex, 
    			TemporalJitterSequenceLength,
    			TemporalJitterPixels.X,
    			TemporalJitterPixels.Y);
    	}
    
    	ViewUniformShaderParameters.ForceDrawAllVelocities = CVarBasePassForceOutputsVelocity.GetValueOnRenderThread();
    		
    	uint32 FrameIndex = 0;
    	if (ViewState)
    	{
    		FrameIndex = ViewState->GetFrameIndex();
    	}
    
    	// TODO(GA): kill StateFrameIndexMod8 because this is only a scalar bit mask with StateFrameIndex anyway.
    	ViewUniformShaderParameters.StateFrameIndexMod8 = FrameIndex % 8;
    	ViewUniformShaderParameters.StateFrameIndex = FrameIndex;
    
    	{
    		// If rendering in stereo, the other stereo passes uses the left eye's translucency lighting volume.
    		const FViewInfo* PrimaryView = this;
    		if (IStereoRendering::IsASecondaryView(*this))
    		{
    			if (Family->Views.IsValidIndex(0))
    			{
    				const FSceneView* LeftEyeView = Family->Views[0];
    				if (LeftEyeView->bIsViewInfo && IStereoRendering::IsAPrimaryView(*LeftEyeView))
    				{
    					PrimaryView = static_cast<const FViewInfo*>(LeftEyeView);
    				}
    			}
    		}
    		PrimaryView->CalcTranslucencyLightingVolumeBounds(OutTranslucentCascadeBoundsArray, NumTranslucentCascades);
    	}
    
    	const int32 TranslucencyLightingVolumeDim = GetTranslucencyLightingVolumeDim();
    
    	for (int32 CascadeIndex = 0; CascadeIndex < NumTranslucentCascades; CascadeIndex++)
    	{
    		const float VolumeVoxelSize = (OutTranslucentCascadeBoundsArray[CascadeIndex].Max.X - OutTranslucentCascadeBoundsArray[CascadeIndex].Min.X) / TranslucencyLightingVolumeDim;
    		const FVector VolumeSize = OutTranslucentCascadeBoundsArray[CascadeIndex].Max - OutTranslucentCascadeBoundsArray[CascadeIndex].Min;
    		ViewUniformShaderParameters.TranslucencyLightingVolumeMin[CascadeIndex] = FVector4(OutTranslucentCascadeBoundsArray[CascadeIndex].Min, 1.0f / TranslucencyLightingVolumeDim);
    		ViewUniformShaderParameters.TranslucencyLightingVolumeInvSize[CascadeIndex] = FVector4(FVector(1.0f) / VolumeSize, VolumeVoxelSize);
    	}
    	
    	ViewUniformShaderParameters.PreExposure = PreExposure;
    	ViewUniformShaderParameters.OneOverPreExposure = 1.f / PreExposure;
    
    	ViewUniformShaderParameters.DepthOfFieldFocalDistance = FinalPostProcessSettings.DepthOfFieldFocalDistance;
    	ViewUniformShaderParameters.DepthOfFieldSensorWidth = FinalPostProcessSettings.DepthOfFieldSensorWidth;
    	ViewUniformShaderParameters.DepthOfFieldFocalRegion = FinalPostProcessSettings.DepthOfFieldFocalRegion;
    	// clamped to avoid div by 0 in shader
    	ViewUniformShaderParameters.DepthOfFieldNearTransitionRegion = FMath::Max(0.01f, FinalPostProcessSettings.DepthOfFieldNearTransitionRegion);
    	// clamped to avoid div by 0 in shader
    	ViewUniformShaderParameters.DepthOfFieldFarTransitionRegion = FMath::Max(0.01f, FinalPostProcessSettings.DepthOfFieldFarTransitionRegion);
    	ViewUniformShaderParameters.DepthOfFieldScale = FinalPostProcessSettings.DepthOfFieldScale;
    	ViewUniformShaderParameters.DepthOfFieldFocalLength = 50.0f;
    
    	ViewUniformShaderParameters.bSubsurfacePostprocessEnabled = IsSubsurfaceEnabled() ? 1.0f : 0.0f;
    
    	{
    		// This is the CVar default
    		float Value = 1.0f;
    
    		// Compiled out in SHIPPING to make cheating a bit harder.
    #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    		Value = CVarGeneralPurposeTweak.GetValueOnRenderThread();
    #endif
    
    		ViewUniformShaderParameters.GeneralPurposeTweak = Value;
    	}
    
    	ViewUniformShaderParameters.DemosaicVposOffset = 0.0f;
    	{
    		ViewUniformShaderParameters.DemosaicVposOffset = CVarDemosaicVposOffset.GetValueOnRenderThread();
    	}
    
    	ViewUniformShaderParameters.IndirectLightingColorScale = FVector(FinalPostProcessSettings.IndirectLightingColor.R * FinalPostProcessSettings.IndirectLightingIntensity,
    		FinalPostProcessSettings.IndirectLightingColor.G * FinalPostProcessSettings.IndirectLightingIntensity,
    		FinalPostProcessSettings.IndirectLightingColor.B * FinalPostProcessSettings.IndirectLightingIntensity);
    
    	ViewUniformShaderParameters.NormalCurvatureToRoughnessScaleBias.X = FMath::Clamp(CVarNormalCurvatureToRoughnessScale.GetValueOnAnyThread(), 0.0f, 2.0f);
    	ViewUniformShaderParameters.NormalCurvatureToRoughnessScaleBias.Y = FMath::Clamp(CVarNormalCurvatureToRoughnessBias.GetValueOnAnyThread(), -1.0f, 1.0f);
    	ViewUniformShaderParameters.NormalCurvatureToRoughnessScaleBias.Z = FMath::Clamp(CVarNormalCurvatureToRoughnessExponent.GetValueOnAnyThread(), .05f, 20.0f);
    
    	ViewUniformShaderParameters.RenderingReflectionCaptureMask = bIsReflectionCapture ? 1.0f : 0.0f;
    	ViewUniformShaderParameters.RealTimeReflectionCapture = 0.0f;
    	ViewUniformShaderParameters.RealTimeReflectionCapturePreExposure = 1.0f; // This must be 1 for now. If changed, we need to update the SkyLight AverageExposure and take it into account when sampling sky specular and diffuse irradiance.
    
    	ViewUniformShaderParameters.AmbientCubemapTint = FinalPostProcessSettings.AmbientCubemapTint;
    	ViewUniformShaderParameters.AmbientCubemapIntensity = FinalPostProcessSettings.AmbientCubemapIntensity;
    
    	ViewUniformShaderParameters.CircleDOFParams = DiaphragmDOF::CircleDofHalfCoc(*this);
    
    	ERHIFeatureLevel::Type RHIFeatureLevel = Scene == nullptr ? GMaxRHIFeatureLevel : Scene->GetFeatureLevel();
    
    	if (Scene && Scene->SkyLight)
    	{
    		FSkyLightSceneProxy* SkyLight = Scene->SkyLight;
    
    		ViewUniformShaderParameters.SkyLightColor = SkyLight->GetEffectiveLightColor();
    
    		bool bApplyPrecomputedBentNormalShadowing = 
    			SkyLight->bCastShadows 
    			&& SkyLight->bWantsStaticShadowing;
    
    		ViewUniformShaderParameters.SkyLightApplyPrecomputedBentNormalShadowingFlag = bApplyPrecomputedBentNormalShadowing ? 1.0f : 0.0f;
    		ViewUniformShaderParameters.SkyLightAffectReflectionFlag = SkyLight->bAffectReflection ? 1.0f : 0.0f;
    		ViewUniformShaderParameters.SkyLightAffectGlobalIlluminationFlag = SkyLight->bAffectGlobalIllumination ? 1.0f : 0.0f;
    	}
    	else
    	{
    		ViewUniformShaderParameters.SkyLightColor = FLinearColor::Black;
    		ViewUniformShaderParameters.SkyLightApplyPrecomputedBentNormalShadowingFlag = 0.0f;
    		ViewUniformShaderParameters.SkyLightAffectReflectionFlag = 0.0f;
    		ViewUniformShaderParameters.SkyLightAffectGlobalIlluminationFlag = 0.0f;
    	}
    
    	if (RHIFeatureLevel == ERHIFeatureLevel::ES3_1)
    	{
    		// Make sure there's no padding since we're going to cast to FVector4*
    		static_assert(sizeof(ViewUniformShaderParameters.MobileSkyIrradianceEnvironmentMap) == sizeof(FVector4) * 7, "unexpected sizeof ViewUniformShaderParameters.MobileSkyIrradianceEnvironmentMap");
    
    		const bool bSetupSkyIrradiance = Scene
    			&& Scene->SkyLight
    			// Skylights with static lighting already had their diffuse contribution baked into lightmaps
    			&& !Scene->SkyLight->bHasStaticLighting
    			&& Family->EngineShowFlags.SkyLighting;
    
    		if (bSetupSkyIrradiance)
    		{
    			const FSHVectorRGB3& SkyIrradiance = Scene->SkyLight->IrradianceEnvironmentMap;
    			SetupSkyIrradianceEnvironmentMapConstantsFromSkyIrradiance((FVector4*)&ViewUniformShaderParameters.MobileSkyIrradianceEnvironmentMap, SkyIrradiance);
    		}
    		else
    		{
    			FMemory::Memzero((FVector4*)&ViewUniformShaderParameters.MobileSkyIrradianceEnvironmentMap, sizeof(FVector4) * 7);
    		}
    	}
    	else
    	{
    		if (Scene && Scene->SkyIrradianceEnvironmentMap.SRV)
    		{
    			ViewUniformShaderParameters.SkyIrradianceEnvironmentMap = Scene->SkyIrradianceEnvironmentMap.SRV;
    		}
    		else
    		{
    			ViewUniformShaderParameters.SkyIrradianceEnvironmentMap = GIdentityPrimitiveBuffer.SkyIrradianceEnvironmentMapSRV;
    		}
    	}
    	ViewUniformShaderParameters.MobilePreviewMode =
    		(GIsEditor &&
    		(RHIFeatureLevel == ERHIFeatureLevel::ES3_1) &&
    		GMaxRHIFeatureLevel > ERHIFeatureLevel::ES3_1) ? 1.0f : 0.0f;
    
    	// Padding between the left and right eye may be introduced by an HMD, which instanced stereo needs to account for.
    	if ((IStereoRendering::IsStereoEyePass(StereoPass)) && (Family->Views.Num() > 1))
    	{
    		check(Family->Views.Num() >= 2);
    
    		// The static_cast<const FViewInfo*> is fine because when executing this method, we know that
    		// Family::Views point to multiple FViewInfo, since of them is <this>.
    		const float StereoViewportWidth = float(
    			static_cast<const FViewInfo*>(Family->Views[1])->ViewRect.Max.X - 
    			static_cast<const FViewInfo*>(Family->Views[0])->ViewRect.Min.X);
    		const float EyePaddingSize = float(
    			static_cast<const FViewInfo*>(Family->Views[1])->ViewRect.Min.X -
    			static_cast<const FViewInfo*>(Family->Views[0])->ViewRect.Max.X);
    
    		ViewUniformShaderParameters.HMDEyePaddingOffset = (StereoViewportWidth - EyePaddingSize) / StereoViewportWidth;
    	}
    	else
    	{
    		ViewUniformShaderParameters.HMDEyePaddingOffset = 1.0f;
    	}
    
    	ViewUniformShaderParameters.ReflectionCubemapMaxMip = FMath::FloorLog2(UReflectionCaptureComponent::GetReflectionCaptureSize());
    
    	ViewUniformShaderParameters.ShowDecalsMask = Family->EngineShowFlags.Decals ? 1.0f : 0.0f;
    
    	extern int32 GDistanceFieldAOSpecularOcclusionMode;
    	ViewUniformShaderParameters.DistanceFieldAOSpecularOcclusionMode = GDistanceFieldAOSpecularOcclusionMode;
    
    	ViewUniformShaderParameters.IndirectCapsuleSelfShadowingIntensity = Scene ? Scene->DynamicIndirectShadowsSelfShadowingIntensity : 1.0f;
    
    	extern FVector GetReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight();
    	ViewUniformShaderParameters.ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight = GetReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight();
    
    	ViewUniformShaderParameters.StereoPassIndex = GEngine->StereoRenderingDevice ? GEngine->StereoRenderingDevice->GetViewIndexForPass(StereoPass) : 0;
    	ViewUniformShaderParameters.StereoIPD = StereoIPD;
    
    	{
    		auto XRCamera = GEngine->XRSystem ? GEngine->XRSystem->GetXRCamera() : nullptr;
    		TArray<FVector2D> CameraUVs;
    		if (XRCamera.IsValid() && XRCamera->GetPassthroughCameraUVs_RenderThread(CameraUVs) && CameraUVs.Num() == 4)
    		{
    			ViewUniformShaderParameters.XRPassthroughCameraUVs[0] = FVector4(CameraUVs[0], CameraUVs[1]);
    			ViewUniformShaderParameters.XRPassthroughCameraUVs[1] = FVector4(CameraUVs[2], CameraUVs[3]);
    		}
    		else
    		{
    			ViewUniformShaderParameters.XRPassthroughCameraUVs[0] = FVector4(0, 0, 0, 1);
    			ViewUniformShaderParameters.XRPassthroughCameraUVs[1] = FVector4(1, 0, 1, 1);
    		}
    	}
    
    	if (DrawDynamicFlags & EDrawDynamicFlags::FarShadowCascade)
    	{
    		extern ENGINE_API int32 GFarShadowStaticMeshLODBias;
    		ViewUniformShaderParameters.FarShadowStaticMeshLODBias = GFarShadowStaticMeshLODBias;
    	}
    	else
    	{
    		ViewUniformShaderParameters.FarShadowStaticMeshLODBias = 0;
    	}
    
    	ViewUniformShaderParameters.PreIntegratedBRDF = GEngine->PreIntegratedSkinBRDFTexture->Resource->TextureRHI;
    
    	ViewUniformShaderParameters.VirtualTextureFeedbackStride = SceneContext.GetVirtualTextureFeedbackBufferSize().X;
    	ViewUniformShaderParameters.RuntimeVirtualTextureMipLevel = FVector4(ForceInitToZero);
    	ViewUniformShaderParameters.RuntimeVirtualTexturePackHeight = FVector2D(ForceInitToZero);
    	ViewUniformShaderParameters.RuntimeVirtualTextureDebugParams = FVector4(ForceInitToZero);
    	
    	if (UseGPUScene(GMaxRHIShaderPlatform, RHIFeatureLevel))
    	{
    		if (PrimitiveSceneDataOverrideSRV)
    		{
    			ViewUniformShaderParameters.PrimitiveSceneData = PrimitiveSceneDataOverrideSRV;
    		}
    		else
    		{
    			const FRWBufferStructured* ViewPrimitiveShaderDataBuffer = nullptr;
    
    			if (DynamicPrimitiveShaderData.Num() > 0)
    			{
    				ViewPrimitiveShaderDataBuffer = ViewState ? &ViewState->PrimitiveShaderDataBuffer : &OneFramePrimitiveShaderDataBuffer;
    			}
    			else if (Scene)
    			{
    				ViewPrimitiveShaderDataBuffer = &Scene->GPUScene.PrimitiveBuffer;
    			}
    
    			if (ViewPrimitiveShaderDataBuffer && ViewPrimitiveShaderDataBuffer->SRV)
    			{
    				ViewUniformShaderParameters.PrimitiveSceneData = ViewPrimitiveShaderDataBuffer->SRV;
    			}
    		}
    
    		if (PrimitiveSceneDataTextureOverrideRHI)
    		{
    			ViewUniformShaderParameters.PrimitiveSceneDataTexture = PrimitiveSceneDataTextureOverrideRHI;
    		}
    		else
    		{
    			const FTextureRWBuffer2D* ViewPrimitiveShaderDataTexture = nullptr;
    			if (DynamicPrimitiveShaderData.Num() > 0)
    			{
    				ViewPrimitiveShaderDataTexture = ViewState ? &ViewState->PrimitiveShaderDataTexture : &OneFramePrimitiveShaderDataTexture;
    			}
    			else if (Scene)
    			{
    				ViewPrimitiveShaderDataTexture = &Scene->GPUScene.PrimitiveTexture;
    			}
    
    			if (ViewPrimitiveShaderDataTexture)
    			{
    				ViewUniformShaderParameters.PrimitiveSceneDataTexture = OrBlack2DIfNull(ViewPrimitiveShaderDataTexture->Buffer);
    			}
    		}
    		
    		if (LightmapSceneDataOverrideSRV)
    		{
    			ViewUniformShaderParameters.LightmapSceneData = LightmapSceneDataOverrideSRV;
    		}
    		else if (Scene && Scene->GPUScene.LightmapDataBuffer.SRV)
    		{
    			ViewUniformShaderParameters.LightmapSceneData = Scene->GPUScene.LightmapDataBuffer.SRV;
    		}
    	}
    
    	// Hair global resources 
    	SetUpViewHairRenderInfo(*this, ViewUniformShaderParameters.HairRenderInfo, ViewUniformShaderParameters.HairRenderInfoBits, ViewUniformShaderParameters.HairComponents);
    	UpdateHairLUT(*this);
    	ViewUniformShaderParameters.HairScatteringLUTTexture = nullptr;
    	if (GSystemTextures.HairLUT0.IsValid() && GSystemTextures.HairLUT0->GetRenderTargetItem().ShaderResourceTexture)
    	{
    		ViewUniformShaderParameters.HairScatteringLUTTexture = GSystemTextures.HairLUT0->GetRenderTargetItem().ShaderResourceTexture;
    	}
    	ViewUniformShaderParameters.HairScatteringLUTTexture = OrBlack3DIfNull(ViewUniformShaderParameters.HairScatteringLUTTexture);
    	ViewUniformShaderParameters.HairScatteringLUTSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
    
    	if (WaterDataBuffer.IsValid() && WaterIndirectionBuffer.IsValid())
    	{
    		ViewUniformShaderParameters.WaterIndirection = WaterIndirectionBuffer.GetReference();
    		ViewUniformShaderParameters.WaterData = WaterDataBuffer.GetReference();
    	}
    	else
    	{
    		ViewUniformShaderParameters.WaterIndirection = GIdentityPrimitiveBuffer.PrimitiveSceneDataBufferSRV;
    		ViewUniformShaderParameters.WaterData = GIdentityPrimitiveBuffer.PrimitiveSceneDataBufferSRV;
    	}
    
    	ViewUniformShaderParameters.VTFeedbackBuffer = SceneContext.GetVirtualTextureFeedbackUAV();
    	ViewUniformShaderParameters.QuadOverdraw = SceneContext.GetQuadOverdrawBufferUAV();
    }
    
    
    
    RENDERER_API void SetupSkyIrradianceEnvironmentMapConstantsFromSkyIrradiance(FVector4* OutSkyIrradianceEnvironmentMap, const FSHVectorRGB3 SkyIrradiance)
    {
    	const float SqrtPI = FMath::Sqrt(PI);
    	const float Coefficient0 = 1.0f / (2 * SqrtPI);
    	const float Coefficient1 = FMath::Sqrt(3) / (3 * SqrtPI);
    	const float Coefficient2 = FMath::Sqrt(15) / (8 * SqrtPI);
    	const float Coefficient3 = FMath::Sqrt(5) / (16 * SqrtPI);
    	const float Coefficient4 = .5f * Coefficient2;
    
    	// Pack the SH coefficients in a way that makes applying the lighting use the least shader instructions
    	// This has the diffuse convolution coefficients baked in
    	// See "Stupid Spherical Harmonics (SH) Tricks"
    	OutSkyIrradianceEnvironmentMap[0].X = -Coefficient1 * SkyIrradiance.R.V[3];
    	OutSkyIrradianceEnvironmentMap[0].Y = -Coefficient1 * SkyIrradiance.R.V[1];
    	OutSkyIrradianceEnvironmentMap[0].Z = Coefficient1 * SkyIrradiance.R.V[2];
    	OutSkyIrradianceEnvironmentMap[0].W = Coefficient0 * SkyIrradiance.R.V[0] - Coefficient3 * SkyIrradiance.R.V[6];
    
    	OutSkyIrradianceEnvironmentMap[1].X = -Coefficient1 * SkyIrradiance.G.V[3];
    	OutSkyIrradianceEnvironmentMap[1].Y = -Coefficient1 * SkyIrradiance.G.V[1];
    	OutSkyIrradianceEnvironmentMap[1].Z = Coefficient1 * SkyIrradiance.G.V[2];
    	OutSkyIrradianceEnvironmentMap[1].W = Coefficient0 * SkyIrradiance.G.V[0] - Coefficient3 * SkyIrradiance.G.V[6];
    
    	OutSkyIrradianceEnvironmentMap[2].X = -Coefficient1 * SkyIrradiance.B.V[3];
    	OutSkyIrradianceEnvironmentMap[2].Y = -Coefficient1 * SkyIrradiance.B.V[1];
    	OutSkyIrradianceEnvironmentMap[2].Z = Coefficient1 * SkyIrradiance.B.V[2];
    	OutSkyIrradianceEnvironmentMap[2].W = Coefficient0 * SkyIrradiance.B.V[0] - Coefficient3 * SkyIrradiance.B.V[6];
    
    	OutSkyIrradianceEnvironmentMap[3].X = Coefficient2 * SkyIrradiance.R.V[4];
    	OutSkyIrradianceEnvironmentMap[3].Y = -Coefficient2 * SkyIrradiance.R.V[5];
    	OutSkyIrradianceEnvironmentMap[3].Z = 3 * Coefficient3 * SkyIrradiance.R.V[6];
    	OutSkyIrradianceEnvironmentMap[3].W = -Coefficient2 * SkyIrradiance.R.V[7];
    
    	OutSkyIrradianceEnvironmentMap[4].X = Coefficient2 * SkyIrradiance.G.V[4];
    	OutSkyIrradianceEnvironmentMap[4].Y = -Coefficient2 * SkyIrradiance.G.V[5];
    	OutSkyIrradianceEnvironmentMap[4].Z = 3 * Coefficient3 * SkyIrradiance.G.V[6];
    	OutSkyIrradianceEnvironmentMap[4].W = -Coefficient2 * SkyIrradiance.G.V[7];
    
    	OutSkyIrradianceEnvironmentMap[5].X = Coefficient2 * SkyIrradiance.B.V[4];
    	OutSkyIrradianceEnvironmentMap[5].Y = -Coefficient2 * SkyIrradiance.B.V[5];
    	OutSkyIrradianceEnvironmentMap[5].Z = 3 * Coefficient3 * SkyIrradiance.B.V[6];
    	OutSkyIrradianceEnvironmentMap[5].W = -Coefficient2 * SkyIrradiance.B.V[7];
    
    	OutSkyIrradianceEnvironmentMap[6].X = Coefficient4 * SkyIrradiance.R.V[8];
    	OutSkyIrradianceEnvironmentMap[6].Y = Coefficient4 * SkyIrradiance.G.V[8];
    	OutSkyIrradianceEnvironmentMap[6].Z = Coefficient4 * SkyIrradiance.B.V[8];
    	OutSkyIrradianceEnvironmentMap[6].W = 1;
    }

D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\SceneVisibility.cpp

/**
     * Initialize scene's views.
     * Check visibility, build visible mesh commands, etc.
     */
    bool FDeferredShadingSceneRenderer::InitViews(FRHICommandListImmediate& RHICmdList, FExclusiveDepthStencil::Type BasePassDepthStencilAccess, struct FILCUpdatePrimTaskData& ILCTaskData)
    {
    	SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_InitViews, FColor::Emerald);
    	SCOPE_CYCLE_COUNTER(STAT_InitViewsTime);
    	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(InitViews_Scene);
    	check(RHICmdList.IsOutsideRenderPass());
    
    	PreVisibilityFrameSetup(RHICmdList);
    
    	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
    
    	{
    		// This is to init the ViewUniformBuffer before rendering for the Niagara compute shader.
    		// This needs to run before ComputeViewVisibility() is called, but the views normally initialize the ViewUniformBuffer after that (at the end of this method).
    		if (FXSystem && FXSystem->RequiresEarlyViewUniformBuffer() && Views.IsValidIndex(0))
    		{
    			Views[0].InitRHIResources();
    			FXSystem->PostInitViews(RHICmdList, Views[0].ViewUniformBuffer, Views[0].AllowGPUParticleUpdate() && !ViewFamily.EngineShowFlags.HitProxies);
    		}
    	}
    	
    	FViewVisibleCommandsPerView ViewCommandsPerView;
    	ViewCommandsPerView.SetNum(Views.Num());
    
    	ComputeViewVisibility(RHICmdList, BasePassDepthStencilAccess, ViewCommandsPerView, DynamicIndexBufferForInitViews, DynamicVertexBufferForInitViews, DynamicReadBufferForInitViews);
    
    	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
    
    	// This has to happen before Scene->IndirectLightingCache.UpdateCache, since primitives in View.IndirectShadowPrimitives need ILC updates
    	CreateIndirectCapsuleShadows();
    
    	// This must happen before we start initialising and using views.
    	UpdateSkyIrradianceGpuBuffer(RHICmdList);
    
    	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
    
    	// Initialise Sky/View resources before the view global uniform buffer is built.
    	if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags))
    	{
    		InitSkyAtmosphereForViews(RHICmdList);
    	}
    
    	PostVisibilityFrameSetup(ILCTaskData);
    	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
    
    	FVector AverageViewPosition(0);
    
    	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
    	{		
    		FViewInfo& View = Views[ViewIndex];
    		AverageViewPosition += View.ViewMatrices.GetViewOrigin() / Views.Num();
    	}
    
    	bool bDoInitViewAftersPrepass = !!GDoInitViewsLightingAfterPrepass;
    
    	if (!bDoInitViewAftersPrepass)
    	{
    		InitViewsPossiblyAfterPrepass(RHICmdList, ILCTaskData);
    	}
    
    	{
    		QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_InitRHIResources);
    		// initialize per-view uniform buffer.
    		for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
    		{
    			FViewInfo& View = Views[ViewIndex];
    
    			if (View.ViewState)
    			{
    				if (!View.ViewState->ForwardLightingResources)
    				{
    					View.ViewState->ForwardLightingResources.Reset(new FForwardLightingViewResources());
    				}
    
    				View.ForwardLightingResources = View.ViewState->ForwardLightingResources.Get();
    			}
    			else
    			{
    				View.ForwardLightingResourcesStorage.Reset(new FForwardLightingViewResources());
    				View.ForwardLightingResources = View.ForwardLightingResourcesStorage.Get();
    			}
    
    #if RHI_RAYTRACING
    			View.IESLightProfileResource = View.ViewState ? &View.ViewState->IESLightProfileResources : nullptr;
    #endif
    			// Set the pre-exposure before initializing the constant buffers.
    			if (View.ViewState)
    			{
    				View.ViewState->UpdatePreExposure(View);
    			}
    
    			// Initialize the view's RHI resources.
    			View.InitRHIResources();
    		}
    	}
    
    	SetupVolumetricFog();
    
    	{
    		QUICK_SCOPE_CYCLE_COUNTER(STAT_InitViews_OnStartRender);
    		OnStartRender(RHICmdList);
    	}
    
    	return bDoInitViewAftersPrepass;
    }

D:\\UnrealEngine426\\Engine\\Source\\Runtime\\Renderer\\Private\\DeferredShadingRenderer.cpp

void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
    {
    	Scene->UpdateAllPrimitiveSceneInfos(RHICmdList, true);
    
    	check(RHICmdList.IsOutsideRenderPass());
    
    	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderOther);
    
    	PrepareViewRectsForRendering();
    
    	if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags))
    	{
    		for (int32 LightIndex = 0; LightIndex < NUM_ATMOSPHERE_LIGHTS; ++LightIndex)
    		{
    			if (Scene->AtmosphereLights[LightIndex])
    			{
    				PrepareSunLightProxy(*Scene->GetSkyAtmosphereSceneInfo(),LightIndex, *Scene->AtmosphereLights[LightIndex]);
    			}
    		}
    	}
    	else if (Scene->AtmosphereLights[0] && Scene->HasAtmosphericFog())
    	{
    		PRAGMA_DISABLE_DEPRECATION_WARNINGS
    		// Only one atmospheric light at one time.
    		Scene->GetAtmosphericFogSceneInfo()->PrepareSunLightProxy(*Scene->AtmosphereLights[0]);
    		PRAGMA_ENABLE_DEPRECATION_WARNINGS
    	}
    	else
    	{
    		Scene->ResetAtmosphereLightsProperties();
    	}
    
    	SCOPED_NAMED_EVENT(FDeferredShadingSceneRenderer_Render, FColor::Emerald);
    
    #if WITH_MGPU
    	FRHIGPUMask RenderTargetGPUMask = (GNumExplicitGPUsForRendering > 1 && ViewFamily.RenderTarget) ? ViewFamily.RenderTarget->GetGPUMask(RHICmdList) : FRHIGPUMask::GPU0();
    	
    	{
    		static auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.PathTracing.GPUCount"));
    		if (CVar && CVar->GetInt() > 1)
    		{
    			RenderTargetGPUMask = FRHIGPUMask::All(); // Broadcast to all GPUs 
    		}
    	}
    
    	ComputeViewGPUMasks(RenderTargetGPUMask);
    #endif // WITH_MGPU
    
    	// By default, limit our GPU usage to only GPUs specified in the view masks.
    	SCOPED_GPU_MASK(RHICmdList, AllViewsGPUMask);
    	SCOPED_GPU_MASK(FRHICommandListExecutor::GetImmediateAsyncComputeCommandList(), AllViewsGPUMask);
    
    	FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
    	
    	//make sure all the targets we're going to use will be safely writable.
    	GRenderTargetPool.TransitionTargetsWritable(RHICmdList);
    
    	// this way we make sure the SceneColor format is the correct one and not the one from the end of frame before
    	SceneContext.ReleaseSceneColor();
    
    	const bool bDBuffer = !ViewFamily.EngineShowFlags.ShaderComplexity && ViewFamily.EngineShowFlags.Decals && IsUsingDBuffers(ShaderPlatform);
    
    	WaitOcclusionTests(RHICmdList);
    
    	if (!ViewFamily.EngineShowFlags.Rendering)
    	{
    		return;
    	}
    	SCOPED_DRAW_EVENT(RHICmdList, Scene);
    
    	// Anything rendered inside Render() which isn't accounted for will fall into this stat
    	// This works because child stat events do not contribute to their parents' times (see GPU_STATS_CHILD_TIMES_INCLUDED)
    	SCOPED_GPU_STAT(RHICmdList, Unaccounted);
    	
    	{
    		SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_Render_Init);
    		SCOPED_GPU_STAT(RHICmdList, AllocateRendertargets);
    
    		// Initialize global system textures (pass-through if already initialized).
    		GSystemTextures.InitializeTextures(RHICmdList, FeatureLevel);
    
    		// Allocate the maximum scene render target space for the current view family.
    		SceneContext.SetKeepDepthContent(true);
    		SceneContext.Allocate(RHICmdList, this);
    	}
    
    	const bool bUseVirtualTexturing = UseVirtualTexturing(FeatureLevel);
    	if (bUseVirtualTexturing)
    	{
    		SCOPED_GPU_STAT(RHICmdList, VirtualTextureUpdate);
    		// AllocateResources needs to be called before RHIBeginScene
    		FVirtualTextureSystem::Get().AllocateResources(RHICmdList, FeatureLevel);
    		FVirtualTextureSystem::Get().CallPendingCallbacks();
    	}
    
    	// Use read-only depth in the base pass if we have a full depth prepass.
    	const bool bAllowReadonlyDepthBasePass = EarlyZPassMode == DDM_AllOpaque
    		&& !ViewFamily.EngineShowFlags.ShaderComplexity
    		&& !ViewFamily.UseDebugViewPS()
    		&& !ViewFamily.EngineShowFlags.Wireframe
    		&& !ViewFamily.EngineShowFlags.LightMapDensity;
    
    	const FExclusiveDepthStencil::Type BasePassDepthStencilAccess =
    		bAllowReadonlyDepthBasePass
    		? FExclusiveDepthStencil::DepthRead_StencilWrite
    		: FExclusiveDepthStencil::DepthWrite_StencilWrite;
    
    	FILCUpdatePrimTaskData ILCTaskData;
    
    	// Find the visible primitives.
    	RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
    
    	bool bDoInitViewAftersPrepass = false;
    	{
    		SCOPED_GPU_STAT(RHICmdList, VisibilityCommands);
    		bDoInitViewAftersPrepass = InitViews(RHICmdList, BasePassDepthStencilAccess, ILCTaskData);
    	}
    ......