CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Runtime/Renderer/Private/DecalRenderingShared.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

722 lines
29 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
/*=============================================================================
DecalRenderingShared.cpp
=============================================================================*/
#include "DecalRenderingShared.h"
#include "StaticBoundShaderState.h"
#include "Components/DecalComponent.h"
#include "GlobalShader.h"
#include "Materials/MaterialRenderProxy.h"
#include "MaterialShaderType.h"
#include "MaterialShader.h"
#include "DebugViewModeRendering.h"
#include "ScenePrivate.h"
#include "SceneProxies/DeferredDecalProxy.h"
#include "SceneProxies/SkyLightSceneProxy.h"
#include "PipelineStateCache.h"
#include "MobileBasePassRendering.h"
#include "Async/ParallelFor.h"
static TAutoConsoleVariable<float> CVarDecalFadeScreenSizeMultiplier(
TEXT("r.Decal.FadeScreenSizeMult"),
1.0f,
TEXT("Control the per decal fade screen size. Multiplies with the per-decal screen size fade threshold.")
TEXT(" Smaller means decals fade less aggressively.")
);
FVisibleDecal::FVisibleDecal(const FDeferredDecalProxy& InDecalProxy, float InConservativeRadius, float InFadeAlpha, EShaderPlatform ShaderPlatform, ERHIFeatureLevel::Type FeatureLevel)
: MaterialProxy(InDecalProxy.DecalMaterial->GetRenderProxy())
, Component((uintptr_t)InDecalProxy.Component)
, SortOrder(InDecalProxy.SortOrder)
, ConservativeRadius(InConservativeRadius)
, FadeAlpha(InFadeAlpha)
, InvFadeDuration(InDecalProxy.InvFadeDuration)
, InvFadeInDuration(InDecalProxy.InvFadeInDuration)
, FadeStartDelayNormalized(InDecalProxy.FadeStartDelayNormalized)
, FadeInStartDelayNormalized(InDecalProxy.FadeInStartDelayNormalized)
, DecalColor(InDecalProxy.DecalColor)
, ComponentTrans(InDecalProxy.ComponentTrans)
, BoxBounds(InDecalProxy.GetBounds().GetBox())
{
// Build BlendDesc from a potentially incomplete material.
// If our shader isn't compiled yet then we will potentially render later with a different fallback material.
FMaterial const& MaterialResource = MaterialProxy->GetIncompleteMaterialWithFallback(FeatureLevel);
BlendDesc = DecalRendering::ComputeDecalBlendDesc(ShaderPlatform, MaterialResource);
}
FDecalVisibilityTaskData* FDecalVisibilityTaskData::Launch(FRDGBuilder& GraphBuilder, const FScene& Scene, TConstArrayView<FViewInfo> Views)
{
const FSceneViewFamily& ViewFamily = *Views[0].Family;
if (AreDecalsEnabled(ViewFamily) && !HasRayTracedOverlay(ViewFamily))
{
const bool bDBufferEnabled = ::IsDBufferEnabled(ViewFamily, ViewFamily.GetShaderPlatform());
const bool bGBufferEnabled = IsUsingGBuffers(ViewFamily.GetShaderPlatform());
return GraphBuilder.AllocObject<FDecalVisibilityTaskData>(Scene, Views, bDBufferEnabled, bGBufferEnabled);
}
return nullptr;
}
FDecalVisibilityTaskData::FDecalVisibilityTaskData(const FScene& Scene, TConstArrayView<FViewInfo> Views, bool bInDBufferEnabled, bool bInGBufferEnabled)
: bDBufferEnabled(bInDBufferEnabled)
, bGBufferEnabled(bInGBufferEnabled)
{
ViewPackets.Reserve(Views.Num());
for (const FViewInfo& View : Views)
{
ViewPackets.Emplace(*this, Scene, View);
}
}
FDecalVisibilityViewPacket::FDecalVisibilityViewPacket(const FDecalVisibilityTaskData& InTaskData, const FScene& Scene, const FViewInfo& InView)
: TaskData(InTaskData)
, View(InView)
{
RelevantDecalsMap.Reserve((int32)EDecalRenderStage::Num);
VisibleDecals.Task = LaunchSceneRenderTask(TEXT("BuildVisibleDecalList"), [&OutputList = VisibleDecals.List, &InputList = Scene.Decals, &View = View]
{
OutputList = DecalRendering::BuildVisibleDecalList(InputList, View);
});
AllTasksEvent.AddPrerequisites(VisibleDecals.Task);
const auto LaunchRelevantDecalTask = [this] (EDecalRenderStage Stage)
{
FRelevantDecals& RelevantDecals = RelevantDecalsMap.Emplace(Stage);
RelevantDecals.Task = LaunchSceneRenderTask(TEXT("BuildRelevantDecalList"), [&OutputList = RelevantDecals.List, &InputList = VisibleDecals.List, Stage]
{
OutputList = DecalRendering::BuildRelevantDecalList(InputList, Stage);
}, VisibleDecals.Task);
AllTasksEvent.AddPrerequisites(RelevantDecals.Task);
};
// DBuffer Passes
if (TaskData.bDBufferEnabled)
{
LaunchRelevantDecalTask(EDecalRenderStage::BeforeBasePass);
LaunchRelevantDecalTask(EDecalRenderStage::Emissive);
}
// GBuffer Passes
else if (TaskData.bGBufferEnabled)
{
LaunchRelevantDecalTask(EDecalRenderStage::BeforeLighting);
}
// AmbientOcclusion Pass gets built on-demand, since we don't know if it will be enabled until later in the pipeline.
}
TConstArrayView<FVisibleDecal> FDecalVisibilityViewPacket::FinishVisibleDecals()
{
check(IsInRenderingThread());
if (VisibleDecals.Task.IsValid())
{
VisibleDecals.Task.Wait();
VisibleDecals.Task = {};
}
return VisibleDecals.List;
}
TConstArrayView<const FVisibleDecal*> FDecalVisibilityViewPacket::FinishRelevantDecals(EDecalRenderStage Stage)
{
check(IsInRenderingThread());
FRelevantDecals* RelevantDecals = RelevantDecalsMap.Find(Stage);
if (RelevantDecals)
{
if (RelevantDecals->Task.IsValid())
{
RelevantDecals->Task.Wait();
RelevantDecals->Task = {};
}
}
else
{
// Wasn't requested as a task. Build on-demand.
RelevantDecals = &RelevantDecalsMap.Emplace(Stage);
RelevantDecals->List = DecalRendering::BuildRelevantDecalList(FinishVisibleDecals(), Stage);
}
return RelevantDecals->List;
}
/**
* A vertex shader for projecting a deferred decal onto the scene.
*/
class FDeferredDecalVS : public FGlobalShader
{
DECLARE_GLOBAL_SHADER(FDeferredDecalVS);
SHADER_USE_PARAMETER_STRUCT(FDeferredDecalVS, FGlobalShader);
BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
SHADER_PARAMETER_STRUCT_INCLUDE(FViewShaderParameters, View)
SHADER_PARAMETER(FMatrix44f, FrustumComponentToClip)
SHADER_PARAMETER_STRUCT_REF(FPrimitiveUniformShaderParameters, PrimitiveUniformBuffer)
END_SHADER_PARAMETER_STRUCT()
};
IMPLEMENT_GLOBAL_SHADER(FDeferredDecalVS, "/Engine/Private/DeferredDecal.usf", "MainVS" ,SF_Vertex);
/**
* A pixel shader for projecting a deferred decal onto the scene.
*/
class FDeferredDecalPS : public FMaterialShader
{
DECLARE_SHADER_TYPE(FDeferredDecalPS,Material);
public:
static bool ShouldCompilePermutation(const FMaterialShaderPermutationParameters& Parameters)
{
return (Parameters.MaterialParameters.MaterialDomain == MD_DeferredDecal) &&
DecalRendering::GetBaseRenderStage(DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters)) != EDecalRenderStage::None;
}
static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
{
FMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
DecalRendering::ModifyCompilationEnvironment(Parameters.Platform, DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::None, OutEnvironment);
}
FDeferredDecalPS() {}
FDeferredDecalPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
: FMaterialShader(Initializer)
{
DecalPositionHigh.Bind(Initializer.ParameterMap, TEXT("DecalPositionHigh"));
SvPositionToDecal.Bind(Initializer.ParameterMap,TEXT("SvPositionToDecal"));
RightEyeSvPositionToDecal.Bind(Initializer.ParameterMap, TEXT("RightEyeSvPositionToDecal"));
DecalToWorld.Bind(Initializer.ParameterMap,TEXT("DecalToWorld"));
DecalToWorldInvScale.Bind(Initializer.ParameterMap, TEXT("DecalToWorldInvScale"));
DecalOrientation.Bind(Initializer.ParameterMap,TEXT("DecalOrientation"));
DecalParams.Bind(Initializer.ParameterMap, TEXT("DecalParams"));
DecalColorParam.Bind(Initializer.ParameterMap, TEXT("DecalColorParam"));
MobileBasePassUniformBuffer.Bind(Initializer.ParameterMap, FMobileBasePassUniformParameters::FTypeInfo::GetStructMetadata()->GetShaderVariableName());
MobileDirectionLightBufferParam.Bind(Initializer.ParameterMap, FMobileDirectionalLightShaderParameters::FTypeInfo::GetStructMetadata()->GetShaderVariableName());
MobileReflectionCaptureParam.Bind(Initializer.ParameterMap, FMobileReflectionCaptureShaderParameters::FTypeInfo::GetStructMetadata()->GetShaderVariableName());
}
void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FViewInfo& View, const FVisibleDecal& VisibleDecal, const FMaterialRenderProxy* MaterialProxy, const FMaterial* MaterialResource, const float FadeAlphaValue = 1.0f, const FScene* Scene = nullptr)
{
auto& PrimitivePS = GetUniformBufferParameter<FPrimitiveUniformShaderParameters>();
SetUniformBufferParameter(BatchedParameters, PrimitivePS, GIdentityPrimitiveUniformBuffer);
FMaterialShader::SetParameters(BatchedParameters, MaterialProxy, *MaterialResource, View);
const FMatrix DecalToWorldMatrix = VisibleDecal.ComponentTrans.ToMatrixWithScale();
const FMatrix WorldToDecalMatrix = VisibleDecal.ComponentTrans.ToInverseMatrixWithScale();
const FDFVector3 AbsoluteOrigin(DecalToWorldMatrix.GetOrigin());
const FVector3f PositionHigh = AbsoluteOrigin.High;
const FMatrix44f RelativeDecalToWorldMatrix = FDFMatrix::MakeToRelativeWorldMatrix(PositionHigh, DecalToWorldMatrix).M;
const FVector3f OrientationVector = (FVector3f)VisibleDecal.ComponentTrans.GetUnitAxis(EAxis::X);
if (DecalPositionHigh.IsBound())
{
SetShaderValue(BatchedParameters, DecalPositionHigh, PositionHigh);
}
if(SvPositionToDecal.IsBound())
{
FVector2D InvViewSize = FVector2D(1.0f / View.ViewRect.Width(), 1.0f / View.ViewRect.Height());
// setup a matrix to transform float4(SvPosition.xyz,1) directly to Decal (quality, performance as we don't need to convert or use interpolator)
// new_xy = (xy - ViewRectMin.xy) * ViewSizeAndInvSize.zw * float2(2,-2) + float2(-1, 1);
// transformed into one MAD: new_xy = xy * ViewSizeAndInvSize.zw * float2(2,-2) + (-ViewRectMin.xy) * ViewSizeAndInvSize.zw * float2(2,-2) + float2(-1, 1);
float Mx = 2.0f * InvViewSize.X;
float My = -2.0f * InvViewSize.Y;
float Ax = -1.0f - 2.0f * View.ViewRect.Min.X * InvViewSize.X;
float Ay = 1.0f + 2.0f * View.ViewRect.Min.Y * InvViewSize.Y;
const FMatrix SvPositionToDecalBase(
FPlane(Mx, 0, 0, 0),
FPlane(0, My, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(Ax, Ay, 0, 1)
);
// todo: we could use InvTranslatedViewProjectionMatrix and TranslatedWorldToComponent for better quality
FMatrix44f SvPositionToDecalValue = FMatrix44f( // LWC_TODO: Precision loss
SvPositionToDecalBase * View.ViewMatrices.GetInvViewProjectionMatrix() * WorldToDecalMatrix);
SetShaderValue(BatchedParameters, SvPositionToDecal, SvPositionToDecalValue);
if (RightEyeSvPositionToDecal.IsBound())
{
const FViewInfo* InstancedView = View.GetInstancedView();
if (InstancedView)
{
FMatrix44f RightEyeSvPositionToDecalValue = FMatrix44f( // LWC_TODO: Precision loss
SvPositionToDecalBase * InstancedView->ViewMatrices.GetInvViewProjectionMatrix() * WorldToDecalMatrix);
SetShaderValue(BatchedParameters, RightEyeSvPositionToDecal, RightEyeSvPositionToDecalValue);
}
}
}
if(DecalToWorld.IsBound())
{
SetShaderValue(BatchedParameters, DecalToWorld, RelativeDecalToWorldMatrix);
}
if (DecalToWorldInvScale.IsBound())
{
SetShaderValue(BatchedParameters, DecalToWorldInvScale, static_cast<FVector3f>(DecalToWorldMatrix.GetScaleVector().Reciprocal()));
}
if (DecalOrientation.IsBound())
{
SetShaderValue(BatchedParameters, DecalOrientation, OrientationVector);
}
float LifetimeAlpha = 1.0f;
// Certain engine captures (e.g. environment reflection) don't have a tick. Default to fully opaque.
if (View.Family->Time.GetWorldTimeSeconds())
{
LifetimeAlpha = FMath::Clamp(FMath::Min(View.Family->Time.GetWorldTimeSeconds() * -VisibleDecal.InvFadeDuration + VisibleDecal.FadeStartDelayNormalized, View.Family->Time.GetWorldTimeSeconds() * VisibleDecal.InvFadeInDuration + VisibleDecal.FadeInStartDelayNormalized), 0.0f, 1.0f);
}
SetShaderValue(BatchedParameters, DecalParams, FVector2f(FadeAlphaValue, LifetimeAlpha));
SetShaderValue(BatchedParameters, DecalColorParam, VisibleDecal.DecalColor);
if (MobileDirectionLightBufferParam.IsBound() && Scene)
{
const int UniformBufferIndex = FMath::Clamp(FReadOnlyCVARCache::MobileForwardDecalLighting(), 1, 3);
SetUniformBufferParameter(BatchedParameters, MobileDirectionLightBufferParam, Scene->UniformBuffers.MobileDirectionalLightUniformBuffers[UniformBufferIndex]);
}
if (MobileReflectionCaptureParam.IsBound())
{
if (Scene &&
(
(Scene->SkyLight && Scene->SkyLight->ProcessedTexture && Scene->SkyLight->ProcessedTexture->TextureRHI)
|| Scene->CanSampleSkyLightRealTimeCaptureData()
))
{
SetUniformBufferParameter(BatchedParameters, MobileReflectionCaptureParam, Scene->UniformBuffers.MobileSkyReflectionUniformBuffer);
}
else
{
SetUniformBufferParameter(BatchedParameters, MobileReflectionCaptureParam, GDefaultMobileReflectionCaptureUniformBuffer.GetUniformBufferRHI());
}
}
}
private:
LAYOUT_FIELD(FShaderParameter, SvPositionToDecal);
LAYOUT_FIELD(FShaderParameter, RightEyeSvPositionToDecal);
LAYOUT_FIELD(FShaderParameter, DecalPositionHigh);
LAYOUT_FIELD(FShaderParameter, DecalToWorld);
LAYOUT_FIELD(FShaderParameter, DecalToWorldInvScale);
LAYOUT_FIELD(FShaderParameter, DecalOrientation);
LAYOUT_FIELD(FShaderParameter, DecalParams);
LAYOUT_FIELD(FShaderParameter, DecalColorParam);
LAYOUT_FIELD(FShaderUniformBufferParameter, MobileBasePassUniformBuffer);
LAYOUT_FIELD(FShaderUniformBufferParameter, MobileDirectionLightBufferParam);
LAYOUT_FIELD(FShaderUniformBufferParameter, MobileReflectionCaptureParam);
};
IMPLEMENT_MATERIAL_SHADER_TYPE(,FDeferredDecalPS,TEXT("/Engine/Private/DeferredDecal.usf"),TEXT("MainPS"),SF_Pixel);
class FDeferredDecalEmissivePS : public FDeferredDecalPS
{
DECLARE_SHADER_TYPE(FDeferredDecalEmissivePS, Material);
public:
static bool ShouldCompilePermutation(const FMaterialShaderPermutationParameters& Parameters)
{
return (Parameters.MaterialParameters.MaterialDomain == MD_DeferredDecal) &&
DecalRendering::IsCompatibleWithRenderStage(DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::Emissive);
}
static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
{
FMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
DecalRendering::ModifyCompilationEnvironment(Parameters.Platform, DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::Emissive, OutEnvironment);
}
FDeferredDecalEmissivePS() {}
FDeferredDecalEmissivePS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
: FDeferredDecalPS(Initializer)
{}
};
IMPLEMENT_MATERIAL_SHADER_TYPE(, FDeferredDecalEmissivePS, TEXT("/Engine/Private/DeferredDecal.usf"), TEXT("MainPS"), SF_Pixel);
class FDeferredDecalAmbientOcclusionPS : public FDeferredDecalPS
{
DECLARE_SHADER_TYPE(FDeferredDecalAmbientOcclusionPS, Material);
public:
static bool ShouldCompilePermutation(const FMaterialShaderPermutationParameters& Parameters)
{
return (Parameters.MaterialParameters.MaterialDomain == MD_DeferredDecal) &&
DecalRendering::IsCompatibleWithRenderStage(DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::AmbientOcclusion);
}
static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
{
FMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
DecalRendering::ModifyCompilationEnvironment(Parameters.Platform, DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::AmbientOcclusion, OutEnvironment);
}
FDeferredDecalAmbientOcclusionPS() {}
FDeferredDecalAmbientOcclusionPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
: FDeferredDecalPS(Initializer)
{}
};
IMPLEMENT_MATERIAL_SHADER_TYPE(, FDeferredDecalAmbientOcclusionPS, TEXT("/Engine/Private/DeferredDecal.usf"), TEXT("MainPS"), SF_Pixel);
class FDeferredDecalMobilePS : public FDeferredDecalPS
{
DECLARE_SHADER_TYPE(FDeferredDecalMobilePS, Material);
public:
static bool ShouldCompilePermutation(const FMaterialShaderPermutationParameters& Parameters)
{
return (Parameters.MaterialParameters.MaterialDomain == MD_DeferredDecal) &&
DecalRendering::IsCompatibleWithRenderStage(DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::Mobile);
}
static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
{
FMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
DecalRendering::ModifyCompilationEnvironment(Parameters.Platform, DecalRendering::ComputeDecalBlendDesc(Parameters.Platform, Parameters.MaterialParameters), EDecalRenderStage::Mobile, OutEnvironment);
OutEnvironment.SetDefine(TEXT("DECAL_MOBILE_FORWARD_LIT"), FReadOnlyCVARCache::MobileForwardDecalLighting() != 0 ? 1u : 0u);
}
FDeferredDecalMobilePS() {}
FDeferredDecalMobilePS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
: FDeferredDecalPS(Initializer)
{}
};
IMPLEMENT_MATERIAL_SHADER_TYPE(, FDeferredDecalMobilePS, TEXT("/Engine/Private/DeferredDecal.usf"), TEXT("MainPS"), SF_Pixel);
namespace DecalRendering
{
float GetDecalFadeScreenSizeMultiplier()
{
return CVarDecalFadeScreenSizeMultiplier.GetValueOnRenderThread();
}
float CalculateDecalFadeAlpha(float DecalFadeScreenSize, const FMatrix& ComponentToWorldMatrix, const FViewInfo& View, float FadeMultiplier)
{
check(View.IsPerspectiveProjection());
float Distance = (View.ViewMatrices.GetViewOrigin() - ComponentToWorldMatrix.GetOrigin()).Size();
float Radius = ComponentToWorldMatrix.GetMaximumAxisScale();
float CurrentScreenSize = ((Radius / Distance) * FadeMultiplier);
// fading coefficient needs to increase with increasing field of view and decrease with increasing resolution
// FadeCoeffScale is an empirically determined constant to bring us back roughly to fraction of screen size for FadeScreenSize
const float FadeCoeffScale = 600.0f;
float FOVFactor = ((2.0f / View.ViewMatrices.GetProjectionMatrix().M[0][0]) / View.ViewRect.Width()) * FadeCoeffScale;
float FadeCoeff = DecalFadeScreenSize * FOVFactor;
float FadeRange = FadeCoeff * 0.5f;
float Alpha = (CurrentScreenSize - FadeCoeff) / FadeRange;
return FMath::Clamp(Alpha, 0.0f, 1.0f);
}
void SortDecalList(FRelevantDecalList& Decals)
{
Decals.Sort([](const FVisibleDecal& A, const FVisibleDecal& B)
{
// Sort by sort order to allow control over composited result
if (B.SortOrder != A.SortOrder)
{
return A.SortOrder < B.SortOrder;
}
// Then sort decals by state to reduce render target switches
if (B.BlendDesc.bWriteNormal != A.BlendDesc.bWriteNormal)
{
// bWriteNormal here has priority because we want to render decals that output normals before those could read normals.
// Also this is the only flag that can trigger a change of EDecalRenderTargetMode inside a single EDecalRenderStage, and we batch according to this.
return B.BlendDesc.bWriteNormal < A.BlendDesc.bWriteNormal; // < so that those outputting normal are first.
}
// Sort decals by blend mode to reduce render target switches
if (B.BlendDesc.Packed != A.BlendDesc.Packed)
{
// Sorting by the FDecalBlendDesc contents will reduce blend state changes.
return (int32)B.BlendDesc.Packed < (int32)A.BlendDesc.Packed;
}
if (B.MaterialProxy != A.MaterialProxy)
{
// Batch decals with the same material together
return B.MaterialProxy < A.MaterialProxy;
}
// Also sort by component since Sort() is not stable
return B.Component < A.Component;
});
}
FVisibleDecalList BuildVisibleDecalList(TConstArrayView<FDeferredDecalProxy*> Decals, const FViewInfo& View)
{
TRACE_CPUPROFILER_EVENT_SCOPE(BuildVisibleDecalList);
// Don't draw for shader complexity mode.
// todo: Handle shader complexity mode for deferred decal.
if (Decals.IsEmpty() || View.Family->EngineShowFlags.ShaderComplexity)
{
return {};
}
FVisibleDecalList VisibleDecals;
VisibleDecals.Reserve(Decals.Num());
const float FadeMultiplier = GetDecalFadeScreenSizeMultiplier();
const EShaderPlatform ShaderPlatform = View.GetShaderPlatform();
const bool bIsPerspectiveProjection = View.IsPerspectiveProjection();
for (const FDeferredDecalProxy* DecalProxy : Decals)
{
if (!DecalProxy->DecalMaterial || !DecalProxy->DecalMaterial->IsValidLowLevelFast())
{
continue;
}
if (!DecalProxy->IsShown(&View))
{
continue;
}
const FMatrix ComponentToWorldMatrix = DecalProxy->ComponentTrans.ToMatrixWithScale();
// can be optimized as we test against a sphere around the box instead of the box itself
const float ConservativeRadius = FMath::Sqrt(
ComponentToWorldMatrix.GetScaledAxis(EAxis::X).SizeSquared() +
ComponentToWorldMatrix.GetScaledAxis(EAxis::Y).SizeSquared() +
ComponentToWorldMatrix.GetScaledAxis(EAxis::Z).SizeSquared());
const bool bIsVisibleInFirstView = View.ViewFrustum.IntersectSphere(ComponentToWorldMatrix.GetOrigin(), ConservativeRadius);
const FViewInfo* InstancedView = View.GetInstancedView();
const bool bIsVisibleInSecondView = InstancedView ? InstancedView->ViewFrustum.IntersectSphere(ComponentToWorldMatrix.GetOrigin(), ConservativeRadius) : false;
// can be optimized as the test is too conservative (sphere instead of OBB)
if (ConservativeRadius < SMALL_NUMBER || !(bIsVisibleInFirstView || bIsVisibleInSecondView))
{
continue;
}
float FadeAlpha = 1.0f;
if (bIsPerspectiveProjection && DecalProxy->FadeScreenSize != 0.0f)
{
FadeAlpha = CalculateDecalFadeAlpha(DecalProxy->FadeScreenSize, ComponentToWorldMatrix, View, FadeMultiplier);
}
const bool bShouldRender = FadeAlpha > 0.0f;
if (!bShouldRender)
{
continue;
}
VisibleDecals.Emplace(*DecalProxy, ConservativeRadius, FadeAlpha, ShaderPlatform, View.GetFeatureLevel());
}
return VisibleDecals;
}
FRelevantDecalList BuildRelevantDecalList(TConstArrayView<FVisibleDecal> Decals, EDecalRenderStage DecalRenderStage)
{
TRACE_CPUPROFILER_EVENT_SCOPE(BuildRelevantDecalList);
FRelevantDecalList RelevantDecals;
RelevantDecals.Reserve(Decals.Num());
for (const FVisibleDecal& VisibleDecal : Decals)
{
if (IsCompatibleWithRenderStage(VisibleDecal.BlendDesc, DecalRenderStage))
{
RelevantDecals.Emplace(&VisibleDecal);
}
}
SortDecalList(RelevantDecals);
return RelevantDecals;
}
bool HasRelevantDecals(TConstArrayView<FVisibleDecal> Decals, EDecalRenderStage DecalRenderStage)
{
TRACE_CPUPROFILER_EVENT_SCOPE(HasRelevantDecals);
for (const FVisibleDecal& VisibleDecal : Decals)
{
if (IsCompatibleWithRenderStage(VisibleDecal.BlendDesc, DecalRenderStage))
{
return true;
}
}
return false;
}
FMatrix ComputeComponentToClipMatrix(const FViewInfo& View, const FMatrix& DecalComponentToWorld)
{
if (View.bIsMobileMultiViewEnabled || View.Aspects.IsMobileMultiViewEnabled())
{
// In multi view, the rest of the matrix that is multiplied with DecalComponentToWorld in the non-multi view
// case is split out in ViewUniformShaderParameters.MobileMultiviewDecalTransform so we can multiply
// it later in the shader.
return DecalComponentToWorld;
}
else
{
FMatrix ComponentToWorldMatrixTrans = DecalComponentToWorld.ConcatTranslation(View.ViewMatrices.GetPreViewTranslation());
return ComponentToWorldMatrixTrans * View.ViewMatrices.GetTranslatedViewProjectionMatrix();
}
}
bool TryGetDeferredDecalShaders(
FMaterial const& Material,
ERHIFeatureLevel::Type FeatureLevel,
EDecalRenderStage DecalRenderStage,
TShaderRef<FDeferredDecalPS>& OutPixelShader)
{
FMaterialShaderTypes ShaderTypes;
if (DecalRenderStage == EDecalRenderStage::Emissive)
{
ShaderTypes.AddShaderType<FDeferredDecalEmissivePS>();
}
else if (DecalRenderStage == EDecalRenderStage::AmbientOcclusion)
{
ShaderTypes.AddShaderType<FDeferredDecalAmbientOcclusionPS>();
}
else if (DecalRenderStage == EDecalRenderStage::Mobile)
{
ShaderTypes.AddShaderType<FDeferredDecalMobilePS>();
}
else
{
ShaderTypes.AddShaderType<FDeferredDecalPS>();
}
FMaterialShaders Shaders;
if (!Material.TryGetShaders(ShaderTypes, nullptr, Shaders))
{
return false;
}
Shaders.TryGetPixelShader(OutPixelShader);
return OutPixelShader.IsValid();
}
bool GetShaders(ERHIFeatureLevel::Type FeatureLevel,
const FMaterial& Material,
EDecalRenderStage DecalRenderStage,
TShaderRef<FShader>& OutVertexShader,
TShaderRef<FShader>& OutPixelShader)
{
TShaderRef<FDeferredDecalPS> PixelShader;
if (!TryGetDeferredDecalShaders(Material, FeatureLevel, DecalRenderStage, PixelShader))
{
return false;
}
TShaderMapRef<FDeferredDecalVS> VertexShader(GetGlobalShaderMap(FeatureLevel));
OutVertexShader = VertexShader;
OutPixelShader = PixelShader;
return true;
}
bool SetupShaderState(
ERHIFeatureLevel::Type FeatureLevel,
const FMaterial& Material,
EDecalRenderStage DecalRenderStage,
FBoundShaderStateInput& OutBoundShaderState)
{
TShaderRef<FShader> VertexShader;
TShaderRef<FShader> PixelShader;
if (!GetShaders( FeatureLevel, Material, DecalRenderStage, VertexShader, PixelShader))
{
return false;
}
OutBoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
OutBoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
OutBoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
return true;
}
FMaterialRenderProxy const* TryGetDeferredDecalMaterial(
FMaterialRenderProxy const* MaterialProxy,
ERHIFeatureLevel::Type FeatureLevel,
EDecalRenderStage DecalRenderStage,
FMaterial const*& OutMaterialResource,
TShaderRef<FDeferredDecalPS>& OutPixelShader)
{
OutMaterialResource = nullptr;
while (MaterialProxy != nullptr)
{
OutMaterialResource = MaterialProxy->GetMaterialNoFallback(FeatureLevel);
if (OutMaterialResource != nullptr)
{
if (TryGetDeferredDecalShaders(*OutMaterialResource, FeatureLevel, DecalRenderStage, OutPixelShader))
{
break;
}
}
MaterialProxy = MaterialProxy->GetFallback(FeatureLevel);
}
return MaterialProxy;
}
void SetShader(FRHICommandList& RHICmdList, FGraphicsPipelineStateInitializer& GraphicsPSOInit, uint32 StencilRef, const FViewInfo& View,
const FVisibleDecal& VisibleDecal, EDecalRenderStage DecalRenderStage, const FMatrix& FrustumComponentToClip, const FScene* Scene)
{
FMaterial const* MaterialResource = nullptr;
TShaderRef<FDeferredDecalPS> PixelShader;
FMaterialRenderProxy const* MaterialProxy = TryGetDeferredDecalMaterial(VisibleDecal.MaterialProxy, View.GetFeatureLevel(), DecalRenderStage, MaterialResource, PixelShader);
TShaderMapRef<FDeferredDecalVS> VertexShader(View.ShaderMap);
GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
GraphicsPSOInit.PrimitiveType = PT_TriangleList;
SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit, StencilRef);
// Set vertex shader parameters.
{
FDeferredDecalVS::FParameters ShaderParameters;
ShaderParameters.FrustumComponentToClip = FMatrix44f(FrustumComponentToClip); // LWC_TODO: Precision loss?
ShaderParameters.PrimitiveUniformBuffer = GIdentityPrimitiveUniformBuffer.GetUniformBufferRef();
ShaderParameters.View = View.GetShaderParameters();
SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), ShaderParameters);
}
// Set pixel shader parameters.
{
SetShaderParametersLegacyPS(RHICmdList, PixelShader, View, VisibleDecal, MaterialProxy, MaterialResource, VisibleDecal.FadeAlpha, Scene);
}
// Set stream source after updating cached strides
RHICmdList.SetStreamSource(0, GetUnitCubeVertexBuffer(), 0);
}
void SetVertexShaderOnly(FRHICommandList& RHICmdList, FGraphicsPipelineStateInitializer& GraphicsPSOInit, const FViewInfo& View, const FMatrix& FrustumComponentToClip)
{
TShaderMapRef<FDeferredDecalVS> VertexShader(View.ShaderMap);
GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
GraphicsPSOInit.PrimitiveType = PT_TriangleList;
SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit, 0);
// Set vertex shader parameters.
{
FDeferredDecalVS::FParameters ShaderParameters;
ShaderParameters.FrustumComponentToClip = FMatrix44f(FrustumComponentToClip); // LWC_TODO: Precision loss
ShaderParameters.PrimitiveUniformBuffer = GIdentityPrimitiveUniformBuffer.GetUniformBufferRef();
ShaderParameters.View = View.GetShaderParameters();
SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), ShaderParameters);
}
}
}
Reference in New Issue View Git Blame Copy Permalink