void FBasePassForwardOpaqueDrawingPolicyFactory::AddStaticMesh(FRHICommandList& RHICmdList, FScene* Scene, FStaticMesh* StaticMesh) { // Determine the mesh's material and blend mode. const auto FeatureLevel = Scene->GetFeatureLevel(); const FMaterial* Material = StaticMesh->MaterialRenderProxy->GetMaterial(FeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Only draw opaque materials. if( !IsTranslucentBlendMode(BlendMode) ) { // following check moved from ProcessBasePassMeshForForwardShading to avoid passing feature level. check(!AllowHighQualityLightmaps(Scene->GetFeatureLevel())); ProcessBasePassMeshForForwardShading( RHICmdList, FProcessBasePassMeshParameters( *StaticMesh, Material, StaticMesh->PrimitiveSceneInfo->Proxy, true, false, ESceneRenderTargetsMode::DontSet, FeatureLevel ), FDrawBasePassForwardShadingStaticMeshAction(Scene,StaticMesh) ); } }
FMaterialRelevance UMaterialInterface::GetRelevance_Internal(const UMaterial* Material, ERHIFeatureLevel::Type InFeatureLevel) const { if(Material) { const FMaterialResource* MaterialResource = Material->GetMaterialResource(InFeatureLevel); const bool bIsTranslucent = IsTranslucentBlendMode((EBlendMode)GetBlendMode()); EMaterialShadingModel ShadingModel = GetShadingModel(); const bool bIsLit = ShadingModel != MSM_Unlit; // Determine the material's view relevance. FMaterialRelevance MaterialRelevance; MaterialRelevance.bOpaque = !bIsTranslucent; MaterialRelevance.bMasked = IsMasked(); MaterialRelevance.bDistortion = Material->bUsesDistortion && bIsTranslucent; MaterialRelevance.bSeparateTranslucency = bIsTranslucent && Material->bEnableSeparateTranslucency; MaterialRelevance.bNormalTranslucency = bIsTranslucent && !Material->bEnableSeparateTranslucency; MaterialRelevance.bDisableDepthTest = bIsTranslucent && Material->bDisableDepthTest; MaterialRelevance.bSubsurfaceProfile = (Material->MaterialDomain == MD_Surface) && !bIsTranslucent && (ShadingModel == MSM_SubsurfaceProfile); MaterialRelevance.bOutputsVelocityInBasePass = Material->bOutputVelocityOnBasePass; return MaterialRelevance; } else { return FMaterialRelevance(); } }
void FBasePassOpaqueDrawingPolicyFactory::AddStaticMesh(FRHICommandList& RHICmdList, FScene* Scene, FStaticMesh* StaticMesh) { // Determine the mesh's material and blend mode. const FMaterial* Material = StaticMesh->MaterialRenderProxy->GetMaterial(Scene->GetFeatureLevel()); const EBlendMode BlendMode = Material->GetBlendMode(); // Don't composite static meshes const bool bEditorCompositeDepthTest = false; // Only draw opaque materials. if( !IsTranslucentBlendMode(BlendMode) ) { ProcessBasePassMesh( RHICmdList, FProcessBasePassMeshParameters( *StaticMesh, Material, StaticMesh->PrimitiveSceneInfo->Proxy, false, bEditorCompositeDepthTest, ESceneRenderTargetsMode::DontSet, Scene->GetFeatureLevel()), FDrawBasePassStaticMeshAction(Scene,StaticMesh) ); } }
FMeshBatchAndRelevance::FMeshBatchAndRelevance(const FMeshBatch& InMesh, const FPrimitiveSceneProxy* InPrimitiveSceneProxy, ERHIFeatureLevel::Type FeatureLevel) : Mesh(&InMesh), PrimitiveSceneProxy(InPrimitiveSceneProxy) { EBlendMode BlendMode = InMesh.MaterialRenderProxy->GetMaterial(FeatureLevel)->GetBlendMode(); bHasOpaqueOrMaskedMaterial = !IsTranslucentBlendMode(BlendMode); bRenderInMainPass = PrimitiveSceneProxy->ShouldRenderInMainPass(); }
/** * Render a dynamic mesh using a translucent draw policy * @return true if the mesh rendered */ bool FTranslucencyForwardShadingDrawingPolicyFactory::DrawDynamicMesh( FRHICommandList& RHICmdList, const FViewInfo& View, ContextType DrawingContext, const FMeshBatch& Mesh, bool bBackFace, bool bPreFog, const FPrimitiveSceneProxy* PrimitiveSceneProxy, FHitProxyId HitProxyId ) { bool bDirty = false; // Determine the mesh's material and blend mode. const auto FeatureLevel = View.GetFeatureLevel(); const auto ShaderPlatform = View.GetShaderPlatform(); const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(FeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Only render translucent materials. if (IsTranslucentBlendMode(BlendMode)) { const bool bDisableDepthTest = Material->ShouldDisableDepthTest(); if (bDisableDepthTest) { RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI()); } ProcessBasePassMeshForForwardShading( RHICmdList, FProcessBasePassMeshParameters( Mesh, Material, PrimitiveSceneProxy, true, false, ESceneRenderTargetsMode::SetTextures, FeatureLevel ), FDrawTranslucentMeshForwardShadingAction( View, bBackFace, HitProxyId ) ); if (bDisableDepthTest) { // Restore default depth state // Note, this is a reversed Z depth surface, using CF_GreaterEqual. RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_GreaterEqual>::GetRHI()); } bDirty = true; } return bDirty; }
void FRendererModule::DrawTileMesh(FRHICommandListImmediate& RHICmdList, const FSceneView& SceneView, const FMeshBatch& Mesh, bool bIsHitTesting, const FHitProxyId& HitProxyId) { if (!GUsingNullRHI) { // Create an FViewInfo so we can initialize its RHI resources //@todo - reuse this view for multiple tiles, this is going to be slow for each tile FViewInfo View(&SceneView); View.InitRHIResources(); const auto FeatureLevel = View.GetFeatureLevel(); const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(FeatureLevel); //get the blend mode of the material const EBlendMode MaterialBlendMode = Material->GetBlendMode(); FSceneRenderTargets::Get(RHICmdList).SetLightAttenuationMode(false); GSystemTextures.InitializeTextures(RHICmdList, FeatureLevel); // handle translucent material blend modes, not relevant in MaterialTexCoordScalesAnalysis since it outputs the scales. if (IsTranslucentBlendMode(MaterialBlendMode) && View.Family->GetDebugViewShaderMode() != DVSM_MaterialTexCoordScalesAnalysis) { if (FeatureLevel >= ERHIFeatureLevel::SM4) { FTranslucencyDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FTranslucencyDrawingPolicyFactory::ContextType(nullptr, ETranslucencyPass::TPT_AllTranslucency, true), Mesh, false, false, NULL, HitProxyId); } else { FMobileTranslucencyDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FMobileTranslucencyDrawingPolicyFactory::ContextType(false), Mesh, false, false, NULL, HitProxyId); } } // handle opaque materials else { // make sure we are doing opaque drawing RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI()); // draw the mesh if (bIsHitTesting) { FHitProxyDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FHitProxyDrawingPolicyFactory::ContextType(), Mesh, false, false, NULL, HitProxyId); } else { if (FeatureLevel >= ERHIFeatureLevel::SM4) { FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FBasePassOpaqueDrawingPolicyFactory::ContextType(false, ESceneRenderTargetsMode::DontSet), Mesh, false, false, NULL, HitProxyId); } else { FMobileBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FMobileBasePassOpaqueDrawingPolicyFactory::ContextType(false, ESceneRenderTargetsMode::DontSet), Mesh, false, false, NULL, HitProxyId); } } } } }
static bool ShouldCache(EShaderPlatform Platform,const FMaterial* Material,const FVertexFactoryType* VertexFactoryType) { //Only compile the velocity shaders for the default material or if it's masked, return ((Material->IsSpecialEngineMaterial() || Material->IsMasked() //or if the material is opaque and two-sided, || (Material->IsTwoSided() && !IsTranslucentBlendMode(Material->GetBlendMode())) // or if the material modifies meshes || Material->MaterialMayModifyMeshPosition())) && IsFeatureLevelSupported(Platform, ERHIFeatureLevel::SM4) && !FVelocityRendering::OutputsToGBuffer(); }
void FRendererModule::DrawTileMesh(FRHICommandListImmediate& RHICmdList, const FSceneView& SceneView, const FMeshBatch& Mesh, bool bIsHitTesting, const FHitProxyId& HitProxyId) { // Create an FViewInfo so we can initialize its RHI resources //@todo - reuse this view for multiple tiles, this is going to be slow for each tile FViewInfo View(&SceneView); View.InitRHIResources(nullptr); const auto FeatureLevel = View.GetFeatureLevel(); const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(FeatureLevel); //get the blend mode of the material const EBlendMode MaterialBlendMode = Material->GetBlendMode(); if (!GUsingNullRHI) { // handle translucent material blend modes if (IsTranslucentBlendMode(MaterialBlendMode)) { if (FeatureLevel >= ERHIFeatureLevel::SM4) { FTranslucencyDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FTranslucencyDrawingPolicyFactory::ContextType(nullptr, TPT_NonSeparateTransluceny, true), Mesh, false, false, NULL, HitProxyId); } else { FTranslucencyForwardShadingDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FTranslucencyForwardShadingDrawingPolicyFactory::ContextType(false), Mesh, false, false, NULL, HitProxyId); } } // handle opaque materials else { // make sure we are doing opaque drawing RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI()); // draw the mesh if (bIsHitTesting) { FHitProxyDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FHitProxyDrawingPolicyFactory::ContextType(), Mesh, false, false, NULL, HitProxyId); } else { if (FeatureLevel >= ERHIFeatureLevel::SM4) { FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FBasePassOpaqueDrawingPolicyFactory::ContextType(false, ESceneRenderTargetsMode::DontSet), Mesh, false, false, NULL, HitProxyId); } else { FBasePassForwardOpaqueDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, FBasePassForwardOpaqueDrawingPolicyFactory::ContextType(false, ESceneRenderTargetsMode::DontSet), Mesh, false, false, NULL, HitProxyId); } } } } }
bool FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh( FRHICommandList& RHICmdList, const FViewInfo& View, ContextType DrawingContext, const FMeshBatch& Mesh, bool bBackFace, bool bPreFog, const FPrimitiveSceneProxy* PrimitiveSceneProxy, FHitProxyId HitProxyId, const bool bIsInstancedStereo ) { // Determine the mesh's material and blend mode. const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(View.GetFeatureLevel()); const EBlendMode BlendMode = Material->GetBlendMode(); // Only draw opaque materials. if(!IsTranslucentBlendMode(BlendMode)) { ProcessBasePassMesh( RHICmdList, FProcessBasePassMeshParameters( Mesh, Material, PrimitiveSceneProxy, !bPreFog, DrawingContext.bEditorCompositeDepthTest, DrawingContext.TextureMode, View.GetFeatureLevel(), bIsInstancedStereo ), FDrawBasePassDynamicMeshAction( View, bBackFace, Mesh.DitheredLODTransitionAlpha, HitProxyId ) ); return true; } else { return false; } }
bool FBasePassForwardOpaqueDrawingPolicyFactory::DrawDynamicMesh( FRHICommandList& RHICmdList, const FViewInfo& View, ContextType DrawingContext, const FMeshBatch& Mesh, bool bBackFace, bool bPreFog, const FPrimitiveSceneProxy* PrimitiveSceneProxy, FHitProxyId HitProxyId ) { // Determine the mesh's material and blend mode. const auto FeatureLevel = View.GetFeatureLevel(); const auto ShaderPlatform = View.GetShaderPlatform(); const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(FeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Only draw opaque materials. if(!IsTranslucentBlendMode(BlendMode)) { ProcessBasePassMeshForForwardShading( RHICmdList, FProcessBasePassMeshParameters( Mesh, Material, PrimitiveSceneProxy, true, false, DrawingContext.TextureMode, FeatureLevel ), FDrawBasePassForwardShadingDynamicMeshAction( View, bBackFace, HitProxyId ) ); return true; } else { return false; } }
void Process( FRHICommandList& RHICmdList, const FProcessBasePassMeshParameters& Parameters, const LightMapPolicyType& LightMapPolicy, const typename LightMapPolicyType::ElementDataType& LightMapElementData ) const { FScene::EBasePassDrawListType DrawType = FScene::EBasePass_Default; if (StaticMesh->IsMasked(Parameters.FeatureLevel)) { DrawType = FScene::EBasePass_Masked; } if (Scene) { // Find the appropriate draw list for the static mesh based on the light-map policy type. TStaticMeshDrawList<TBasePassDrawingPolicy<LightMapPolicyType> >& DrawList = Scene->GetBasePassDrawList<LightMapPolicyType>(DrawType); // Add the static mesh to the draw list. DrawList.AddMesh( StaticMesh, typename TBasePassDrawingPolicy<LightMapPolicyType>::ElementDataType(LightMapElementData), TBasePassDrawingPolicy<LightMapPolicyType>( StaticMesh->VertexFactory, StaticMesh->MaterialRenderProxy, *Parameters.Material, Parameters.FeatureLevel, LightMapPolicy, Parameters.BlendMode, Parameters.TextureMode, Parameters.ShadingModel != MSM_Unlit && Scene->SkyLight && Scene->SkyLight->bWantsStaticShadowing && !Scene->SkyLight->bHasStaticLighting, IsTranslucentBlendMode(Parameters.BlendMode) && Scene->HasAtmosphericFog(), /* bOverrideWithShaderComplexity = */ false, /* bInAllowGlobalFog = */ false, /* bInEnableEditorPrimitiveDepthTest = */ false, /* bInEnableReceiveDecalOutput = */ true ), Scene->GetFeatureLevel() ); } }
/** * Render a dynamic mesh using a translucent draw policy * @return true if the mesh rendered */ bool FTranslucencyForwardShadingDrawingPolicyFactory::DrawDynamicMesh( FRHICommandList& RHICmdList, const FViewInfo& View, ContextType DrawingContext, const FMeshBatch& Mesh, bool bBackFace, bool bPreFog, const FPrimitiveSceneProxy* PrimitiveSceneProxy, FHitProxyId HitProxyId ) { bool bDirty = false; // Determine the mesh's material and blend mode. const auto FeatureLevel = View.GetFeatureLevel(); const auto ShaderPlatform = View.GetShaderPlatform(); const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(FeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Only render translucent materials. if (IsTranslucentBlendMode(BlendMode)) { ProcessBasePassMeshForForwardShading( RHICmdList, FProcessBasePassMeshParameters( Mesh, Material, PrimitiveSceneProxy, true, false, ESceneRenderTargetsMode::SetTextures, FeatureLevel ), FDrawTranslucentMeshForwardShadingAction( View, bBackFace, HitProxyId ) ); bDirty = true; } return bDirty; }
void FBasePassForwardOpaqueDrawingPolicyFactory::AddStaticMesh(FScene* Scene,FStaticMesh* StaticMesh) { // Determine the mesh's material and blend mode. const FMaterial* Material = StaticMesh->MaterialRenderProxy->GetMaterial(GRHIFeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Only draw opaque materials. if( !IsTranslucentBlendMode(BlendMode) ) { ProcessBasePassMeshForForwardShading( FProcessBasePassMeshParameters( *StaticMesh, Material, StaticMesh->PrimitiveSceneInfo->Proxy, true, false, ESceneRenderTargetsMode::DontSet ), FDrawBasePassForwardShadingStaticMeshAction(Scene,StaticMesh) ); } }
static bool ShouldCache(EShaderPlatform Platform,const FMaterial* Material,const FVertexFactoryType* VertexFactoryType) { return Material && IsTranslucentBlendMode(Material->GetBlendMode()) && Material->IsDistorted(); }
bool FDepthDrawingPolicyFactory::DrawMesh( const FViewInfo& View, ContextType DrawingContext, const FMeshBatch& Mesh, const uint64& BatchElementMask, bool bBackFace, bool bPreFog, const FPrimitiveSceneProxy* PrimitiveSceneProxy, FHitProxyId HitProxyId ) { bool bDirty = false; //Do a per-FMeshBatch check on top of the proxy check in RenderPrePass to handle the case where a proxy that is relevant //to the depth only pass has to submit multiple FMeshElements but only some of them should be used as occluders. if (Mesh.bUseAsOccluder) { const FMaterialRenderProxy* MaterialRenderProxy = Mesh.MaterialRenderProxy; const FMaterial* Material = MaterialRenderProxy->GetMaterial(GRHIFeatureLevel); const EBlendMode BlendMode = Material->GetBlendMode(); // Check to see if the primitive is currently fading in or out using the screen door effect. If it is, // then we can't assume the object is opaque as it may be forcibly masked. const FSceneViewState* SceneViewState = static_cast<const FSceneViewState*>( View.State ); if ( BlendMode == BLEND_Opaque && Mesh.VertexFactory->SupportsPositionOnlyStream() && !Material->MaterialModifiesMeshPosition()) { //render opaque primitives that support a separate position-only vertex buffer const FMaterialRenderProxy* DefaultProxy = UMaterial::GetDefaultMaterial(MD_Surface)->GetRenderProxy(false); FPositionOnlyDepthDrawingPolicy DrawingPolicy(Mesh.VertexFactory,DefaultProxy,*DefaultProxy->GetMaterial(GRHIFeatureLevel),Material->IsTwoSided()); DrawingPolicy.DrawShared(&View,DrawingPolicy.CreateBoundShaderState()); int32 BatchElementIndex = 0; uint64 Mask = BatchElementMask; do { if(Mask & 1) { DrawingPolicy.SetMeshRenderState(View,PrimitiveSceneProxy,Mesh,BatchElementIndex,bBackFace,FPositionOnlyDepthDrawingPolicy::ElementDataType()); DrawingPolicy.DrawMesh(Mesh,BatchElementIndex); } Mask >>= 1; BatchElementIndex++; } while(Mask); bDirty = true; } else if (!IsTranslucentBlendMode(BlendMode)) { const bool bMaterialMasked = Material->IsMasked(); bool bDraw = true; switch(DrawingContext.DepthDrawingMode) { case DDM_AllOccluders: break; case DDM_NonMaskedOnly: bDraw = !bMaterialMasked; break; default: check(!"Unrecognized DepthDrawingMode"); } if(bDraw) { if (!bMaterialMasked && !Material->MaterialModifiesMeshPosition()) { // Override with the default material for opaque materials that are not two sided MaterialRenderProxy = UMaterial::GetDefaultMaterial(MD_Surface)->GetRenderProxy(false); } FDepthDrawingPolicy DrawingPolicy(Mesh.VertexFactory,MaterialRenderProxy,*MaterialRenderProxy->GetMaterial(GRHIFeatureLevel),Material->IsTwoSided()); DrawingPolicy.DrawShared(&View,DrawingPolicy.CreateBoundShaderState()); int32 BatchElementIndex = 0; uint64 Mask = BatchElementMask; do { if(Mask & 1) { DrawingPolicy.SetMeshRenderState(View,PrimitiveSceneProxy,Mesh,BatchElementIndex,bBackFace,FMeshDrawingPolicy::ElementDataType()); DrawingPolicy.DrawMesh(Mesh,BatchElementIndex); } Mask >>= 1; BatchElementIndex++; } while(Mask); bDirty = true; } } }
void Process( FRHICommandList& RHICmdList, const FProcessBasePassMeshParameters& Parameters, const LightMapPolicyType& LightMapPolicy, const typename LightMapPolicyType::ElementDataType& LightMapElementData ) const { const bool bIsLitMaterial = Parameters.ShadingModel != MSM_Unlit; #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) // When rendering masked materials in the shader complexity viewmode, // We want to overwrite complexity for the pixels which get depths written, // And accumulate complexity for pixels which get killed due to the opacity mask being below the clip value. // This is accomplished by forcing the masked materials to render depths in the depth only pass, // Then rendering in the base pass with additive complexity blending, depth tests on, and depth writes off. if(View.Family->EngineShowFlags.ShaderComplexity) { RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false,CF_DepthNearOrEqual>::GetRHI()); } const FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList); #endif const FScene* Scene = Parameters.PrimitiveSceneProxy ? Parameters.PrimitiveSceneProxy->GetPrimitiveSceneInfo()->Scene : NULL; TBasePassDrawingPolicy<LightMapPolicyType> DrawingPolicy( Parameters.Mesh.VertexFactory, Parameters.Mesh.MaterialRenderProxy, *Parameters.Material, Parameters.FeatureLevel, LightMapPolicy, Parameters.BlendMode, Parameters.TextureMode, Scene && Scene->SkyLight && !Scene->SkyLight->bHasStaticLighting && Scene->SkyLight->bWantsStaticShadowing && bIsLitMaterial, IsTranslucentBlendMode(Parameters.BlendMode) && (Scene && Scene->HasAtmosphericFog()) && View.Family->EngineShowFlags.AtmosphericFog, View.Family->EngineShowFlags.ShaderComplexity, false, Parameters.bEditorCompositeDepthTest, /* bInEnableReceiveDecalOutput = */ Scene != nullptr, View.Family->GetQuadOverdrawMode() ); RHICmdList.BuildAndSetLocalBoundShaderState(DrawingPolicy.GetBoundShaderStateInput(View.GetFeatureLevel())); DrawingPolicy.SetSharedState(RHICmdList, &View, typename TBasePassDrawingPolicy<LightMapPolicyType>::ContextDataType(Parameters.bIsInstancedStereo, false)); const FMeshDrawingRenderState DrawRenderState(DitheredLODTransitionAlpha); for( int32 BatchElementIndex = 0, Num = Parameters.Mesh.Elements.Num(); BatchElementIndex < Num; BatchElementIndex++ ) { // We draw instanced static meshes twice when rendering with instanced stereo. Once for each eye. const bool bIsInstancedMesh = Parameters.Mesh.Elements[BatchElementIndex].bIsInstancedMesh; const uint32 InstancedStereoDrawCount = (Parameters.bIsInstancedStereo && bIsInstancedMesh) ? 2 : 1; for (uint32 DrawCountIter = 0; DrawCountIter < InstancedStereoDrawCount; ++DrawCountIter) { DrawingPolicy.SetInstancedEyeIndex(RHICmdList, DrawCountIter); TDrawEvent<FRHICommandList> MeshEvent; BeginMeshDrawEvent(RHICmdList, Parameters.PrimitiveSceneProxy, Parameters.Mesh, MeshEvent); DrawingPolicy.SetMeshRenderState( RHICmdList, View, Parameters.PrimitiveSceneProxy, Parameters.Mesh, BatchElementIndex, bBackFace, DrawRenderState, typename TBasePassDrawingPolicy<LightMapPolicyType>::ElementDataType(LightMapElementData), typename TBasePassDrawingPolicy<LightMapPolicyType>::ContextDataType() ); DrawingPolicy.DrawMesh(RHICmdList, Parameters.Mesh, BatchElementIndex, Parameters.bIsInstancedStereo); } } #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if(View.Family->EngineShowFlags.ShaderComplexity) { RHICmdList.SetDepthStencilState(TStaticDepthStencilState<true,CF_DepthNearOrEqual>::GetRHI()); } #endif }