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
}
