Skip to content

Instantly share code, notes, and snippets.

@ldl19691031

ldl19691031/RedCubeRendering.cpp

Created May 27, 2023 09:38
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save ldl19691031/fdd923ddb8334a383a1d42969e5f396f to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save ldl19691031/fdd923ddb8334a383a1d42969e5f396f to your computer and use it in GitHub Desktop.
Download ZIP
Raw
RedCubeRendering.cpp
#include "RedCubeRendering.h"
#include "DepthRendering.h"
#include "DataDrivenShaderPlatformInfo.h"
#include "Engine/Engine.h"
#include "RendererInterface.h"
#include "StaticBoundShaderState.h"
#include "SceneUtils.h"
#include "EngineGlobals.h"
#include "Materials/Material.h"
#include "PostProcess/SceneRenderTargets.h"
#include "GlobalShader.h"
#include "MaterialShaderType.h"
#include "MeshMaterialShaderType.h"
#include "MeshMaterialShader.h"
#include "SceneRendering.h"
#include "DeferredShadingRenderer.h"
#include "ScenePrivate.h"
#include "OneColorShader.h"
#include "IHeadMountedDisplay.h"
#include "IXRTrackingSystem.h"
#include "ScreenRendering.h"
#include "PostProcess/SceneFilterRendering.h"
#include "DynamicPrimitiveDrawing.h"
#include "PipelineStateCache.h"
#include "ClearQuad.h"
#include "MeshPassProcessor.inl"
#include "PixelShaderUtils.h"
#include "RenderGraphUtils.h"
#include "SceneRenderingUtils.h"
#include "DebugProbeRendering.h"
#include "RenderCore.h"
#include "SimpleMeshDrawCommandPass.h"
#include "UnrealEngine.h"
BEGIN_SHADER_PARAMETER_STRUCT(FRedCubePassParameters, )
SHADER_PARAMETER_STRUCT_INCLUDE(FViewShaderParameters, View)
SHADER_PARAMETER_STRUCT_INCLUDE(FInstanceCullingDrawParams, InstanceCullingDrawParams)
RENDER_TARGET_BINDING_SLOTS()
END_SHADER_PARAMETER_STRUCT()
DECLARE_GPU_DRAWCALL_STAT(RedCubePass);
DECLARE_CYCLE_STAT(TEXT("RedCubePass"), STAT_CLP_RedCubePass, STATGROUP_ParallelCommandListMarkers);
FRedCubePassParameters* GetRedCubePassParameters(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureRef RenderTarget)
{
auto* PassParameters = GraphBuilder.AllocParameters<FRedCubePassParameters>();
PassParameters->View = View.GetShaderParameters();
PassParameters->RenderTargets[0] = FRenderTargetBinding(RenderTarget, ERenderTargetLoadAction::ELoad);
return PassParameters;
}
IMPLEMENT_MATERIAL_SHADER_TYPE(, FRedCubePS, TEXT("/Engine/Private/RedCubePixelShader.usf"), TEXT("Main"), SF_Pixel);
IMPLEMENT_SHADERPIPELINE_TYPE_VSPS(RedCubePipeline, TDepthOnlyVS<false>, FRedCubePS, true);
FRedCubeMeshProcessor::FRedCubeMeshProcessor(EMeshPass::Type InMeshPassType, const FScene* Scene, ERHIFeatureLevel::Type FeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, const FMeshPassProcessorRenderState& InPassDrawRenderState, FMeshPassDrawListContext* InDrawListContext)
: FMeshPassProcessor(InMeshPassType, Scene, FeatureLevel, InViewIfDynamicMeshCommand, InDrawListContext)
, PassDrawRenderState(InPassDrawRenderState)
{
}
void FRedCubeMeshProcessor::AddMeshBatch(const FMeshBatch& MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* PrimitiveSceneProxy, int32 StaticMeshId )
{
const FMaterialRenderProxy* MaterialRenderProxy = MeshBatch.MaterialRenderProxy;
const FMaterial* Material = MaterialRenderProxy->GetMaterialNoFallback(FeatureLevel);
const FVertexFactory* VertexFactory = MeshBatch.VertexFactory;
const FVertexFactoryType* VertexFactoryType = VertexFactory->GetType();
TMeshProcessorShaders<
TDepthOnlyVS<false>,
FRedCubePS> RedCubePassShaders;
FShaderPipelineRef ShaderPipeline;
FMaterialShaderTypes ShaderTypes;
ShaderTypes.AddShaderType<TDepthOnlyVS<false>>();
ShaderTypes.AddShaderType<FRedCubePS>();
ShaderTypes.PipelineType = &RedCubePipeline;
FMaterialShaders Shaders;
//GetShaders
{
if (!Material->TryGetShaders(ShaderTypes, VertexFactoryType, Shaders))
{
return;
}
Shaders.TryGetPipeline(ShaderPipeline);
Shaders.TryGetVertexShader(RedCubePassShaders.VertexShader);
Shaders.TryGetPixelShader(RedCubePassShaders.PixelShader);
}
if (ShaderPipeline.IsValid() == false || ShaderPipeline.IsNull())
{
return;
}
FMeshPassProcessorRenderState DrawRenderState(PassDrawRenderState);
FMeshMaterialShaderElementData ShaderElementData;
ShaderElementData.InitializeMeshMaterialData(ViewIfDynamicMeshCommand, PrimitiveSceneProxy, MeshBatch, StaticMeshId, true);
const bool bIsMasked = IsMaskedBlendMode(*Material);
const FMeshDrawCommandSortKey SortKey = CalculateDepthPassMeshStaticSortKey(bIsMasked, RedCubePassShaders.VertexShader.GetShader(), RedCubePassShaders.PixelShader.GetShader());
BuildMeshDrawCommands(
MeshBatch,
BatchElementMask,
PrimitiveSceneProxy,
*MaterialRenderProxy,
*Material,
DrawRenderState,
RedCubePassShaders,
ERasterizerFillMode::FM_Solid,
ERasterizerCullMode::CM_None,
SortKey,
EMeshPassFeatures::Default,
ShaderElementData);
}
void FDeferredShadingSceneRenderer::RenderRedCubePass(FRDGBuilder& GraphBuilder, FRDGTextureRef RenderTargetTexture, FInstanceCullingManager& InstanceCullingManager)
{
RDG_EVENT_SCOPE(GraphBuilder, "Red Cube Pass");
RDG_GPU_STAT_SCOPE(GraphBuilder, RedCubePass);
for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
{
FViewInfo& View = Views[ViewIndex];
FMeshPassProcessorRenderState DrawRenderState;
DrawRenderState.SetBlendState(TStaticBlendStateWriteMask<CW_RGBA, CW_RGBA, CW_RGBA, CW_RGBA>::GetRHI());
DrawRenderState.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
const bool bShouldRenderView = View.ShouldRenderView();
if (bShouldRenderView)
{
View.BeginRenderView();
FRedCubePassParameters* PassParameters = GetRedCubePassParameters(GraphBuilder, View, RenderTargetTexture);
View.ParallelMeshDrawCommandPasses[EMeshPass::RedCubePass].BuildRenderingCommands(GraphBuilder, Scene->GPUScene, PassParameters->InstanceCullingDrawParams);
GraphBuilder.AddPass(
RDG_EVENT_NAME("RedCubePassParallel"),
PassParameters,
ERDGPassFlags::Raster | ERDGPassFlags::SkipRenderPass,
[this, &View, PassParameters](const FRDGPass* InPass, FRHICommandListImmediate& RHICmdList)
{
FRDGParallelCommandListSet ParallelCommandListSet(InPass, RHICmdList, GET_STATID(STAT_CLP_RedCubePass), *this, View, FParallelCommandListBindings(PassParameters));
ParallelCommandListSet.SetHighPriority();
View.ParallelMeshDrawCommandPasses[EMeshPass::RedCubePass].DispatchDraw(&ParallelCommandListSet, RHICmdList, &PassParameters->InstanceCullingDrawParams);
});
}
}
}
FMeshPassProcessor* CreateRedCubePassProcessor(ERHIFeatureLevel::Type FeatureLevel, const FScene* Scene, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext)
{
FMeshPassProcessorRenderState RedCubePassState;
RedCubePassState.SetBlendState(TStaticBlendStateWriteMask<CW_RGBA, CW_RGBA, CW_RGBA, CW_RGBA>::GetRHI());
RedCubePassState.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());
return new FRedCubeMeshProcessor(EMeshPass::RedCubePass, Scene, FeatureLevel, InViewIfDynamicMeshCommand, RedCubePassState,InDrawListContext);
}
REGISTER_MESHPASSPROCESSOR_AND_PSOCOLLECTOR(RedCubePass, CreateRedCubePassProcessor, EShadingPath::Deferred, EMeshPass::RedCubePass, EMeshPassFlags::CachedMeshCommands | EMeshPassFlags::MainView);
bool FRedCubePS::ShouldCompilePermutation(const FMeshMaterialShaderPermutationParameters& Parameters)
{
if (IsTranslucentBlendMode(Parameters.MaterialParameters))
{
return Parameters.MaterialParameters.bIsTranslucencyWritingCustomDepth;
}
return true;
}
Raw
RedCubeRendering.h
#pragma once
#include "CoreMinimal.h"
#include "RHI.h"
#include "HitProxies.h"
#include "ShaderBaseClasses.h"
#include "MeshPassProcessor.h"
class FRedCubeMeshProcessor : public FSceneRenderingAllocatorObject<FRedCubeMeshProcessor>, public FMeshPassProcessor
{
public:
FRedCubeMeshProcessor(
EMeshPass::Type InMeshPassType,
const FScene* Scene,
ERHIFeatureLevel::Type FeatureLevel,
const FSceneView* InViewIfDynamicMeshCommand,
const FMeshPassProcessorRenderState& InPassDrawRenderState,
FMeshPassDrawListContext* InDrawListContext);
virtual void AddMeshBatch(const FMeshBatch& RESTRICT MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, int32 StaticMeshId = -1) override final;
private:
FMeshPassProcessorRenderState PassDrawRenderState;
};
class FRedCubePS : public FMeshMaterialShader
{
DECLARE_SHADER_TYPE(FRedCubePS, MeshMaterial);
public:
static bool ShouldCompilePermutation(const FMeshMaterialShaderPermutationParameters& Parameters);
FRedCubePS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) :
FMeshMaterialShader(Initializer){}
static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
{
FMeshMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
}
FRedCubePS() {}
void GetShaderBindings(
const FScene* Scene,
ERHIFeatureLevel::Type FeatureLevel,
const FPrimitiveSceneProxy* PrimitiveSceneProxy,
const FMaterialRenderProxy& MaterialRenderProxy,
const FMaterial& Material,
const FMeshPassProcessorRenderState& DrawRenderState,
const FMeshMaterialShaderElementData& ShaderElementData,
FMeshDrawSingleShaderBindings& ShaderBindings) const
{
FMeshMaterialShader::GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, Material, DrawRenderState, ShaderElementData, ShaderBindings);
}
};
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment