,	bIsHierarchicalInstancedStaticMesh(false)
,	bIsLandscapeGrass(false)
,	bSupportsGPUScene(false)
,	bHasDeformableMesh(true)
,	bEvaluateWorldPositionOffset(true)
,	bHasWorldPositionOffsetVelocity(false)
,	bAnyMaterialHasWorldPositionOffset(false)
,	bAnyMaterialAlwaysEvaluatesWorldPositionOffset(false)
,	bAnyMaterialHasPixelAnimation(false)	

file
function     void FPrimitiveSceneProxy::EnableGPUSceneSupportFlags

	bVFRequiresPrimitiveUniformBuffer = !bUseGPUScene;
	// For mobile we always assume that proxy does not support GPUScene, as it depends on vertex factory setup which happens later
	bSupportsGPUScene = bMobilePath ? false : bUseGPUScene;
}

/**
 * Updates the hidden editor view visibility map on the game thread which just enqueues a command on the render thread
 */
void FPrimitiveSceneProxy::SetHiddenEdViews_GameThread( uint64 InHiddenEditorViews )

file
class        class FPrimitiveSceneProxy
function     inline bool SupportsGPUScene

	inline bool SupportsGPUScene() const
	{
		return bSupportsGPUScene;
	}

	/**
	 * Returns true if this proxy has any deformable mesh, meaning the mesh is animated e.g., by deforming the vertices through skinning, morphing or some procedural update.
	 * WPO and PDO are not considered here (as they are material effects).
	 */

file
class        class FPrimitiveSceneProxy

	/** True if all meshes (AKA all vertex factories) drawn by this proxy support GPU scene (default is false). */
	uint8 bSupportsGPUScene : 1;

	/** True if the mesh representation is deformable (see HasDeformableMesh() above for more details). Defaults to true to be conservative. */
	uint8 bHasDeformableMesh : 1;

	/** Whether the primitive should evaluate any World Position Offset. */
	uint8 bEvaluateWorldPositionOffset : 1;

file
function     void FGenericDataDrivenShaderPlatformInfo::ParseDataDrivenShaderInfo

	GET_SECTION_BOOL_HELPER(bSupportsHighEndRayTracingEffects);
	GET_SECTION_BOOL_HELPER(bSupportsByteBufferComputeShaders);
	GET_SECTION_BOOL_HELPER(bSupportsGPUScene);
	GET_SECTION_BOOL_HELPER(bSupportsPrimitiveShaders);
	GET_SECTION_BOOL_HELPER(bSupportsUInt64ImageAtomics);
	GET_SECTION_BOOL_HELPER(bRequiresVendorExtensionsForAtomics);
	GET_SECTION_BOOL_HELPER(bSupportsNanite);
	GET_SECTION_BOOL_HELPER(bSupportsLumenGI);
	GET_SECTION_BOOL_HELPER(bSupportsSSDIndirect);

file
function     void FGenericDataDrivenShaderPlatformInfo::UpdatePreviewPlatforms

				// Settings that need to match the runtime
				PREVIEW_USE_RUNTIME_VALUE(bSupportsGPUScene);
				PREVIEW_USE_RUNTIME_VALUE(MaxMeshShaderThreadGroupSize);
				PREVIEW_USE_RUNTIME_VALUE(bSupportsSceneDataCompressedTransforms);
				PREVIEW_USE_RUNTIME_VALUE(bSupportsVertexShaderSRVs);
				PREVIEW_USE_RUNTIME_VALUE(bSupportsManualVertexFetch);
				PREVIEW_USE_RUNTIME_VALUE(bSupportsRealTypes);
				PREVIEW_USE_RUNTIME_VALUE(bSupportsUniformBufferObjects);

file
class        class FGenericDataDrivenShaderPlatformInfo

	uint32 bSupportsHighEndRayTracingEffects : 1; // Whether fully-featured RT effects can be used on the platform (with translucent shadow, etc.)
	uint32 bSupportsPathTracing : 1; // Whether real-time path tracer is supported on this platform (avoids compiling unnecessary shaders)
	uint32 bSupportsGPUScene : 1;
	uint32 bSupportsByteBufferComputeShaders : 1;
	uint32 bSupportsPrimitiveShaders : 1;
	uint32 bSupportsUInt64ImageAtomics : 1;
	uint32 bRequiresVendorExtensionsForAtomics : 1;
	uint32 bSupportsNanite : 1;
	uint32 bSupportsLumenGI : 1;

file
class        class FGenericDataDrivenShaderPlatformInfo
function     static const bool GetSupportsGPUScene

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

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

file
class        class FBatchingSPDI : public FStaticPrimitiveDrawInterface
function     virtual void DrawMesh

			bool bUseAnisotropy = Material.GetShadingModels().HasAnyShadingModel({MSM_DefaultLit, MSM_ClearCoat}) && Material.MaterialUsesAnisotropy_RenderThread();
			bool bSupportsNaniteRendering = SupportsNaniteRendering(StaticMesh->VertexFactory, PrimitiveSceneProxy, Mesh.MaterialRenderProxy, FeatureLevel);
			bool bSupportsGPUScene = StaticMesh->VertexFactory->SupportsGPUScene(FeatureLevel);
			bool bUseForWaterInfoTextureDepth = Mesh.bUseForWaterInfoTextureDepth;
			bool bUseForLumenSceneCapture = Mesh.bUseForLumenSurfaceCacheCapture;

			FStaticMeshBatchRelevance* StaticMeshRelevance = new(PrimitiveSceneInfo->StaticMeshRelevances) FStaticMeshBatchRelevance(
				*StaticMesh, 
				ScreenSize, 

file
class        class FBatchingSPDI : public FStaticPrimitiveDrawInterface
function     virtual void DrawMesh

				bUseAnisotropy,
				bSupportsNaniteRendering,
				bSupportsGPUScene,
				bUseForWaterInfoTextureDepth,
				bUseForLumenSceneCapture,
				FeatureLevel
				);
		}
	}

file
function     FPrimitiveFlagsCompact::FPrimitiveFlagsCompact

	, bIsNaniteMesh(Proxy->IsNaniteMesh())
	, bIsAlwaysVisible(Proxy->IsAlwaysVisible())
	, bSupportsGPUScene(Proxy->SupportsGPUScene())
{}

FPrimitiveSceneInfoCompact::FPrimitiveSceneInfoCompact(FPrimitiveSceneInfo* InPrimitiveSceneInfo) :
	PrimitiveFlagsCompact(InPrimitiveSceneInfo->Proxy)
{
	PrimitiveSceneInfo = InPrimitiveSceneInfo;

file
function     bool FProjectedShadowInfo::ShouldDrawStaticMesh

		bOutDrawingStaticMeshes = true;

		if (EnumHasAnyFlags(MeshSelectionMask, StaticMeshRelevance.bSupportsGPUScene ? EShadowMeshSelection::VSM : EShadowMeshSelection::SM))
		{
			return true;
		}
	}
	return false;
}

file
function     uint64 FProjectedShadowInfo::AddSubjectPrimitive_AnyThread

			}

			// EShadowMeshSelection::All is intentional because bSupportsGPUScene being false may indicate that some VFs (e.g., some LODs) support GPUScene while others don't
			// thus we have to leave the final decision until the mesh batches are produced.
			if (!bDrawingStaticMeshes && bDynamicRelevance && EnumHasAnyFlags(MeshSelectionMask, PrimitiveSceneInfoCompact.PrimitiveFlagsCompact.bSupportsGPUScene ? EShadowMeshSelection::VSM : EShadowMeshSelection::All))
			{
				Result.bDynamicSubjectPrimitive = true;
				++OutStats.NumDynamicSubs;
			}
		}

file
function     FStaticMeshBatchRelevance::FStaticMeshBatchRelevance

	, bSupportsCachingMeshDrawCommands(InbSupportsCachingMeshDrawCommands)
	, bSupportsNaniteRendering(bInSupportsNaniteRendering)
	, bSupportsGPUScene(bInSupportsGPUScene)
	, bUseForWaterInfoTextureDepth(bInUseForWaterInfoTextureDepth)
	, bUseForLumenSceneCapture(bInUseForLumenSceneCapture)
{
}

int32 FStaticMeshBatchRelevance::GetStaticMeshCommandInfoIndex(EMeshPass::Type MeshPass) const

	/** True if the primitive draws only meshes that support GPU-Scene. */
	uint8 bSupportsGPUScene : 1;

	FPrimitiveFlagsCompact(const FPrimitiveSceneProxy* Proxy);
};

/** The information needed to determine whether a primitive is visible. */
class FPrimitiveSceneInfoCompact

file
class        class FStaticMeshBatchRelevance

	/** Cached from vertex factory to avoid dereferencing VF in shadow depth rendering. */
	uint8 bSupportsGPUScene : 1;

	/** Whether the mesh batch should be used in the depth-only passes of rendering the water info texture for the water plugin */
	uint8 bUseForWaterInfoTextureDepth : 1;

	/** Cached from lumen scene card capture */
	uint8 bUseForLumenSceneCapture : 1;