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_ARRAYD:\UnrealEngine426\Engine\Source\Runtime\Renderer\Private\SceneRendering.cpp
/** Encapsulates a GPU read/write structured buffer with its UAV and SRV. */
struct FRWBufferStructured
{
FStructuredBufferRHIRef Buffer;
FUnorderedAccessViewRHIRef UAV;
FShaderResourceViewRHIRef SRV;
uint32 NumBytes;
FRWBufferStructured(): NumBytes(0) {}
~FRWBufferStructured()
{
Release();
}
void Initialize(uint32 BytesPerElement, uint32 NumElements, uint32 AdditionalUsage = 0, const TCHAR* InDebugName = NULL, bool bUseUavCounter = false, bool bAppendBuffer = false)
{
check(GMaxRHIFeatureLevel == ERHIFeatureLevel::SM5 || GMaxRHIFeatureLevel == ERHIFeatureLevel::ES3_1);
// Provide a debug name if using Fast VRAM so the allocators diagnostics will work
ensure(!((AdditionalUsage & BUF_FastVRAM) && !InDebugName));
NumBytes = BytesPerElement * NumElements;
FRHIResourceCreateInfo CreateInfo;
CreateInfo.DebugName = InDebugName;
Buffer = RHICreateStructuredBuffer(BytesPerElement, NumBytes, BUF_UnorderedAccess | BUF_ShaderResource | AdditionalUsage, ERHIAccess::UAVMask, CreateInfo);
UAV = RHICreateUnorderedAccessView(Buffer, bUseUavCounter, bAppendBuffer);
SRV = RHICreateShaderResourceView(Buffer);
}
void Release()
{
int32 BufferRefCount = Buffer ? Buffer->GetRefCount() : -1;
if (BufferRefCount == 1)
{
DiscardTransientResource();
}
NumBytes = 0;
Buffer.SafeRelease();
UAV.SafeRelease();
SRV.SafeRelease();
}
void AcquireTransientResource()
{
RHIAcquireTransientResource(Buffer);
}
void DiscardTransientResource()
{
RHIDiscardTransientResource(Buffer);
}
};
void FSceneRenderer::UpdateSkyIrradianceGpuBuffer(FRHICommandListImmediate& RHICmdList)
{
if (Scene == nullptr)
{
return;
}
FVector4 OutSkyIrradianceEnvironmentMap[7];
// Make sure there's no padding since we're going to cast to FVector4*
checkSlow(sizeof(OutSkyIrradianceEnvironmentMap) == sizeof(FVector4) * 7);
check(Scene);
const bool bUploadIrradiance =
Scene->SkyLight
// Skylights with static lighting already had their diffuse contribution baked into lightmaps
&& !Scene->SkyLight->bHasStaticLighting
&& ViewFamily.EngineShowFlags.SkyLighting
&& !Scene->SkyLight->bRealTimeCaptureEnabled; // When bRealTimeCaptureEnabled is tru, the buffer will be setup on GPU directly in this case
if (bUploadIrradiance)
{
const FSHVectorRGB3& SkyIrradiance = Scene->SkyLight->IrradianceEnvironmentMap;
SetupSkyIrradianceEnvironmentMapConstantsFromSkyIrradiance(OutSkyIrradianceEnvironmentMap, SkyIrradiance);
// Create a buffer for this frame
Scene->SkyIrradianceEnvironmentMap.Release();
Scene->SkyIrradianceEnvironmentMap.Initialize(sizeof(FVector4), 7, 0, TEXT("SkyIrradianceEnvironmentMap"));
// Set the captured environment map data
void* DataPtr = RHICmdList.LockStructuredBuffer(Scene->SkyIrradianceEnvironmentMap.Buffer, 0, Scene->SkyIrradianceEnvironmentMap.NumBytes, RLM_WriteOnly);
checkSlow(Scene->SkyIrradianceEnvironmentMap.NumBytes == sizeof(OutSkyIrradianceEnvironmentMap));
FPlatformMemory::Memcpy(DataPtr, &OutSkyIrradianceEnvironmentMap, sizeof(OutSkyIrradianceEnvironmentMap));
RHICmdList.UnlockStructuredBuffer(Scene->SkyIrradianceEnvironmentMap.Buffer);
}
else if (Scene->SkyIrradianceEnvironmentMap.NumBytes == 0)
{
Scene->SkyIrradianceEnvironmentMap.Initialize(sizeof(FVector4), 7, 0, TEXT("SkyIrradianceEnvironmentMap"));
// Ensure that sky irradiance SH buffer contains sensible initial values (zero init).
// If there is no sky in the level, then nothing else may fill this buffer.
void* DataPtr = RHICmdList.LockStructuredBuffer(Scene->SkyIrradianceEnvironmentMap.Buffer, 0, Scene->SkyIrradianceEnvironmentMap.NumBytes, RLM_WriteOnly);
FPlatformMemory::Memset(DataPtr, 0, Scene->SkyIrradianceEnvironmentMap.NumBytes);
RHICmdList.UnlockStructuredBuffer(Scene->SkyIrradianceEnvironmentMap.Buffer);
}
// This buffer is now going to be read for rendering.
RHICmdList.Transition(FRHITransitionInfo(Scene->SkyIrradianceEnvironmentMap.UAV, ERHIAccess::Unknown, ERHIAccess::SRVMask));
}
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);
}
......
扫一扫
1185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
