void FForwardShadingSceneRenderer::ConditionalResolveSceneDepth(FRHICommandListImmediate& RHICmdList)
{
FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
SceneContext.ResolveSceneDepthToAuxiliaryTexture(RHICmdList);
#if !PLATFORM_HTML5
auto ShaderPlatform = ViewFamily.GetShaderPlatform();
if (IsMobileHDR()
&& IsMobilePlatform(ShaderPlatform)
&& !IsPCPlatform(ShaderPlatform)) // exclude mobile emulation on PC
{
bool bSceneDepthInAlpha = (SceneContext.GetSceneColor()->GetDesc().Format == PF_FloatRGBA);
bool bOnChipDepthFetch = (GSupportsShaderDepthStencilFetch || (bSceneDepthInAlpha && GSupportsShaderFramebufferFetch));
if (!bOnChipDepthFetch)
{
// Only these features require depth texture
bool bDecals = ViewFamily.EngineShowFlags.Decals && Scene->Decals.Num();
bool bModulatedShadows = ViewFamily.EngineShowFlags.DynamicShadows && GetShadowQuality() > 0 && bModulatedShadowsInUse;
if (bDecals || bModulatedShadows)
{
// Switch target to force hardware flush current depth to texture
FTextureRHIRef DummySceneColor = GSystemTextures.BlackDummy->GetRenderTargetItem().TargetableTexture;
FTextureRHIRef DummyDepthTarget = GSystemTextures.DepthDummy->GetRenderTargetItem().TargetableTexture;
SetRenderTarget(RHICmdList, DummySceneColor, DummyDepthTarget, ESimpleRenderTargetMode::EUninitializedColorClearDepth, FExclusiveDepthStencil::DepthWrite_StencilWrite);
RHICmdList.DiscardRenderTargets(true, true, 0);
}
}
}
#endif //!PLATFORM_HTML5
}
void FForwardShadingSceneRenderer::RenderTranslucency(FRHICommandListImmediate& RHICmdList)
{
if (ShouldRenderTranslucency())
{
const bool bGammaSpace = !IsMobileHDR();
const bool bLinearHDR64 = !bGammaSpace && !IsMobileHDR32bpp();
SCOPED_DRAW_EVENT(RHICmdList, Translucency);
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
{
SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex);
const FViewInfo& View = Views[ViewIndex];
#if PLATFORM_HTML5
// Copy the view so emulation of framebuffer fetch works for alpha=depth.
// Possible optimization: this copy shouldn't be needed unless something uses fetch of depth.
if(bLinearHDR64 && GSupportsRenderTargetFormat_PF_FloatRGBA && (GSupportsShaderFramebufferFetch == false) && (!IsPCPlatform(View.GetShaderPlatform())))
{
CopySceneAlpha(RHICmdList, View);
}
#endif
if (!bGammaSpace)
{
GSceneRenderTargets.BeginRenderingTranslucency(RHICmdList, View);
}
else
{
RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
}
// Enable depth test, disable depth writes.
// Note, this is a reversed Z depth surface, using CF_GreaterEqual.
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false,CF_GreaterEqual>::GetRHI());
// Draw only translucent prims that don't read from scene color
View.TranslucentPrimSet.DrawPrimitivesForForwardShading(RHICmdList, View, *this);
// Draw the view's mesh elements with the translucent drawing policy.
DrawViewElements<FTranslucencyForwardShadingDrawingPolicyFactory>(RHICmdList, View, FTranslucencyForwardShadingDrawingPolicyFactory::ContextType(), SDPG_World, false);
// Draw the view's mesh elements with the translucent drawing policy.
DrawViewElements<FTranslucencyForwardShadingDrawingPolicyFactory>(RHICmdList, View, FTranslucencyForwardShadingDrawingPolicyFactory::ContextType(), SDPG_Foreground, false);
}
}
}
/**
* Renders the view family.
*/
void FForwardShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
{
if(!ViewFamily.EngineShowFlags.Rendering)
{
return;
}
auto FeatureLevel = ViewFamily.GetFeatureLevel();
// 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.
GSceneRenderTargets.Allocate(ViewFamily);
// Find the visible primitives.
InitViews(RHICmdList);
RenderShadowDepthMaps(RHICmdList);
// Notify the FX system that the scene is about to be rendered.
if (Scene->FXSystem)
{
Scene->FXSystem->PreRender(RHICmdList);
}
GRenderTargetPool.VisualizeTexture.OnStartFrame(Views[0]);
// Dynamic vertex and index buffers need to be committed before rendering.
FGlobalDynamicVertexBuffer::Get().Commit();
FGlobalDynamicIndexBuffer::Get().Commit();
// This might eventually be a problem with multiple views.
// Using only view 0 to check to do on-chip transform of alpha.
FViewInfo& View = Views[0];
const bool bGammaSpace = !IsMobileHDR();
const bool bRequiresUpscale = ((uint32)ViewFamily.RenderTarget->GetSizeXY().X > ViewFamily.FamilySizeX || (uint32)ViewFamily.RenderTarget->GetSizeXY().Y > ViewFamily.FamilySizeY);
const bool bRenderToScene = bRequiresUpscale || FSceneRenderer::ShouldCompositeEditorPrimitives(View);
if (bGammaSpace && !bRenderToScene)
{
SetRenderTarget(RHICmdList, ViewFamily.RenderTarget->GetRenderTargetTexture(), GSceneRenderTargets.GetSceneDepthTexture(), ESimpleRenderTargetMode::EClearToDefault);
}
else
{
// Begin rendering to scene color
GSceneRenderTargets.BeginRenderingSceneColor(RHICmdList, ESimpleRenderTargetMode::EClearToDefault);
}
if (GIsEditor)
{
RHICmdList.Clear(true, Views[0].BackgroundColor, false, 0, false, 0, FIntRect());
}
RenderForwardShadingBasePass(RHICmdList);
// Make a copy of the scene depth if the current hardware doesn't support reading and writing to the same depth buffer
GSceneRenderTargets.ResolveSceneDepthToAuxiliaryTexture(RHICmdList);
// Notify the FX system that opaque primitives have been rendered.
if (Scene->FXSystem)
{
Scene->FXSystem->PostRenderOpaque(RHICmdList);
}
// Draw translucency.
if (ViewFamily.EngineShowFlags.Translucency)
{
SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime);
// Note: Forward pass has no SeparateTranslucency, so refraction effect order with Transluency is different.
// Having the distortion applied between two different translucency passes would make it consistent with the deferred pass.
// This is not done yet.
if (ViewFamily.EngineShowFlags.Refraction)
{
// to apply refraction effect by distorting the scene color
RenderDistortion(RHICmdList);
}
RenderTranslucency(RHICmdList);
}
static const auto CVarMobileMSAA = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileMSAA"));
bool bOnChipSunMask =
GSupportsRenderTargetFormat_PF_FloatRGBA &&
GSupportsShaderFramebufferFetch &&
ViewFamily.EngineShowFlags.PostProcessing &&
((View.bLightShaftUse) || (View.FinalPostProcessSettings.DepthOfFieldScale > 0.0) ||
((ViewFamily.GetShaderPlatform() == SP_METAL) && (CVarMobileMSAA ? CVarMobileMSAA->GetValueOnAnyThread() > 1 : false))
);
if (!bGammaSpace && bOnChipSunMask)
{
// Convert alpha from depth to circle of confusion with sunshaft intensity.
// This is done before resolve on hardware with framebuffer fetch.
// This will break when PrePostSourceViewportSize is not full size.
FIntPoint PrePostSourceViewportSize = GSceneRenderTargets.GetBufferSizeXY();
FMemMark Mark(FMemStack::Get());
FRenderingCompositePassContext CompositeContext(RHICmdList, View);
FRenderingCompositePass* PostProcessSunMask = CompositeContext.Graph.RegisterPass(new(FMemStack::Get()) FRCPassPostProcessSunMaskES2(PrePostSourceViewportSize, true));
CompositeContext.Root->AddDependency(FRenderingCompositeOutputRef(PostProcessSunMask));
CompositeContext.Process(TEXT("OnChipAlphaTransform"));
}
if (!bGammaSpace || bRenderToScene)
{
// Resolve the scene color for post processing.
GSceneRenderTargets.ResolveSceneColor(RHICmdList, FResolveRect(0, 0, ViewFamily.FamilySizeX, ViewFamily.FamilySizeY));
// Drop depth and stencil before post processing to avoid export.
RHICmdList.DiscardRenderTargets(true, true, 0);
}
if (!bGammaSpace)
{
// Finish rendering for each view, or the full stereo buffer if enabled
if (ViewFamily.bResolveScene)
{
if (ViewFamily.EngineShowFlags.StereoRendering)
{
check(Views.Num() > 1);
//@todo ES2 stereo post: until we get proper stereo postprocessing for ES2, process the stereo buffer as one view
FIntPoint OriginalMax0 = Views[0].ViewRect.Max;
Views[0].ViewRect.Max = Views[1].ViewRect.Max;
GPostProcessing.ProcessES2(RHICmdList, Views[0], bOnChipSunMask);
Views[0].ViewRect.Max = OriginalMax0;
}
else
{
SCOPED_DRAW_EVENT(RHICmdList, PostProcessing);
SCOPE_CYCLE_COUNTER(STAT_FinishRenderViewTargetTime);
for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++)
{
SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex);
GPostProcessing.ProcessES2(RHICmdList, Views[ViewIndex], bOnChipSunMask);
}
}
}
}
else if (bRenderToScene)
{
BasicPostProcess(RHICmdList, View, bRequiresUpscale, FSceneRenderer::ShouldCompositeEditorPrimitives(View));
}
RenderFinish(RHICmdList);
}
void FMobileSceneRenderer::RenderDecals(FRHICommandListImmediate& RHICmdList)
{
if (Scene->Decals.Num() == 0 || !IsMobileHDR())
{
return;
}
SCOPE_CYCLE_COUNTER(STAT_DecalsDrawTime);
FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
SceneContext.BeginRenderingSceneColor(RHICmdList, ESimpleRenderTargetMode::EExistingColorAndDepth, FExclusiveDepthStencil::DepthRead_StencilRead);
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
{
const FViewInfo& View = Views[ViewIndex];
// Build a list of decals that need to be rendered for this view
FTransientDecalRenderDataList SortedDecals;
FDecalRendering::BuildVisibleDecalList(*Scene, View, DRS_Mobile, SortedDecals);
if (SortedDecals.Num())
{
SCOPED_DRAW_EVENT(RHICmdList, DeferredDecals);
INC_DWORD_STAT_BY(STAT_Decals, SortedDecals.Num());
RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1);
RHICmdList.SetStreamSource(0, GetUnitCubeVertexBuffer(), sizeof(FVector4), 0);
TOptional<EDecalBlendMode> LastDecalBlendMode;
TOptional<bool> LastDecalDepthState;
bool bEncodedHDR = IsMobileHDR32bpp() && !IsMobileHDRMosaic();
if (bEncodedHDR)
{
RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());
}
for (int32 DecalIndex = 0, DecalCount = SortedDecals.Num(); DecalIndex < DecalCount; DecalIndex++)
{
const FTransientDecalRenderData& DecalData = SortedDecals[DecalIndex];
const FDeferredDecalProxy& DecalProxy = *DecalData.DecalProxy;
const FMatrix ComponentToWorldMatrix = DecalProxy.ComponentTrans.ToMatrixWithScale();
const FMatrix FrustumComponentToClip = FDecalRendering::ComputeComponentToClipMatrix(View, ComponentToWorldMatrix);
const float ConservativeRadius = DecalData.ConservativeRadius;
const bool bInsideDecal = ((FVector)View.ViewMatrices.ViewOrigin - ComponentToWorldMatrix.GetOrigin()).SizeSquared() < FMath::Square(ConservativeRadius * 1.05f + View.NearClippingDistance * 2.0f);
if (!LastDecalDepthState.IsSet() || LastDecalDepthState.GetValue() != bInsideDecal)
{
LastDecalDepthState = bInsideDecal;
if (bInsideDecal)
{
RHICmdList.SetRasterizerState(View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI());
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_Always,
true,CF_Equal,SO_Keep,SO_Keep,SO_Keep,
false,CF_Always,SO_Keep,SO_Keep,SO_Keep,
GET_STENCIL_BIT_MASK(RECEIVE_DECAL, 1),0x00>::GetRHI(), 0);
}
else
{
RHICmdList.SetRasterizerState(View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI());
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<
false,CF_DepthNearOrEqual,
true,CF_Equal,SO_Keep,SO_Keep,SO_Keep,
false,CF_Always,SO_Keep,SO_Keep,SO_Keep,
GET_STENCIL_BIT_MASK(RECEIVE_DECAL, 1),0x00>::GetRHI(), 0);
}
}
if (!bEncodedHDR && (!LastDecalBlendMode.IsSet() || LastDecalBlendMode.GetValue() != DecalData.DecalBlendMode))
{
LastDecalBlendMode = DecalData.DecalBlendMode;
switch(DecalData.DecalBlendMode)
{
case DBM_Translucent:
RHICmdList.SetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_SourceAlpha, BF_InverseSourceAlpha>::GetRHI());
break;
case DBM_Stain:
// Modulate
RHICmdList.SetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_DestColor, BF_InverseSourceAlpha>::GetRHI());
break;
case DBM_Emissive:
// Additive
RHICmdList.SetBlendState(TStaticBlendState<CW_RGB, BO_Add, BF_SourceAlpha, BF_One>::GetRHI());
break;
default:
check(0);
};
}
// Set shader params
FDecalRendering::SetShader(RHICmdList, View, DecalData, FrustumComponentToClip);
RHICmdList.DrawIndexedPrimitive(GetUnitCubeIndexBuffer(), PT_TriangleList, 0, 0, 8, 0, ARRAY_COUNT(GCubeIndices) / 3, 1);
}
}
}
}
