bIsMobile

#Overview

name: bIsMobile

The value of this variable can be defined or overridden in .ini config files. 11 .ini config files referencing this setting variable.

It is referenced in 35 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of bIsMobile is to identify if the current platform or device being targeted is a mobile platform, specifically one using the ES3_1 (OpenGL ES 3.1) feature level. This variable is commonly used throughout the Unreal Engine 5 codebase to conditionally execute or skip certain rendering and performance-related code paths that are specific to mobile devices.

Key points about bIsMobile:

It is typically set based on the feature level of the current platform, where ERHIFeatureLevel::ES3_1 indicates a mobile device.
It is used in various Unreal Engine subsystems, including rendering, materials, and shader compilation.
The value is usually determined at runtime based on the current platform and graphics capabilities.
It’s often used in conditional statements to enable or disable certain features or optimizations for mobile platforms.
The variable interacts with other platform-specific flags and settings to determine the appropriate rendering and performance behavior for mobile devices.

Best practices when using this variable:

Always check the current context and platform capabilities before relying solely on bIsMobile.
Consider using it in conjunction with other platform-specific checks for more granular control.
Be aware that mobile-specific optimizations may impact visual quality or feature availability.
Test thoroughly on various mobile devices to ensure proper behavior when bIsMobile is true.
Keep in mind that the definition of “mobile” may evolve over time, so consider the long-term implications of using this flag.

Developers should be aware that using bIsMobile may result in different rendering paths or feature sets being used, which can affect performance and visual quality on mobile devices. It’s important to balance the need for mobile-specific optimizations with maintaining a consistent experience across platforms.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/Android/DataDrivenPlatformInfo.ini:60, section: [ShaderPlatform OPENGL_ES3_1_ANDROID]

INI Section: ShaderPlatform OPENGL_ES3_1_ANDROID
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/Android/DataDrivenPlatformInfo.ini:78, section: [ShaderPlatform VULKAN_ES3_1_ANDROID]

INI Section: ShaderPlatform VULKAN_ES3_1_ANDROID
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/IOS/DataDrivenPlatformInfo.ini:53, section: [ShaderPlatform METAL]

INI Section: ShaderPlatform METAL
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/IOS/DataDrivenPlatformInfo.ini:78, section: [ShaderPlatform METAL_SIM]

INI Section: ShaderPlatform METAL_SIM
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/Mac/DataDrivenPlatformInfo.ini:130, section: [ShaderPlatform METAL_MACES3_1]

INI Section: ShaderPlatform METAL_MACES3_1
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/TVOS/DataDrivenPlatformInfo.ini:35, section: [ShaderPlatform METAL_TVOS]

INI Section: ShaderPlatform METAL_TVOS
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/VulkanPC/DataDrivenPlatformInfo.ini:16, section: [ShaderPlatform VULKAN_SM5]

INI Section: ShaderPlatform VULKAN_SM5
Raw value: false
Is Array: False

Location: <Workspace>/Engine/Config/VulkanPC/DataDrivenPlatformInfo.ini:147, section: [ShaderPlatform VULKAN_SM6]

INI Section: ShaderPlatform VULKAN_SM6
Raw value: false
Is Array: False

Location: <Workspace>/Engine/Config/VulkanPC/DataDrivenPlatformInfo.ini:266, section: [ShaderPlatform VULKAN_PCES3_1]

INI Section: ShaderPlatform VULKAN_PCES3_1
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/Windows/DataDrivenPlatformInfo.ini:151, section: [ShaderPlatform PCD3D_ES3_1]

INI Section: ShaderPlatform PCD3D_ES3_1
Raw value: true
Is Array: False

Location: <Workspace>/Engine/Config/Windows/DataDrivenPlatformInfo.ini:177, section: [ShaderPlatform OPENGL_PCES3_1]

INI Section: ShaderPlatform OPENGL_PCES3_1
Raw value: true
Is Array: False

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:281`

Scope (from outer to inner):

file
function     void BuildMetalShaderOutput

Source code excerpt:


	//TODO read from toolchain
	const bool bIsMobile = (ShaderInput.Target.Platform == SP_METAL || ShaderInput.Target.Platform == SP_METAL_MRT || ShaderInput.Target.Platform == SP_METAL_TVOS || ShaderInput.Target.Platform == SP_METAL_MRT_TVOS || ShaderInput.Target.Platform == SP_METAL_SIM);
	bool bNoFastMath = ShaderInput.Environment.CompilerFlags.Contains(CFLAG_NoFastMath);
	const bool bUsingWPO = ShaderInput.Environment.GetCompileArgument(TEXT("USES_WORLD_POSITION_OFFSET"), false);
	if (bUsingWPO && (ShaderInput.Target.Platform == SP_METAL_MRT || ShaderInput.Target.Platform == SP_METAL_MRT_TVOS) && Frequency == SF_Vertex)
	{
		// WPO requires that we make all multiply/sincos instructions invariant :(
		bNoFastMath = true;

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:764`

Scope (from outer to inner):

file
function     void BuildMetalShaderOutput

Source code excerpt:

			if (bSucceeded)
			{
				if (!bIsMobile && !ShaderInput.Environment.CompilerFlags.Contains(CFLAG_Archive))
				{
					uint32 CodeSize = FCStringAnsi::Strlen(TCHAR_TO_UTF8(*MetalCode)) + 1;

					int32 CompressedSize = FCompression::CompressMemoryBound(NAME_Zlib, CodeSize);
					DebugCode.CompressedData.SetNum(CompressedSize);

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:901`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:


	// TODO read from toolchain
	const bool bIsMobile = FMetalCompilerToolchain::Get()->IsMobile((EShaderPlatform)Input.Target.Platform);
	const bool bAppleTV = (Input.ShaderFormat == NAME_SF_METAL_TVOS || Input.ShaderFormat == NAME_SF_METAL_MRT_TVOS);
	const bool bIsSimulator = (Input.ShaderFormat == NAME_SF_METAL_SIM);

	FString MinOSVersion;
	FString StandardVersion;
	switch (VersionEnum)

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:915`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

			MinOSVersion = TEXT("-mtvos-version-min=17.0");
		}
		else if (bIsMobile)
		{
			if (bIsSimulator)
			{
				MinOSVersion = TEXT("-miphonesimulator-version-min=17.0");
			}
			else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:937`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

			MinOSVersion = TEXT("-mtvos-version-min=16.0");
		}
		else if (bIsMobile)
		{
			if (bIsSimulator)
			{
				MinOSVersion = TEXT("-miphonesimulator-version-min=16.0");
			}
			else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:960`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

			MinOSVersion = TEXT("-mtvos-version-min=15.0");
		}
		else if (bIsMobile)
		{
			if (bIsSimulator)
			{
				MinOSVersion = TEXT("-miphonesimulator-version-min=15.0");
			}
			else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:982`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

			MinOSVersion = TEXT("-mtvos-version-min=15.0");
		}
		else if (bIsMobile)
		{
			if (bIsSimulator)
			{
				MinOSVersion = TEXT("-miphonesimulator-version-min=15.0");
			}
			else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1010`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

			MinOSVersion = TEXT("-mtvos-version-min=15.0");
		}
		else if (bIsMobile)
		{
			if (bIsSimulator)
			{
				MinOSVersion = TEXT("-miphonesimulator-version-min=15.0");
			}
			else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1042`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

	}

	TCHAR const* StandardPlatform = bIsMobile ? TEXT("ios") : TEXT("macos");
	FString Standard;
	if (VersionEnum >= 8) //-V547
	{
		Standard = FString::Printf(TEXT("-std=metal%s"), *StandardVersion);
	}
	else

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1099`

Scope (from outer to inner):

file
function     void CompileMetalShader

Source code excerpt:

		FMetalCompileShaderSPIRV::DoCompileMetalShader(Input, Output, PreprocessedSource, GUIDHash, VersionEnum, Semantics, MaxUnrollLoops, (EShaderFrequency)Input.Target.Frequency, bDumpDebugInfo, Standard, MinOSVersion);
	}
	ShaderParameterParser.ValidateShaderParameterTypes(Input, bIsMobile, Output);
}

void OutputMetalDebugData(const FShaderCompilerInput& Input, const FShaderPreprocessOutput& PreprocessOutput, const FShaderCompilerOutput& Output)
{
	UE::ShaderCompilerCommon::DumpExtendedDebugShaderData(Input, PreprocessOutput, Output);
}

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderFormat.cpp:339`

Scope (from outer to inner):

file
class        class FMetalShaderFormat : public IShaderFormat
function     virtual void ModifyShaderCompilerInput

Source code excerpt:

		// Work out which standard we need, this is dependent on the shader platform.
		// TODO: Read from toolchain class
		const bool bIsMobile = FMetalCompilerToolchain::Get()->IsMobile((EShaderPlatform)Input.Target.Platform);
		if (bIsMobile)
		{
			Input.Environment.SetDefine(TEXT("IOS"), 1);
		}
		else
		{
			Input.Environment.SetDefine(TEXT("MAC"), 1);

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Components/SkyLightComponent.cpp:1121`

Scope (from outer to inner):

file
function     bool USkyLightComponent::IsRealTimeCaptureEnabled

Source code excerpt:

	// See FORT-301037, FORT-302324	
	// Don't call in PostLoad and SetCaptureIsDirty, because the LocalScene could be null and sky wouldn't be updated on mobile.
	const bool bIsMobile = LocalScene && LocalScene->GetFeatureLevel() <= ERHIFeatureLevel::ES3_1;
	return bRealTimeCapture && (Mobility == EComponentMobility::Movable || Mobility == EComponentMobility::Stationary) && GSkylightRealTimeReflectionCapture >0 && !bIsMobile;
}

void USkyLightComponent::SetRealTimeCaptureEnabled(bool bNewRealTimeCaptureEnabled)
{
	bRealTimeCapture = bNewRealTimeCaptureEnabled;
	MarkRenderStateDirty();

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:597`

Scope (from outer to inner):

file
function     void TGPUSkinVertexFactory<BoneInfluenceType>::ModifyCompilationEnvironment

Source code excerpt:


	// Mobile doesn't support motion blur, don't use previous frame morph delta for mobile.
	const bool bIsMobile = IsMobilePlatform(Parameters.Platform);
	OutEnvironment.SetDefine(TEXT("GPUSKIN_MORPH_USE_PREVIOUS"), !bIsMobile);

	// Whether the material supports morph targets
	OutEnvironment.SetDefine(TEXT("GPUSKIN_MORPH_BLEND"), Parameters.MaterialParameters.bIsUsedWithMorphTargets || Parameters.MaterialParameters.bIsSpecialEngineMaterial);
}

/**

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:910`

Scope (from outer to inner):

file
class        class FGPUSkinVertexFactoryShaderParameters : public FVertexFactoryShaderParameters
function     void GetElementShaderBindings

Source code excerpt:

		// Mobile doesn't support motion blur, don't use previous frame morph delta for mobile.
		const EShaderPlatform ShaderPlatform = GetFeatureLevelShaderPlatform(FeatureLevel);
		const bool bIsMobile = IsMobilePlatform(ShaderPlatform);
		if (!bIsMobile)
		{
			const auto* GPUSkinVertexFactory = (const FGPUBaseSkinVertexFactory*)VertexFactory;
			bool bMorphUpdatedThisFrame = (View->Family->FrameCounter == GPUSkinVertexFactory->GetMorphVertexBufferUpdatedFrameNumber());
			bool bPrevious = !View->Family->bWorldIsPaused && bMorphUpdatedThisFrame;
			const FMorphVertexBuffer* MorphVertexBuffer = GPUSkinVertexFactory->GetMorphVertexBuffer(bPrevious);
			ShaderBindings.Add(PreviousMorphBufferParameter, MorphVertexBuffer ? MorphVertexBuffer->GetSRV() : GNullVertexBuffer.VertexBufferSRV.GetReference());

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:951`

Scope (from outer to inner):

file
function     bool FGPUBaseSkinAPEXClothVertexFactory::IsClothEnabled

Source code excerpt:

	static FShaderPlatformCachedIniValue<bool> MobileEnableClothIniValue(TEXT("r.Mobile.EnableCloth"));
	const bool bEnableClothOnMobile = (MobileEnableClothIniValue.Get(Platform) != 0);
	const bool bIsMobile = IsMobilePlatform(Platform);
	return !bIsMobile || bEnableClothOnMobile;
}


/*-----------------------------------------------------------------------------
	TGPUSkinAPEXClothVertexFactoryShaderParameters
-----------------------------------------------------------------------------*/

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1012`

Scope (from outer to inner):

file
class        class TGPUSkinAPEXClothVertexFactoryShaderParameters : public FGPUSkinVertexFactoryShaderParameters
function     void GetElementShaderBindings

Source code excerpt:

		// Mobile doesn't support motion blur, no need to feed the previous frame cloth data
		const EShaderPlatform ShaderPlatform = GetFeatureLevelShaderPlatform(FeatureLevel);
		const bool bIsMobile = IsMobilePlatform(ShaderPlatform);
		if (!bIsMobile)
		{
			ShaderBindings.Add(PreviousClothSimulVertsPositionsNormalsParameter, ClothShaderData.GetClothBufferForReading(true).VertexBufferSRV);
			ShaderBindings.Add(PreviousClothToLocalParameter, ClothShaderData.GetClothToLocalForReading(true));
		}

		ShaderBindings.Add(GPUSkinApexClothParameter, ClothVertexFactory->GetClothBuffer());

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1194`

Scope (from outer to inner):

file
function     void TGPUSkinAPEXClothVertexFactory<BoneInfluenceType>::ModifyCompilationEnvironment

Source code excerpt:

	
	// Mobile doesn't support motion blur, don't use previous frame data.
	const bool bIsMobile = IsMobilePlatform(Parameters.Platform);
	OutEnvironment.SetDefine(TEXT("GPUSKIN_APEX_CLOTH_PREVIOUS"), !bIsMobile);
}

template <GPUSkinBoneInfluenceType BoneInfluenceType>
bool TGPUSkinAPEXClothVertexFactory<BoneInfluenceType>::ShouldCompilePermutation(const FVertexFactoryShaderPermutationParameters& Parameters)
{
	return IsClothEnabled(Parameters.Platform)

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:435`

Scope (from outer to inner):

file
function     FMaterialRelevance UMaterialInterface::GetRelevance_Internal

Source code excerpt:

		}

		const bool bIsMobile = InFeatureLevel <= ERHIFeatureLevel::ES3_1;
		const bool bUsesSingleLayerWaterMaterial = MaterialResource->GetShadingModels().HasShadingModel(MSM_SingleLayerWater);
		const bool bIsSinglePassWaterTranslucent = bIsMobile && bUsesSingleLayerWaterMaterial;
		const bool bIsMobilePixelProjectedTranslucent = MaterialResource->IsUsingPlanarForwardReflections() 
														&& IsUsingMobilePixelProjectedReflection(GetFeatureLevelShaderPlatform(InFeatureLevel));

		// Note that even though XX_GameThread() api is called, this function can be called on non game thread via 
		// GetRelevance_Concurrent()
		bool bUsesAnisotropy = MaterialResource->GetShadingModels().HasAnyShadingModel({ MSM_DefaultLit, MSM_ClearCoat }) &&

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:464`

Scope (from outer to inner):

file
function     FMaterialRelevance UMaterialInterface::GetRelevance_Internal

Source code excerpt:

		if (bIsTranslucent && bSupportsSeparateTranslucency)
		{
			if (bIsMobile)
			{
				if (Material->bEnableMobileSeparateTranslucency)
				{
					TranslucencyPass = MTP_AfterDOF;
				}
			}

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/PostProcessVolume.cpp:111`

Scope (from outer to inner):

file
function     bool APostProcessVolume::CanEditChange

Source code excerpt:

		PRAGMA_DISABLE_DEPRECATION_WARNINGS
		{
			bool bIsMobile = false;

			if (UWorld* World = GetWorld())
			{
				if (FSceneInterface* Scene = World->Scene)
				{
					bIsMobile = Scene->GetShadingPath(Scene->GetFeatureLevel()) == EShadingPath::Mobile;
				}
			}

			bool bHaveCinematicDOF = !bIsMobile;
			bool bHaveGaussianDOF = bIsMobile;

			if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(FPostProcessSettings, DepthOfFieldScale) ||
				PropertyName == GET_MEMBER_NAME_STRING_CHECKED(FPostProcessSettings, DepthOfFieldNearBlurSize) ||
				PropertyName == GET_MEMBER_NAME_STRING_CHECKED(FPostProcessSettings, DepthOfFieldFarBlurSize) ||
				PropertyName == GET_MEMBER_NAME_STRING_CHECKED(FPostProcessSettings, DepthOfFieldSkyFocusDistance) ||
				PropertyName == GET_MEMBER_NAME_STRING_CHECKED(FPostProcessSettings, DepthOfFieldVignetteSize) ||

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:697`

Scope: file

Source code excerpt:


	const EShaderPlatform ShaderPlatform = GetFeatureLevelShaderPlatform(FeatureLevel);
	const bool bIsMobile = IsMobilePlatform(ShaderPlatform);
	const bool bClothEnabled = FGPUBaseSkinAPEXClothVertexFactory::IsClothEnabled(ShaderPlatform);
	if (bDataPresent)
	{
		bool bSkinCacheResult = true;
		for (int32 SectionIdx = 0; SectionIdx < Sections.Num(); SectionIdx++)
		{

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:806`

Scope: file

Source code excerpt:

			// Mobile doesn't support motion blur so no need to double buffer cloth data.
			// Skin cache doesn't need double buffering, if failed to enter skin cache then the fall back GPU skinned VF needs double buffering.
			if (bClothFactory && !bIsMobile && !SkinCacheEntry && Mode == EGPUSkinCacheEntryMode::Raster)
			{
				FGPUBaseSkinAPEXClothVertexFactory::ClothShaderType& ClothShaderData = VertexFactoryData.ClothVertexFactories[SectionIdx]->GetClothShaderData();
				ClothShaderData.EnableDoubleBuffer();
			}
		}
	}

	// Mobile doesn't support motion blur so no need to double buffer morph deltas
	if (bMorph && !bIsMobile && !SkinCacheEntry && Mode == EGPUSkinCacheEntryMode::Raster && !LOD.MorphVertexBufferPool->IsDoubleBuffered())
	{
		// Going through GPU skinned vertex factory, turn on double buffering for motion blur
		LOD.MorphVertexBufferPool->EnableDoubleBuffer(RHICmdList);
	}
}

#Loc: `<Workspace>/Engine/Source/Runtime/Landscape/Private/Landscape.cpp:2315`

Scope (from outer to inner):

file
function     const TArray<FWeightmapLayerAllocationInfo>& ULandscapeComponent::GetCurrentRuntimeWeightmapLayerAllocations

Source code excerpt:

{

	bool bIsMobile = GetWorld()->GetFeatureLevel() == ERHIFeatureLevel::ES3_1;
	return bIsMobile ? MobileWeightmapLayerAllocations : WeightmapLayerAllocations;
}

TArray<FWeightmapLayerAllocationInfo>& ULandscapeComponent::GetCurrentRuntimeWeightmapLayerAllocations()
{
	bool bIsMobile = GetWorld()->GetFeatureLevel() == ERHIFeatureLevel::ES3_1;
	return bIsMobile ? MobileWeightmapLayerAllocations : WeightmapLayerAllocations;
}

#if WITH_EDITOR

FLandscapeLayerComponentData* ULandscapeComponent::GetEditingLayer()
{

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Private/DataDrivenShaderPlatformInfo.cpp:198`

Scope (from outer to inner):

file
function     void FGenericDataDrivenShaderPlatformInfo::ParseDataDrivenShaderInfo

Source code excerpt:

	ADD_PROPERTY_TO_SHADERPLATFORM_FUNCTIONMAP(IsConsole, GetIsConsole);

	GET_SECTION_BOOL_HELPER(bIsMobile);
	GET_SECTION_BOOL_HELPER(bIsMetalMRT);
	GET_SECTION_BOOL_HELPER(bIsPC);
	GET_SECTION_BOOL_HELPER(bIsConsole);
	GET_SECTION_BOOL_HELPER(bIsAndroidOpenGLES);
	GET_SECTION_BOOL_HELPER(bSupportsDebugViewShaders);
	GET_SECTION_BOOL_HELPER(bSupportsMobileMultiView);

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:23`

Scope (from outer to inner):

file
class        class FGenericDataDrivenShaderPlatformInfo

Source code excerpt:

	FName ShaderFormat;
	uint32 ShaderPropertiesHash;
	uint32 bIsMobile : 1;
	uint32 bIsMetalMRT : 1;
	uint32 bIsPC : 1;
	uint32 bIsConsole : 1;
	uint32 bIsAndroidOpenGLES : 1;

	uint32 bSupportsDebugViewShaders : 1;

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:203`

Scope (from outer to inner):

file
class        class FGenericDataDrivenShaderPlatformInfo
function     static const bool GetIsMobile

Source code excerpt:

	{
		check(IsValid(Platform));
		return Infos[Platform].bIsMobile;
	}

	static FORCEINLINE_DEBUGGABLE const bool GetIsMetalMRT(const FStaticShaderPlatform Platform)
	{
		check(IsValid(Platform));
		return Infos[Platform].bIsMetalMRT;

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:78`

Scope (from outer to inner):

file
function     FDeferredDecalPassTextures GetDeferredDecalPassTextures

Source code excerpt:

	auto* Parameters = GraphBuilder.AllocParameters<FDecalPassUniformParameters>();
	
	const bool bIsMobile = (View.GetFeatureLevel() == ERHIFeatureLevel::ES3_1);
	ESceneTextureSetupMode TextureReadAccess = ESceneTextureSetupMode::None;
	EMobileSceneTextureSetupMode MobileTextureReadAccess = EMobileSceneTextureSetupMode::None;
	if (bIsMobile)
	{
		MobileTextureReadAccess = EMobileSceneTextureSetupMode::SceneDepth | EMobileSceneTextureSetupMode::CustomDepth;
	}
	else
	{
		TextureReadAccess = ESceneTextureSetupMode::GBufferA | ESceneTextureSetupMode::SceneDepth | ESceneTextureSetupMode::CustomDepth;

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:99`

Scope (from outer to inner):

file
function     FDeferredDecalPassTextures GetDeferredDecalPassTextures

Source code excerpt:


	// Mobile deferred renderer does not use dbuffer 
	if (!bIsMobile)
	{
		PassTextures.GBufferA = (*SceneTextures.UniformBuffer)->GBufferATexture;
		PassTextures.GBufferB = (*SceneTextures.UniformBuffer)->GBufferBTexture;
		PassTextures.GBufferC = (*SceneTextures.UniformBuffer)->GBufferCTexture;
		PassTextures.GBufferE = (*SceneTextures.UniformBuffer)->GBufferETexture;
	}

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2889`

Scope (from outer to inner):

file
function     FSceneRenderer::FSceneRenderer

Source code excerpt:

			&& ViewFamily.EngineShowFlags.SeparateTranslucency;

		const bool bIsMobile = ViewFamily.GetFeatureLevel() == ERHIFeatureLevel::ES3_1;
		if (bIsMobile)
		{
			const bool bMobileMSAA = GetDefaultMSAACount(ERHIFeatureLevel::ES3_1) > 1;
			SeparateTranslucencyEnabled &= (IsMobileHDR() && !bMobileMSAA); // on <= ES3_1 separate translucency requires HDR on and MSAA off
		}

		ViewFamily.bAllowTranslucencyAfterDOF = SeparateTranslucencyEnabled && CVarAllowTranslucencyAfterDOF.GetValueOnAnyThread() != 0;

		if (!ViewFamily.bAllowTranslucencyAfterDOF && !bIsMobile && CVarTSRForceSeparateTranslucency.GetValueOnAnyThread() != 0)
		{
			for (FViewInfo* View : AllViews)
			{
				if (View->AntiAliasingMethod == AAM_TSR)
				{
					ViewFamily.bAllowTranslucencyAfterDOF = true;

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2913`

Scope (from outer to inner):

file
function     FSceneRenderer::FSceneRenderer

Source code excerpt:

		// When MSAA sample count is >1 it works, but hair has not been properly tested so far due to other issues, so MSAA cannot use separted standard translucent for now.
		uint32 MSAASampleCount = GetDefaultMSAACount(ViewFamily.GetFeatureLevel());
		ViewFamily.bAllowStandardTranslucencySeparated = SeparateTranslucencyEnabled && MSAASampleCount == 1 && !bIsMobile && CVarTranslucencyStandardSeparated.GetValueOnAnyThread() != 0;
	}

	check(!ViewFamily.AllViews.Num());
	ViewFamily.AllViews.Append(AllViews);

	Scene->CustomRenderPassRendererInputs.Reset();

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:120`

Scope (from outer to inner):

file
class        class FWaterInfoTexturePassMeshProcessor : public FSceneRenderingAllocatorObject<FWaterInfoTexturePassMeshProcessor>, public FMeshPassProcessor

Source code excerpt:

{
public:
	FWaterInfoTexturePassMeshProcessor(const FScene* Scene, ERHIFeatureLevel::Type FeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext, bool bIsMobile);

	virtual void AddMeshBatch(const FMeshBatch& RESTRICT MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, int32 StaticMeshId = -1) override final;
	virtual void CollectPSOInitializers(const FSceneTexturesConfig& SceneTexturesConfig, const FMaterial& Material, const FPSOPrecacheVertexFactoryData& VertexFactoryData, const FPSOPrecacheParams& PreCacheParams, TArray<FPSOPrecacheData>& PSOInitializers) override final;

private:
	bool TryAddMeshBatch(

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:136`

Scope (from outer to inner):

file
class        class FWaterInfoTexturePassMeshProcessor : public FSceneRenderingAllocatorObject<FWaterInfoTexturePassMeshProcessor>, public FMeshPassProcessor

Source code excerpt:

	FMeshPassProcessorRenderState PassDrawRenderState;
	TArray<const TCHAR*, TInlineAllocator<1>> MaterialAllowList;
	bool bIsMobile;
};

FWaterInfoTexturePassMeshProcessor::FWaterInfoTexturePassMeshProcessor(const FScene* Scene, ERHIFeatureLevel::Type FeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext, bool bIsMobile)
	: FMeshPassProcessor(EMeshPass::WaterInfoTexturePass, Scene, FeatureLevel, InViewIfDynamicMeshCommand, InDrawListContext),
	bIsMobile(bIsMobile)
{
	PassDrawRenderState.SetBlendState(TStaticBlendState<>::GetRHI());
	PassDrawRenderState.SetDepthStencilAccess(FExclusiveDepthStencil::DepthWrite_StencilNop);
	PassDrawRenderState.SetDepthStencilState(TStaticDepthStencilState<true, CF_DepthNearOrEqual>::GetRHI());

	// HACK: This whole path for rendering the water info texture is a temporary solution, so in order to avoid supporting generic material setups, we use an allow list to restrict

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:193`

Scope (from outer to inner):

file
function     void FWaterInfoTexturePassMeshProcessor::CollectPSOInitializers

Source code excerpt:

		SetupDepthStencilInfo(PF_DepthStencil, TexCreate_DepthStencilTargetable | TexCreate_ShaderResource, ERenderTargetLoadAction::EClear, ERenderTargetLoadAction::ENoAction, FExclusiveDepthStencil::DepthWrite_StencilNop, RenderTargetsInfo);

		if (!bIsMobile)
		{
			// Get the shaders if possible for given vertex factory
			TMeshProcessorShaders<
				TBasePassVertexShaderPolicyParamType<FUniformLightMapPolicy>,
				TBasePassPixelShaderPolicyParamType<FUniformLightMapPolicy>> PassShaders;
			if (!GetBasePassShaders<FUniformLightMapPolicy>(

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:275`

Scope (from outer to inner):

file
function     bool FWaterInfoTexturePassMeshProcessor::TryAddMeshBatch

Source code excerpt:

		const FVertexFactory* VertexFactory = MeshBatch.VertexFactory;

		if (!bIsMobile)
		{
			TMeshProcessorShaders<
				TBasePassVertexShaderPolicyParamType<FUniformLightMapPolicy>,
				TBasePassPixelShaderPolicyParamType<FUniformLightMapPolicy>> PassShaders;

			if (!GetBasePassShaders<FUniformLightMapPolicy>(

#Loc: `<Workspace>/Engine/Source/Runtime/Sockets/Private/IOS/SocketSubsystemIOS.cpp:169`

Scope (from outer to inner):

file
function     bool FSocketSubsystemIOS::GetLocalAdapterAddresses

Source code excerpt:

			// Also drop any interface that's not a wifi or mobile adapter
			bool bIsWifi = strncmp(Travel->ifa_name, "en", 2) == 0;
			bool bIsMobile = strncmp(Travel->ifa_name, "pdp_ip", 6) == 0;
			if (!bIsWifi && !bIsMobile)
			{
				continue;
			}

			// Otherwise, this is an address we can consider.
			FSortedPriorityAddresses NewAddress(this);

bIsMobile

bIsMobile

#Overview

#Summary

#Usage in the C++ source code

#Setting Variables

#References In INI files

#References in C++ code

#Callsites

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:281

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:764

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:901

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:915

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:937

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:960

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:982

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1010

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1042

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1099

#Loc: <Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderFormat.cpp:339

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Components/SkyLightComponent.cpp:1121

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:597

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:910

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:951

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1012

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1194

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:435

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:464

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PostProcessVolume.cpp:111

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:697

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:806

#Loc: <Workspace>/Engine/Source/Runtime/Landscape/Private/Landscape.cpp:2315

#Loc: <Workspace>/Engine/Source/Runtime/RHI/Private/DataDrivenShaderPlatformInfo.cpp:198

#Loc: <Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:23

#Loc: <Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:203

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:78

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:99

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2889

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2913

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:120

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:136

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:193

#Loc: <Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:275

#Loc: <Workspace>/Engine/Source/Runtime/Sockets/Private/IOS/SocketSubsystemIOS.cpp:169

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:281`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:764`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:901`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:915`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:937`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:960`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:982`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1010`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1042`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderCompiler.cpp:1099`

#Loc: `<Workspace>/Engine/Source/Developer/Apple/MetalShaderFormat/Private/MetalShaderFormat.cpp:339`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Components/SkyLightComponent.cpp:1121`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:597`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:910`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:951`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1012`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/GPUSkinVertexFactory.cpp:1194`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:435`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/Materials/MaterialInterface.cpp:464`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/PostProcessVolume.cpp:111`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:697`

#Loc: `<Workspace>/Engine/Source/Runtime/Engine/Private/SkeletalRenderGPUSkin.cpp:806`

#Loc: `<Workspace>/Engine/Source/Runtime/Landscape/Private/Landscape.cpp:2315`

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Private/DataDrivenShaderPlatformInfo.cpp:198`

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:23`

#Loc: `<Workspace>/Engine/Source/Runtime/RHI/Public/DataDrivenShaderPlatformInfo.h:203`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:78`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/CompositionLighting/PostProcessDeferredDecals.cpp:99`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2889`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/SceneRendering.cpp:2913`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:120`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:136`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:193`

#Loc: `<Workspace>/Engine/Source/Runtime/Renderer/Private/WaterInfoTextureRendering.cpp:275`

#Loc: `<Workspace>/Engine/Source/Runtime/Sockets/Private/IOS/SocketSubsystemIOS.cpp:169`