Ivan Anikin
610 lines
19 KiB
C++
610 lines
19 KiB
C++
// VRM4U Copyright (c) 2021-2024 Haruyoshi Yamamoto. This software is released under the MIT License.
|
|
|
|
#include "VrmSceneViewExtension.h"
|
|
#include "VrmExtensionRimFilterData.h"
|
|
#include "Misc/EngineVersionComparison.h"
|
|
#include "Runtime/Renderer/Private/SceneRendering.h"
|
|
#include "TextureResource.h"
|
|
|
|
#include "VRM4U_RenderSubsystem.h"
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,2,0)
|
|
#else
|
|
#include "DataDrivenShaderPlatformInfo.h"
|
|
#include "SystemTextures.h"
|
|
#endif
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,3,0)
|
|
#include "PostProcess/PostProcessing.h"
|
|
#include "PostProcess/PostProcessMaterial.h"
|
|
#else
|
|
#include "PostProcess/PostProcessMaterialInputs.h"
|
|
#endif
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,4,0)
|
|
#include "Runtime/Renderer/Private/SceneTextures.h"
|
|
#endif
|
|
|
|
|
|
#include "ScreenPass.h"
|
|
#include "ShaderParameterUtils.h"
|
|
|
|
|
|
#include "GlobalShader.h"
|
|
#include "ShaderParameterStruct.h"
|
|
|
|
#include "RenderGraphEvent.h"
|
|
#include "RenderGraphBuilder.h"
|
|
#include "ProfilingDebugging/CpuProfilerTrace.h"
|
|
#include "Stats/Stats.h"
|
|
#include "DynamicRHI.h"
|
|
|
|
DECLARE_GPU_STAT(VRM4U);
|
|
|
|
|
|
class FMyComputeShader : public FGlobalShader
|
|
{
|
|
|
|
DECLARE_GLOBAL_SHADER(FMyComputeShader);
|
|
SHADER_USE_PARAMETER_STRUCT(FMyComputeShader, FGlobalShader);
|
|
|
|
BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
|
|
SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D<float4>, SceneColorTexture)
|
|
SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D<float4>, BaseColorTexture)
|
|
|
|
SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D, NormalTexture)
|
|
|
|
SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D<float>, SceneDepthTexture)
|
|
//SHADER_PARAMETER_RDG_TEXTURE(Texture2D, CustomDepthTexture)
|
|
SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D<float4>, CustomDepthTexture)
|
|
SHADER_PARAMETER_RDG_TEXTURE_SRV(Texture2D<uint2>, CustomStencilTexture)
|
|
//SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FSceneTextureUniformParameters, SceneTextures)
|
|
|
|
//SHADER_PARAMETER_RDG_TEXTURE(Texture2D, SceneDepthTexture) // 深度
|
|
//SHADER_PARAMETER_SAMPLER(SamplerState, DepthSampler)
|
|
|
|
//SHADER_PARAMETER_RDG_TEXTURE(Texture2D, SceneColorTexture) // カラー
|
|
//SHADER_PARAMETER_SAMPLER(SamplerState, ColorSampler)
|
|
|
|
SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
|
|
|
|
|
|
SHADER_PARAMETER(FVector3f, CameraPosition)
|
|
SHADER_PARAMETER(FVector3f, CameraForwardVector)
|
|
|
|
SHADER_PARAMETER(float, UseCustomLightPosition)
|
|
SHADER_PARAMETER(float, UseCustomLightColor)
|
|
SHADER_PARAMETER(FVector3f, LightPosition)
|
|
SHADER_PARAMETER(FVector3f, LightDirection)
|
|
SHADER_PARAMETER(FVector3f, LightColor)
|
|
SHADER_PARAMETER(float, LightScale)
|
|
SHADER_PARAMETER(float, RimEdgeFade)
|
|
|
|
SHADER_PARAMETER(float, UseBinaryEdge)
|
|
SHADER_PARAMETER(float, RimEdgeBinaryRange)
|
|
|
|
SHADER_PARAMETER(float, SampleScreenScale)
|
|
SHADER_PARAMETER(float, SampleScale)
|
|
|
|
SHADER_PARAMETER(int, CustomStencilMask)
|
|
|
|
//RENDER_TARGET_BINDING_SLOTS()
|
|
END_SHADER_PARAMETER_STRUCT()
|
|
|
|
public:
|
|
static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
|
|
{
|
|
return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
|
|
}
|
|
};
|
|
|
|
/*
|
|
BEGIN_SHADER_PARAMETER_STRUCT(FMyComputeShaderParameters, )
|
|
SHADER_PARAMETER_RDG_TEXTURE_UAV(RWTexture2D<float4>, SceneColorTexture)
|
|
//RENDER_TARGET_BINDING_SLOTS()
|
|
END_SHADER_PARAMETER_STRUCT()
|
|
*/
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,2,0)
|
|
#else
|
|
IMPLEMENT_GLOBAL_SHADER(FMyComputeShader, "/VRM4UShaders/private/BaseColorCS.usf", "MainCS", SF_Compute);
|
|
#endif
|
|
|
|
|
|
static bool LocalCSEnable()
|
|
{
|
|
|
|
static const auto CVarCustomDepth = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.CustomDepth"));
|
|
const int32 EnabledWithStencil = 3;// CustomDepthMode::EnabledWithStencil ではダメ。
|
|
if (CVarCustomDepth) {
|
|
if (CVarCustomDepth->GetValueOnAnyThread() != EnabledWithStencil) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM6) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void LocalCopyFilter(FRDGBuilder& GraphBuilder, FSceneView& InView, const FRenderTargetBindingSlots& RenderTargets, TRDGUniformBufferRef<FSceneTextureUniformParameters>& SceneTextures) {
|
|
#if UE_VERSION_OLDER_THAN(5,4,0)
|
|
#else
|
|
FScreenPassViewInfo ViewInfo(InView);
|
|
#endif
|
|
|
|
// copy枚数
|
|
const int copyNum = 4;
|
|
|
|
FRDGTextureDesc CopyDesc[copyNum] = {};
|
|
FRDGTextureRef CopyTexture[copyNum] = {};
|
|
FRDGTextureRef CopyTextureDepth[copyNum] = {};
|
|
|
|
{
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,5,0)
|
|
#else
|
|
{
|
|
// depth copy
|
|
RDG_EVENT_SCOPE_STAT(GraphBuilder, VRM4U, "VRM4U::Copy2");
|
|
|
|
FRDGTextureRef SourceTexture = SceneTextures->GetParameters()->SceneDepthTexture;
|
|
if (!SourceTexture) return;
|
|
|
|
for (int i = 0; i < copyNum; ++i) {
|
|
CopyDesc[i] = SourceTexture->Desc;
|
|
if (i == 0) {
|
|
}
|
|
else {
|
|
CopyDesc[i].Extent = CopyDesc[i - 1].Extent / 2;
|
|
}
|
|
CopyDesc[i].Flags |= TexCreate_RenderTargetable | TexCreate_UAV;
|
|
|
|
FString name = TEXT("CopiedGBuffer2") + FString::FromInt(i);
|
|
CopyTextureDepth[i] = GraphBuilder.CreateTexture(
|
|
CopyDesc[i],
|
|
*name
|
|
);
|
|
// テクスチャをコピー
|
|
if (i == 0) {
|
|
AddCopyTexturePass(
|
|
GraphBuilder,
|
|
SourceTexture,
|
|
CopyTextureDepth[i]
|
|
);
|
|
}
|
|
else {
|
|
AddDrawTexturePass(
|
|
GraphBuilder,
|
|
ViewInfo,
|
|
//SourceTexture,
|
|
CopyTextureDepth[i - 1],
|
|
CopyTextureDepth[i],
|
|
FIntPoint(0, 0), CopyDesc[i - 1].Extent,
|
|
FIntPoint(0, 0), CopyDesc[i].Extent
|
|
);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,5,0)
|
|
#else
|
|
RDG_EVENT_SCOPE_STAT(GraphBuilder, VRM4U, "VRM4U::Copy");
|
|
#endif
|
|
RDG_GPU_STAT_SCOPE(GraphBuilder, VRM4U);
|
|
SCOPED_NAMED_EVENT(VRM4U, FColor::Emerald);
|
|
|
|
// RenderTargets の0番目を取得
|
|
const FRenderTargetBinding& FirstTarget = RenderTargets[0];
|
|
|
|
FRDGTextureRef SourceTexture = FirstTarget.GetTexture();
|
|
if (!SourceTexture) return;
|
|
|
|
|
|
for (int i = 0; i < copyNum; ++i) {
|
|
CopyDesc[i] = SourceTexture->Desc;
|
|
if (i == 0) {
|
|
}
|
|
else {
|
|
CopyDesc[i].Extent = CopyDesc[i - 1].Extent / 2;
|
|
}
|
|
CopyDesc[i].Flags |= TexCreate_RenderTargetable | TexCreate_UAV;
|
|
|
|
FString name = TEXT("CopiedGBuffer") + FString::FromInt(i);
|
|
CopyTexture[i] = GraphBuilder.CreateTexture(
|
|
CopyDesc[i],
|
|
*name
|
|
);
|
|
// テクスチャをコピー
|
|
if (i == 0) {
|
|
AddCopyTexturePass(
|
|
GraphBuilder,
|
|
SourceTexture,
|
|
CopyTexture[i]
|
|
);
|
|
}
|
|
else {
|
|
#if UE_VERSION_OLDER_THAN(5,4,0)
|
|
#elif UE_VERSION_OLDER_THAN(5,5,0)
|
|
AddDrawTexturePass(
|
|
GraphBuilder,
|
|
InView,
|
|
//SourceTexture,
|
|
CopyTexture[i - 1],
|
|
CopyTexture[i],
|
|
FIntPoint(0, 0), CopyDesc[0].Extent,
|
|
FIntPoint(0, 0), CopyDesc[i - 1].Extent
|
|
);
|
|
#else
|
|
AddDrawTexturePass(
|
|
GraphBuilder,
|
|
ViewInfo,
|
|
//SourceTexture,
|
|
CopyTexture[i - 1],
|
|
CopyTexture[i],
|
|
FIntPoint(0, 0), CopyDesc[i - 1].Extent,
|
|
FIntPoint(0, 0), CopyDesc[i].Extent
|
|
);
|
|
#endif
|
|
// AddCopyTexturePass(
|
|
// GraphBuilder,
|
|
// CopyTexture[i-1],
|
|
// CopyTexture[i]
|
|
// );
|
|
}
|
|
}
|
|
|
|
//RenderTargets.DepthStencil.GetTexture();
|
|
|
|
|
|
// SRV（読み込み用）を作成
|
|
//FRDGTextureSRVRef InputSRV = GraphBuilder.CreateSRV(CopyTexture[0]);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void LocalRimFilter(FRDGBuilder& GraphBuilder, FSceneView& InView, const FRenderTargetBindingSlots& RenderTargets, TRDGUniformBufferRef<FSceneTextureUniformParameters> &SceneTextures) {
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,2,0)
|
|
#else
|
|
|
|
UVRM4U_RenderSubsystem* s = GEngine->GetEngineSubsystem<UVRM4U_RenderSubsystem>();
|
|
if (s == nullptr) return;
|
|
|
|
auto data = s->GenerateFilterData();
|
|
|
|
for (int dataIndex = 0; dataIndex < data.Num(); ++dataIndex){
|
|
const auto& d = data[dataIndex];
|
|
|
|
if (RenderTargets[0].GetTexture() == nullptr) continue;
|
|
if (RenderTargets[1].GetTexture() == nullptr) continue;
|
|
if (RenderTargets[2].GetTexture() == nullptr) continue;
|
|
if (RenderTargets[3].GetTexture() == nullptr) continue;
|
|
|
|
// RenderTargets
|
|
// 0 SceneColor
|
|
// 1 A normal
|
|
// 2 B MRS
|
|
// 3 C basecolor
|
|
// 4 D subsurface
|
|
|
|
|
|
const FRDGSystemTextures& SystemTextures = FRDGSystemTextures::Get(GraphBuilder);
|
|
//const FCustomDepthTextures& CustomDepthTextures = SceneTextures->CustomDepth;
|
|
//bool bCustomDepthProduced = HasBeenProduced(CustomDepthTextures.Depth);
|
|
|
|
FMyComputeShader::FParameters* Parameters = GraphBuilder.AllocParameters<FMyComputeShader::FParameters>();
|
|
|
|
{
|
|
// SceneColorTexture
|
|
const FRenderTargetBinding& FirstTarget = RenderTargets[0];
|
|
FRDGTextureRef TargetTexture = FirstTarget.GetTexture();
|
|
FRDGTextureUAVRef GBufferUAV = GraphBuilder.CreateUAV(TargetTexture);
|
|
Parameters->SceneColorTexture = GBufferUAV;
|
|
}
|
|
|
|
{
|
|
// BaseColorTexture
|
|
//const FRenderTargetBinding& FirstTarget = RenderTargets[3];
|
|
//FRDGTextureRef TargetTexture = FirstTarget.GetTexture();
|
|
//FRDGTextureUAVRef GBufferUAV = GraphBuilder.CreateUAV(TargetTexture);
|
|
//Parameters->BaseColorTexture = GBufferUAV;
|
|
}
|
|
|
|
//Parameters->NormalTexture = GraphBuilder.CreateSRV(SceneTextures->GetParameters()->GBufferATexture);
|
|
Parameters->NormalTexture = GraphBuilder.CreateSRV(RenderTargets[1].GetTexture());
|
|
|
|
Parameters->SceneDepthTexture = GraphBuilder.CreateSRV(SceneTextures->GetParameters()->SceneDepthTexture);
|
|
|
|
Parameters->CustomDepthTexture = GraphBuilder.CreateSRV(SceneTextures->GetParameters()->CustomDepthTexture);
|
|
//Parameters->CustomDepthTexture = SceneTextures->GetParameters()->CustomDepthTexture;
|
|
Parameters->CustomStencilTexture = (SceneTextures->GetParameters()->CustomStencilTexture);
|
|
//Parameters->CustomStencilTexture = bCustomDepthProduced ? CustomDepthTextures.Stencil : SystemTextures.StencilDummySRV;
|
|
//Parameters->InputTexture = GraphBuilder.CreateSRV(CopyTexture[1]);
|
|
//Parameters->SceneDepthTexture = SceneTextures->GetParameters()->SceneDepthTexture;
|
|
//Parameters->SceneDepthTexture = SceneTextures->GetParameters()->GBufferBTexture;
|
|
//check(DepthTexture);
|
|
//Parameters->DepthSampler = TStaticSamplerState<SF_Point>::GetRHI();
|
|
|
|
Parameters->View = InView.ViewUniformBuffer;
|
|
//Parameters->SceneTextures = SceneTextures;
|
|
//Parameters->RenderTargets[0] = Output.GetRenderTargetBinding();
|
|
//PassParameters->SceneColorTexture = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(SceneColorTexture));
|
|
|
|
Parameters->CameraPosition = FVector3f(InView.ViewMatrices.GetViewOrigin());
|
|
Parameters->CameraForwardVector = FVector3f(InView.ViewRotation.RotateVector(FVector(1, 0, 0)));
|
|
|
|
Parameters->UseCustomLightPosition = d.bUseCustomLighPosition;
|
|
Parameters->LightPosition = FVector3f(d.LightPosition);
|
|
Parameters->LightDirection = FVector3f(d.LightDirection);
|
|
|
|
Parameters->UseCustomLightColor = d.bUseCustomLighColor;
|
|
Parameters->LightColor = FVector3f(d.LightColor);
|
|
Parameters->LightScale = d.LightScale;
|
|
Parameters->RimEdgeFade = d.RimEdgeFade;
|
|
|
|
Parameters->UseBinaryEdge = d.bUseBinaryEdge;
|
|
Parameters->RimEdgeBinaryRange = d.RimEdgeBinaryRange;
|
|
|
|
Parameters->SampleScreenScale = d.SampleScreenScale;
|
|
Parameters->SampleScale = d.SampleScale;
|
|
|
|
Parameters->CustomStencilMask = d.CustomStencilMask;
|
|
|
|
int Width = RenderTargets[0].GetTexture()->Desc.Extent.X;
|
|
int Height = RenderTargets[0].GetTexture()->Desc.Extent.Y;
|
|
|
|
TShaderMapRef<FMyComputeShader> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel));
|
|
FComputeShaderUtils::AddPass(
|
|
GraphBuilder,
|
|
RDG_EVENT_NAME("VRM4U_CustomGBufferWrite %d", dataIndex),
|
|
ComputeShader,
|
|
Parameters,
|
|
FIntVector(Width / 8, Height / 8, 1)
|
|
);
|
|
/*
|
|
//FRDGBuilder GraphBuilder(FRHICommandListExecutor::GetImmediateCommandList());
|
|
|
|
//RenderTargets.
|
|
|
|
// Render TargetをRDGリソースに変換
|
|
FRDGTextureRef SceneColorTexture = GraphBuilder.RegisterExternalTexture(CreateRenderTarget(RenderTarget->GameThread_GetRenderTargetResource(), TEXT("SceneColorTexture")));
|
|
FRDGTextureUAVRef OutputUAV = GraphBuilder.CreateUAV(SceneColorTexture);
|
|
|
|
// パラメータを設定
|
|
FMyComputeShader::FParameters* Parameters = GraphBuilder.AllocParameters<FMyComputeShader::FParameters>();
|
|
Parameters->SceneColorTexture = OutputUAV;
|
|
|
|
// Shaderを追加してディスパッチ
|
|
TShaderMapRef<FMyComputeShader> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel));
|
|
FComputeShaderUtils::AddPass(
|
|
GraphBuilder,
|
|
RDG_EVENT_NAME("MyComputeShader"),
|
|
ComputeShader,
|
|
Parameters,
|
|
FIntVector(RenderTarget->SizeX / 8, RenderTarget->SizeY / 8, 1) // スレッドグループ数
|
|
);
|
|
|
|
GraphBuilder.Execute();
|
|
*/
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
///////////////////////
|
|
|
|
FVrmSceneViewExtension::FVrmSceneViewExtension(const FAutoRegister& AutoRegister) : FSceneViewExtensionBase(AutoRegister) {
|
|
}
|
|
|
|
void FVrmSceneViewExtension::PostRenderBasePassDeferred_RenderThread(FRDGBuilder& GraphBuilder, FSceneView& InView, const FRenderTargetBindingSlots& RenderTargets, TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTextures) {
|
|
|
|
if (LocalCSEnable() == false) return;
|
|
|
|
const auto FeatureLevel = InView.GetFeatureLevel();
|
|
if (FeatureLevel <= ERHIFeatureLevel::SM5) return;
|
|
|
|
{
|
|
bool bActive = false;
|
|
|
|
//bool bCapture = InView.bIsSceneCapture;
|
|
|
|
auto t = InView.Family->Scene->GetWorld()->WorldType;
|
|
switch (t) {
|
|
case EWorldType::Editor:
|
|
case EWorldType::Game:
|
|
case EWorldType::PIE:
|
|
bActive = true;
|
|
break;
|
|
}
|
|
|
|
if (bActive == false) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
//check(InView.bIsViewInfo);
|
|
//auto ViewInfo = static_cast<const FViewInfo*>(&InView);
|
|
|
|
|
|
//decltype(auto) View = InView;
|
|
//check(View.bIsViewInfo);
|
|
//const FSceneTextures& st = static_cast<const FViewInfo&>(View).GetSceneTextures();
|
|
|
|
|
|
// GBuffer の BaseColor を取得（例: GBufferA に格納されていると仮定）
|
|
//FRDGTextureRef GBufferBaseColorTexture = SceneTextures.GBufferA;
|
|
//FRDGTextureRef GBufferBaseColorTexture = GraphBuilder.RegisterExternalTexture(
|
|
// InView.Scene->SceneTexturesUniformBuffer->GetRDGTexture("GBufferATexture"), // 仮の取得方法
|
|
// TEXT("GBufferBaseColor")
|
|
//);
|
|
//PassTextures.Depth = SceneTextures.Depth;
|
|
//PassTextures.Color = SceneTextures.Color.Target;
|
|
//PassTextures.GBufferA = (*SceneTextures.UniformBuffer)->GBufferATexture;
|
|
//PassTextures.GBufferB = (*SceneTextures.UniformBuffer)->GBufferBTexture;
|
|
//PassTextures.GBufferC = (*SceneTextures.UniformBuffer)->GBufferCTexture;
|
|
//PassTextures.GBufferE = (*SceneTextures.UniformBuffer)->GBufferETexture;
|
|
//PassTextures.DBufferTextures = DBufferTextures;
|
|
|
|
//FRDGTextureRef GBufferBaseColorTexture = (*SceneTextures.UniformBuffer)->GBufferATexture;
|
|
|
|
//FScreenPassTexture ScreenPassTex(SceneTextures->GetParameters()->GBufferATexture);
|
|
//RDG_EVENT_SCOPE(GraphBuilder, "Naga_PostRenderBasePassDeferred %dx%d", ScreenPassTex.ViewRect.Width(), ScreenPassTex.ViewRect.Height());
|
|
|
|
// FRDGTextureUAVRef GBufferUAV = GraphBuilder.CreateUAV(ScreenPassTex.Texture);
|
|
|
|
|
|
///// filter
|
|
#if UE_VERSION_OLDER_THAN(5,2,0)
|
|
#else
|
|
|
|
|
|
bool bUseRimFilter = false;
|
|
{
|
|
LocalRimFilter(GraphBuilder, InView, RenderTargets, SceneTextures);
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
void FVrmSceneViewExtension::PrePostProcessPass_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& View, const FPostProcessingInputs& Inputs) {
|
|
|
|
//const FSceneView& View = Views[0];
|
|
//check(View.bIsViewInfo);
|
|
//const FMinimalSceneTextures& SceneTextures = static_cast<const FViewInfo&>(View).GetSceneTextures();
|
|
}
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,6,0)
|
|
void FVrmSceneViewExtension::SubscribeToPostProcessingPass(EPostProcessingPass Pass, FAfterPassCallbackDelegateArray& InOutPassCallbacks, bool bIsPassEnabled) {
|
|
if (Pass == EPostProcessingPass::FXAA)
|
|
{
|
|
//InOutPassCallbacks.Add(
|
|
// FAfterPassCallbackDelegate::CreateRaw(this, &FVrmSceneViewExtension::AfterTonemap_RenderThread));
|
|
}
|
|
}
|
|
#else
|
|
void FVrmSceneViewExtension::SubscribeToPostProcessingPass(EPostProcessingPass Pass, const FSceneView& InView, FPostProcessingPassDelegateArray& InOutPassCallbacks, bool bIsPassEnabled) {
|
|
if ((int)Pass == (int)EPostProcessingPass::Tonemap-1)
|
|
{
|
|
InOutPassCallbacks.Add(
|
|
FAfterPassCallbackDelegate::CreateRaw(this, &FVrmSceneViewExtension::PreTonemap_RenderThread));
|
|
}
|
|
if (Pass == EPostProcessingPass::Tonemap)
|
|
{
|
|
InOutPassCallbacks.Add(
|
|
FAfterPassCallbackDelegate::CreateRaw(this, &FVrmSceneViewExtension::AfterTonemap_RenderThread));
|
|
}
|
|
if ((int)Pass == (int)EPostProcessingPass::MAX-1)
|
|
{
|
|
InOutPassCallbacks.Add(
|
|
FAfterPassCallbackDelegate::CreateRaw(this, &FVrmSceneViewExtension::LastPass_RenderThread));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
bool FVrmSceneViewExtension::IsActiveThisFrame_Internal(const FSceneViewExtensionContext& Context) const {
|
|
return FSceneViewExtensionBase::IsActiveThisFrame_Internal(Context);
|
|
}
|
|
|
|
|
|
FScreenPassTexture FVrmSceneViewExtension::PreTonemap_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& InView, const FPostProcessMaterialInputs& InOutInputs) {
|
|
return Pass_RenderThread(GraphBuilder, InView, InOutInputs, ECapturePass::PreTonemap);
|
|
}
|
|
FScreenPassTexture FVrmSceneViewExtension::AfterTonemap_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& InView, const FPostProcessMaterialInputs& InOutInputs) {
|
|
return Pass_RenderThread(GraphBuilder, InView, InOutInputs, ECapturePass::PostTonemap);
|
|
}
|
|
FScreenPassTexture FVrmSceneViewExtension::LastPass_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& InView, const FPostProcessMaterialInputs& InOutInputs) {
|
|
return Pass_RenderThread(GraphBuilder, InView, InOutInputs, ECapturePass::LastPass);
|
|
}
|
|
|
|
FScreenPassTexture FVrmSceneViewExtension::Pass_RenderThread(FRDGBuilder & GraphBuilder, const FSceneView & InView, const FPostProcessMaterialInputs & InOutInputs, ECapturePass Pass){
|
|
|
|
auto GetReturnTexture = [&InOutInputs, &GraphBuilder]() {
|
|
#if UE_VERSION_OLDER_THAN(5,4,0)
|
|
/** We don't want to modify scene texture in any way. We just want it to be passed back onto the next stage. */
|
|
FScreenPassTexture SceneTexture = const_cast<FScreenPassTexture&>(InOutInputs.Textures[(uint32)EPostProcessMaterialInput::SceneColor]);
|
|
return SceneTexture;
|
|
#else
|
|
return InOutInputs.ReturnUntouchedSceneColorForPostProcessing(GraphBuilder);
|
|
#endif
|
|
};
|
|
|
|
|
|
|
|
FVRM4URenderModule* m = FModuleManager::GetModulePtr<FVRM4URenderModule>("VRM4URender");
|
|
if (m == nullptr) {
|
|
return GetReturnTexture();
|
|
}
|
|
|
|
if (FVRM4URenderModule::isCaptureTarget(&InView) == false) {
|
|
return GetReturnTexture();
|
|
}
|
|
|
|
bool bOverride = false;
|
|
|
|
if (m->CaptureList.Num()) {
|
|
|
|
#if UE_VERSION_OLDER_THAN(5,3,0)
|
|
decltype(auto) View = static_cast<const FViewInfo&>(InView);
|
|
#else
|
|
decltype(auto) View = InView;
|
|
#endif
|
|
|
|
|
|
TObjectPtr<UTextureRenderTarget2D> dst;
|
|
//FScreenPassTextureSlice src;
|
|
auto src = InOutInputs.Textures[(uint32)EPostProcessMaterialInput::SceneColor];
|
|
|
|
|
|
for (auto c : m->CaptureList) {
|
|
if (c.Key == nullptr) continue;
|
|
if (c.Key->GetRenderTargetResource() == nullptr) continue;
|
|
|
|
switch (c.Value) {
|
|
case EVRM4U_CaptureSource::ColorTexturePostOpaque:
|
|
if (Pass == ECapturePass::PreTonemap) {
|
|
dst = c.Key;
|
|
}
|
|
break;
|
|
case EVRM4U_CaptureSource::ColorTexturePostTonemap:
|
|
if (Pass == ECapturePass::PostTonemap) {
|
|
dst = c.Key;
|
|
}
|
|
break;
|
|
case EVRM4U_CaptureSource::ColorTextureLastPass:
|
|
if (Pass == ECapturePass::LastPass) {
|
|
dst = c.Key;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (src.IsValid() && dst.Get()) {
|
|
#if UE_VERSION_OLDER_THAN(5,4,0)
|
|
FVRM4URenderModule::AddCopyPass(GraphBuilder, FIntPoint(View.UnscaledViewRect.Width(), View.UnscaledViewRect.Height()), src.Texture, dst);
|
|
bOverride = true;
|
|
|
|
#else
|
|
FVRM4URenderModule::AddCopyPass(GraphBuilder, FIntPoint(View.UnscaledViewRect.Width(), View.UnscaledViewRect.Height()), src.TextureSRV->GetParent(), dst);
|
|
bOverride = true;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (bOverride && InOutInputs.OverrideOutput.IsValid())
|
|
{
|
|
return InOutInputs.OverrideOutput;
|
|
} else {
|
|
return GetReturnTexture();
|
|
}
|
|
}
|