diff --git a/.obsidian/plugins/various-complements/data.json b/.obsidian/plugins/various-complements/data.json index 91de3a3..0f72d01 100644 --- a/.obsidian/plugins/various-complements/data.json +++ b/.obsidian/plugins/various-complements/data.json @@ -134,6 +134,14 @@ "lastUpdated": 1707223827335 } } + }, + "此外，UMaterialInstance的部分接口也会触发FMaterialResource实例的创建，此文不继续追踪了。": { + "此外，UMaterialInstance的部分接口也会触发FMaterialResource实例的创建，此文不继续追踪了。": { + "currentFile": { + "count": 1, + "lastUpdated": 1707302668655 + } + } } } } \ No newline at end of file diff --git a/03-UnrealEngine/Rendering/RenderingPipeline/向往渲染系列文章阅读笔记/剖析虚幻渲染体系（09）- 材质体系.md b/03-UnrealEngine/Rendering/RenderingPipeline/向往渲染系列文章阅读笔记/剖析虚幻渲染体系（09）- 材质体系.md index 7376699..46e68ff 100644 --- a/03-UnrealEngine/Rendering/RenderingPipeline/向往渲染系列文章阅读笔记/剖析虚幻渲染体系（09）- 材质体系.md +++ b/03-UnrealEngine/Rendering/RenderingPipeline/向往渲染系列文章阅读笔记/剖析虚幻渲染体系（09）- 材质体系.md @@ -8,4 +8,1621 @@ rating: ⭐ # 前言 https://www.cnblogs.com/timlly/p/15109132.html -# UMaterial \ No newline at end of file +# 概念 +- UMaterialInterface：材质的基础接口类, 定义了大量材质相关的数据和接口, 部分接口是空实现或未实现的接口。 + - USubsurfaceProfile* SubsurfaceProfile：次表面散射轮廓，常用于皮肤、玉石等材质。 + - TArray AssetUserData：用户数据，可以存多个数据。 + - FLightmassMaterialInterfaceSettings LightmassSettings：离线GI数据。 + - TArray TextureStreamingData：纹理流数据。 +- UMaterial：材质类，继承自 UMaterialInterface，对应着一个材质资源文件。定义了材质所需的所有数据和操作接口，并负责打通其它关联类型的链接。 + - TArray MaterialResources：材质渲染资源，一个材质可以拥有多个渲染资源实例。 + - FDefaultMaterialInstance* DefaultMaterialInstance：默认的材质渲染代理，继承自FMaterialRenderProxy。 + - UPhysicalMaterial* PhysMaterial：物理材质。 + - TArray LoadedMaterialResources：已经加载的材质资源，通常由游戏线程从磁盘加载并序列化而来。 + - 材质的各种属性和标记。 +- UMaterialInstance：材质实例，**不能单独存在**，而**需要依赖UMaterialInterface类型的父类**，意味着父类可以是UMaterialInterface的任意一个子类，但最上层的父类必须是UMaterial。 + - UMaterialInstanceConstant：为了**避免运行时因修改材质参数而引起重新编译**，它内部有限的数据覆盖也是因为此。如果不重新编译，就无法支持对材质的常规修改，因此实例只能更改预定义的材质参数的值。 这里的参数就是在材质编辑器内定义的唯一的名称、类型和默认值静态定义。另外，需要明确注意的是，在运行时的代码（非编辑器代码）中，我们是无法更改UMaterialInstanceConstant实例的材质属性。UMaterialInstanceConstant还有一个专用于渲染地貌的ULandscapeMaterialInstanceConstant的子类。 + - UMaterialInstanceDynamic：提供了可以在**运行时代码动态创建和修改材质属性的功能**，并且同样**不会引起材质重新编译**。 +- **FMaterialRenderProxy**：FMaterialRenderProxy负责**接收游戏线程代表的数据，然后传递给渲染器去处理和渲染**。FMaterialRenderProxy是个抽象类，定义了一个静态全局的材质渲染代理映射表和获取FMaterial渲染实例的接口。具体的逻辑由子类完成。 + - **FDefaultMaterialInstance**：渲染UMaterial的默认代表实例。 + - **FMaterialInstanceResource**：渲染UMaterialInstance实例的代表。 + - FColoredMaterialRenderProxy：覆盖材质颜色向量参数的材质渲染代表。 + - FLandscapeMaskMaterialRenderProxy：地貌遮罩材质渲染代表。 + - FLightmassMaterialProxy：Lightmass材质渲染代理。 + - ...... +- **FMaterial**： + - **描述材质的编译过程**，并提供可扩展性钩子(CompileProperty等) 。 + - **将材质属性传递到渲染器**，并使用函数访问材质属性。 + - 存储缓存的**ShaderMap**（GameThread & RenderingThread），和其他来自编译的瞬态输出，这对异步着色器编译是必要的。 +- **FMaterialResource**：继承自FMaterial，实现**材质接口**。 + - 拥有对应的UMaterial、UMaterialInstance指针。 + +![[UE_UMaterial.png]] +UE的材质为何会有如此多的概念和类型，它们的关系到底怎么样？本节尝试阐述它们的关联和作用。 + +首先阐述**UMaterialInterface和它的子类们，它们是引擎模块在游戏线程的代表**。UMaterialInterface继承UOjbect，提供了材质的抽象接口，为子类提供了一致的行为和规范，也好统一不同类型的子类之间的差异。子类UMaterial则对应着用材质编辑器生成的材质蓝图的资源，保存了各种表达式节点及各种参数。另一个子类UMaterialInstance则抽象了材质实例的接口，是为了支持修改材质参数后不引发材质重新编译而存在的，同时统一和规范固定实例（UMaterialInstanceConstant）和动态实例（UMaterialInstanceDynamic）两种子类的数据和行为。UMaterialInstanceConstant在编辑器期间创建和修改好材质参数，运行时不可修改，提升数据更新和渲染的性能；UMaterialInstanceDynamic则可以运行时创建实例和修改数据，提升材质的扩展性和可定制性，但性能较UMaterialInstanceConstant差一些。UMaterialInstance需要指定一个父类，最顶层的父类要求是UMaterial实例。 + +**FMaterialRenderProxy是UMaterialInterface的渲染线程的代表**，类似于UPrimitiveComponent和FPrimitiveSceneProxy的关系。**FMaterialRenderProxy将UMaterialInterface实例的数据搬运（拷贝）到渲染线程，但同时也会在游戏线程被访问到，是两个线程的耦合类型，需要谨慎处理它们的数据和接口调用**。**FMaterialRenderProxy的子类对应着UMaterialInterface的子类，以便将UMaterialInterface的子类数据被精准地搬运（拷贝）到渲染线程，避免游戏线程和渲染线程的竞争**。FMaterialRenderProxy及其子类都是引擎模块的类型。 + +既然已经有了FMaterialRenderProxy的渲染线程代表，为什么还要存在FMaterial和FMaterialResource呢？答案有两点： +- FMaterialRenderProxy及其子类是引擎模块的类型，是游戏线程和渲染线程的胶囊类，需要谨慎处理两个线程的数据和接口调用，渲染模块无法真正完全拥有它的管辖权。 +- FMaterialRenderProxy的数据由UMaterialInterface传递而来，意味着FMaterialRenderProxy的信息有限，无法包含使用了材质的网格的其它信息，如顶点工厂、ShaderMap、ShaderPipelineline、FShader及各种着色器参数等。 + +所以，FMaterial应运而生。FMaterial同是引擎模块的类型，但存储了游戏线程和渲染线程的两个ShaderMap，意味着渲染模块可以自由地访问渲染线程的ShaderMap，而又不影响游戏线程的访问。而且FMaterial包含了渲染材质所需的所有数据，渲染器的其它地方，只要拿到网格的FMaterial，便可以正常地获取材质数据，从而提交绘制指令。比如FBasePassMeshProcessor::AddMeshBatch的代码： +```c++ +// Engine\Source\Runtime\Renderer\Private\BasePassRendering.cpp + +void FBasePassMeshProcessor::AddMeshBatch(const FMeshBatch& RESTRICT MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, int32 StaticMeshId) +{ + if (MeshBatch.bUseForMaterial) + { + const FMaterialRenderProxy* FallbackMaterialRenderProxyPtr = nullptr; + // 获取FMaterial实例. + const FMaterial& Material = MeshBatch.MaterialRenderProxy->GetMaterialWithFallback(FeatureLevel, FallbackMaterialRenderProxyPtr); + const FMaterialRenderProxy& MaterialRenderProxy = FallbackMaterialRenderProxyPtr ? *FallbackMaterialRenderProxyPtr : *MeshBatch.MaterialRenderProxy; + + // 通过FMaterial接口获取材质数据. + const EBlendMode BlendMode = Material.GetBlendMode(); + const FMaterialShadingModelField ShadingModels = Material.GetShadingModels(); + const bool bIsTranslucent = IsTranslucentBlendMode(BlendMode); + const FMeshDrawingPolicyOverrideSettings OverrideSettings = ComputeMeshOverrideSettings(MeshBatch); + const ERasterizerFillMode MeshFillMode = ComputeMeshFillMode(MeshBatch, Material, OverrideSettings); + const ERasterizerCullMode MeshCullMode = ComputeMeshCullMode(MeshBatch, Material, OverrideSettings); + + (......) +} +``` + +>其实应该说**FMaterial**与**FMaterialResource**从FMaterialRenderProxy中将**有多线程竞争风险的渲染所需数据进行剥离**。渲染器只需要拿到FMaterial就可以获取Shader数据并进行MeshBatch提交。 +>在FMaterialRenderProxy中通过**GetMaterialXXX()** 系列函数获取FMaterial。如果Shader没有编译好会进行等待，并在等待完之后返回。GetMaterialFallbackXXX()系列函数会不断递归获取有效的FMaterial直到默认UMaterial::GetDefaultMaterial()。 +>从UMaterial调用GetRenderProxy()获取**FDefaultMaterialInstance DefaultMaterialInstance**，而这个变量在**UMaterial::PostInitProperties()** 通过**DefaultMaterialInstance = new FDefaultMaterialInstance(this);** 初始化。 +# UMaterial +UMaterial是属于引擎层的概念，对应着我们在材质编辑器编辑的uasset资源文件，可以被应用到网格上，以便控制它在场景中的视觉效果。它继承自UMaterialInterface。 +```c++ +// Engine\Source\Runtime\Engine\Classes\Materials\MaterialInterface.h + +// 材质的基础接口类, 定义了大量材质相关的数据和接口, 部分接口是空实现或未实现的接口. +class UMaterialInterface : public UObject, public IBlendableInterface, public IInterface_AssetUserData +{ + // 次表面散射轮廓(配置) + class USubsurfaceProfile* SubsurfaceProfile; + // 当图元不再被用作父元素时进行跟踪的栅栏. + FRenderCommandFence ParentRefFence; + +protected: + // Lightmass离线的GI设置. + struct FLightmassMaterialInterfaceSettings LightmassSettings; + // 纹理流数据. + TArray TextureStreamingData; + // 存于此材质资源内的用户数据列表. + TArray AssetUserData; + +private: + // 强制编译的目标Feature Level. + uint32 FeatureLevelsToForceCompile; + +public: + //---- IInterface_AssetUserData接口 ---- + virtual void AddAssetUserData(UAssetUserData* InUserData) override; + virtual void RemoveUserDataOfClass(TSubclassOf InUserDataClass) override; + virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf InUserDataClass) override; + //---- IInterface_AssetUserData接口 ---- + + // 为所有材质编译的Featurelevel位域. + static uint32 FeatureLevelsForAllMaterials; + void SetFeatureLevelToCompile(ERHIFeatureLevel::Type FeatureLevel, bool bShouldCompile); + static void SetGlobalRequiredFeatureLevel(ERHIFeatureLevel::Type FeatureLevel, bool bShouldCompile); + + //---- UObject接口 ---- + virtual void BeginDestroy() override; + virtual bool IsReadyForFinishDestroy() override; + virtual void PostLoad() override; + virtual void PostDuplicate(bool bDuplicateForPIE) override; + virtual void PostCDOContruct() override; + //---- UObject接口 ---- + + //---- IBlendableInterface接口 ---- + virtual void OverrideBlendableSettings(class FSceneView& View, float Weight) const override; + //---- IBlendableInterface接口 ---- + + // 沿着父链查找这个实例所在的基础材质. + UMaterial* GetBaseMaterial(); + // 获取正在实例化的材质 + virtual class UMaterial* GetMaterial() PURE_VIRTUAL(UMaterialInterface::GetMaterial,return NULL;); + virtual const class UMaterial* GetMaterial() const PURE_VIRTUAL(UMaterialInterface::GetMaterial,return NULL;); + // 获取正在实例化的材质(并发模式) + virtual const class UMaterial* GetMaterial_Concurrent(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const PURE_VIRTUAL(UMaterialInterface::GetMaterial_Concurrent,return NULL;); + + // 测试该材质是否依赖指定的材料. + virtual bool IsDependent(UMaterialInterface* TestDependency); + virtual bool IsDependent_Concurrent(UMaterialInterface* TestDependency, TMicRecursionGuard RecursionGuard = TMicRecursionGuard()); + + // 获取此材质对应的用于渲染的FMaterialRenderProxy实例. + virtual class FMaterialRenderProxy* GetRenderProxy() const PURE_VIRTUAL(UMaterialInterface::GetRenderProxy,return NULL;); + + (......) + + // 获取用于渲染此材质的纹理列表. + virtual void GetUsedTextures(TArray& OutTextures, EMaterialQualityLevel::Type QualityLevel, bool bAllQualityLevels, ERHIFeatureLevel::Type FeatureLevel, bool bAllFeatureLevels) const + PURE_VIRTUAL(UMaterialInterface::GetUsedTextures,); + // 获取用于渲染此材质的纹理列表和索引. + virtual void GetUsedTexturesAndIndices(TArray& OutTextures, TArray< TArray >& OutIndices, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel) const; + // 覆盖指定的纹理. + virtual void OverrideTexture(const UTexture* InTextureToOverride, UTexture* OverrideTexture, ERHIFeatureLevel::Type InFeatureLevel) PURE_VIRTUAL(UMaterialInterface::OverrideTexture, return;); + + // 覆盖给定参数的默认值(短暂的) + virtual void OverrideVectorParameterDefault(const FHashedMaterialParameterInfo& ParameterInfo, const FLinearColor& Value, bool bOverride, ERHIFeatureLevel::Type FeatureLevel) PURE_VIRTUAL(UMaterialInterface::OverrideTexture, return;); + + // 检测指定的材质标记, 如果存在就返回true. + virtual bool CheckMaterialUsage(const EMaterialUsage Usage) PURE_VIRTUAL(UMaterialInterface::CheckMaterialUsage,return false;); + virtual bool CheckMaterialUsage_Concurrent(const EMaterialUsage Usage) const PURE_VIRTUAL(UMaterialInterface::CheckMaterialUsage,return false;); + + // 获取材质的渲染纹理, 需要指定FeatureLevel/QualityLevel. + virtual FMaterialResource* GetMaterialResource(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num); + + // 获取组排序优先级. + virtual bool GetGroupSortPriority(const FString& InGroupName, int32& OutSortPriority) const + PURE_VIRTUAL(UMaterialInterface::GetGroupSortPriority, return false;); + + // 获取材质的各种类型的所有数据. + virtual void GetAllScalarParameterInfo(TArray& OutParameterInfo, TArray& OutParameterIds) const + PURE_VIRTUAL(UMaterialInterface::GetAllScalarParameterInfo,return;); + virtual void GetAllVectorParameterInfo(TArray& OutParameterInfo, TArray& OutParameterIds) const + PURE_VIRTUAL(UMaterialInterface::GetAllVectorParameterInfo,return;); + virtual void GetAllTextureParameterInfo(TArray& OutParameterInfo, TArray& OutParameterIds) const + PURE_VIRTUAL(UMaterialInterface::GetAllTextureParameterInfo,return;); + virtual void GetAllRuntimeVirtualTextureParameterInfo(TArray& OutParameterInfo, TArray& OutParameterIds) const + PURE_VIRTUAL(UMaterialInterface::GetAllRuntimeVirtualTextureParameterInfo, return;); + virtual void GetAllFontParameterInfo(TArray& OutParameterInfo, TArray& OutParameterIds) const + PURE_VIRTUAL(UMaterialInterface::GetAllFontParameterInfo,return;); + + // 获取材质的各种类型的数据. + virtual bool GetScalarParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, float& OutValue, bool bOveriddenOnly = false, bool bCheckOwnedGlobalOverrides = false) const + PURE_VIRTUAL(UMaterialInterface::GetScalarParameterDefaultValue,return false;); + virtual bool GetVectorParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor& OutValue, bool bOveriddenOnly = false, bool bCheckOwnedGlobalOverrides = false) const + PURE_VIRTUAL(UMaterialInterface::GetVectorParameterDefaultValue,return false;); + virtual bool GetTextureParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTexture*& OutValue, bool bCheckOwnedGlobalOverrides = false) const + PURE_VIRTUAL(UMaterialInterface::GetTextureParameterDefaultValue,return false;); + virtual bool GetRuntimeVirtualTextureParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class URuntimeVirtualTexture*& OutValue, bool bCheckOwnedGlobalOverrides = false) const + PURE_VIRTUAL(UMaterialInterface::GetRuntimeVirtualTextureParameterDefaultValue, return false;); + virtual bool GetFontParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UFont*& OutFontValue, int32& OutFontPage, bool bCheckOwnedGlobalOverrides = false) const + PURE_VIRTUAL(UMaterialInterface::GetFontParameterDefaultValue,return false;); + + // 获取分层数据. + virtual int32 GetLayerParameterIndex(EMaterialParameterAssociation Association, UMaterialFunctionInterface * LayerFunction) const + PURE_VIRTUAL(UMaterialInterface::GetLayerParameterIndex, return INDEX_NONE;); + + // 获取由表达式引用的纹理，包括嵌套函数. + virtual TArrayView GetReferencedTextures() const + PURE_VIRTUAL(UMaterialInterface::GetReferencedTextures,return TArrayView();); + + // 保存shader稳定的键值. + virtual void SaveShaderStableKeysInner(const class ITargetPlatform* TP, const struct FStableShaderKeyAndValue& SaveKeyVal) + PURE_VIRTUAL(UMaterialInterface::SaveShaderStableKeysInner, ); + + // 获取材质参数信息. + FMaterialParameterInfo GetParameterInfo(EMaterialParameterAssociation Association, FName ParameterName, UMaterialFunctionInterface* LayerFunction) const; + // 获取材质关联标记. + ENGINE_API FMaterialRelevance GetRelevance(ERHIFeatureLevel::Type InFeatureLevel) const; + ENGINE_API FMaterialRelevance GetRelevance_Concurrent(ERHIFeatureLevel::Type InFeatureLevel) const; + +#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) + // 记录材质和纹理. + ENGINE_API virtual void LogMaterialsAndTextures(FOutputDevice& Ar, int32 Indent) const {} +#endif + +private: + int32 GetWidth() const; + int32 GetHeight() const; + + // Lightmass接口. + const FGuid& GetLightingGuid() const; + void SetLightingGuid(); + virtual void GetLightingGuidChain(bool bIncludeTextures, TArray& OutGuids) const; + virtual bool UpdateLightmassTextureTracking(); + inline bool GetOverrideCastShadowAsMasked() const; + inline bool GetOverrideEmissiveBoost() const; + (......) + + // 数据获取接口. + virtual bool GetScalarParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, float& OutValue, bool bOveriddenOnly = false) const; + virtual bool GetScalarCurveParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FInterpCurveFloat& OutValue) const; + virtual bool GetVectorParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor& OutValue, bool bOveriddenOnly = false) const; + virtual bool GetVectorCurveParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FInterpCurveVector& OutValue) const; + virtual bool GetLinearColorParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor& OutValue) const; + virtual bool GetLinearColorCurveParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FInterpCurveLinearColor& OutValue) const; + virtual bool GetTextureParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTexture*& OutValue, bool bOveriddenOnly = false) const; + virtual bool GetRuntimeVirtualTextureParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class URuntimeVirtualTexture*& OutValue, bool bOveriddenOnly = false) const; + virtual bool GetFontParameterValue(const FHashedMaterialParameterInfo& ParameterInfo,class UFont*& OutFontValue, int32& OutFontPage, bool bOveriddenOnly = false) const; + virtual bool GetRefractionSettings(float& OutBiasValue) const; + + // 访问基础材质的覆盖属性. + virtual float GetOpacityMaskClipValue() const; + virtual bool GetCastDynamicShadowAsMasked() const; + virtual EBlendMode GetBlendMode() const; + virtual FMaterialShadingModelField GetShadingModels() const; + virtual bool IsShadingModelFromMaterialExpression() const; + virtual bool IsTwoSided() const; + virtual bool IsDitheredLODTransition() const; + virtual bool IsTranslucencyWritingCustomDepth() const; + virtual bool IsTranslucencyWritingVelocity() const; + virtual bool IsMasked() const; + virtual bool IsDeferredDecal() const; + virtual USubsurfaceProfile* GetSubsurfaceProfile_Internal() const; + virtual bool CastsRayTracedShadows() const; + + // 强制流系统忽略指定持续时间的正常逻辑，而总是加载此材质使用的所有纹理的所有mip级别. + virtual void SetForceMipLevelsToBeResident( bool OverrideForceMiplevelsToBeResident, bool bForceMiplevelsToBeResidentValue, float ForceDuration, int32 CinematicTextureGroups = 0, bool bFastResponse = false ); + + // 重新缓存所有材材质接口的统一表达式. + static void RecacheAllMaterialUniformExpressions(bool bRecreateUniformBuffer); + virtual void RecacheUniformExpressions(bool bRecreateUniformBuffer) const; + // 初始化所有的系统默认材质. + static void InitDefaultMaterials(); + virtual bool IsPropertyActive(EMaterialProperty InProperty) const; + static uint32 GetFeatureLevelsToCompileForAllMaterials() + + // 返回使用纹理坐标的数量，以及顶点数据是否在着色器图中使用. + void AnalyzeMaterialProperty(EMaterialProperty InProperty, int32& OutNumTextureCoordinates, bool& bOutRequiresVertexData); + + // 遍历所有的FeatureLevel, 可以指定回调. + template + static void IterateOverActiveFeatureLevels(FunctionType InHandler); + + // 访问材质采样器类型的缓存的UEnum类型信息. + static UEnum* GetSamplerTypeEnum(); + + bool UseAnyStreamingTexture() const; + bool HasTextureStreamingData() const; + const TArray& GetTextureStreamingData() const; + FORCEINLINE TArray& GetTextureStreamingData(); + // 纹理流接口. + bool FindTextureStreamingDataIndexRange(FName TextureName, int32& LowerIndex, int32& HigherIndex) const; + void SetTextureStreamingData(const TArray& InTextureStreamingData); + // 返回纹理的比例(LocalSpace Unit / Texture), 用于纹理流矩阵. + virtual float GetTextureDensity(FName TextureName, const struct FMeshUVChannelInfo& UVChannelData) const; + // 预保存. + virtual void PreSave(const class ITargetPlatform* TargetPlatform) override; + // 按名称对纹理流数据进行排序，以加速搜索. 只在需要时排序. + void SortTextureStreamingData(bool bForceSort, bool bFinalSort); + +protected: + uint32 GetFeatureLevelsToCompileForRendering() const; + void UpdateMaterialRenderProxy(FMaterialRenderProxy& Proxy); + +private: + static void PostLoadDefaultMaterials(); + // 材质采样器类型的缓存的UEnum类型信息. + static UEnum* SamplerTypeEnum; +}; + + +// Engine\Source\Runtime\Engine\Classes\Materials\Material.h + +// 材质类, 对应着一个材质资源文件. +class UMaterial : public UMaterialInterface +{ + // 物理材质. + class UPhysicalMaterial* PhysMaterial; + class UPhysicalMaterialMask* PhysMaterialMask; + class UPhysicalMaterial* PhysicalMaterialMap[EPhysicalMaterialMaskColor::MAX]; + + // 材质属性. + FScalarMaterialInput Metallic; + FScalarMaterialInput Specular; + FScalarMaterialInput Anisotropy; + FVectorMaterialInput Normal; + FVectorMaterialInput Tangent; + FColorMaterialInput EmissiveColor; + +#if WITH_EDITORONLY_DATA + // 透射. + FScalarMaterialInput Opacity; + FScalarMaterialInput OpacityMask; +#endif + + TEnumAsByte MaterialDomain; + TEnumAsByte BlendMode; + TEnumAsByte DecalBlendMode; + TEnumAsByte MaterialDecalResponse; + TEnumAsByte ShadingModel; + UPROPERTY(AssetRegistrySearchable) + FMaterialShadingModelField ShadingModels; + +public: + // 材质属性. + float OpacityMaskClipValue; + FVectorMaterialInput WorldPositionOffset; + FScalarMaterialInput Refraction; + FMaterialAttributesInput MaterialAttributes; + FScalarMaterialInput PixelDepthOffset; + FShadingModelMaterialInput ShadingModelFromMaterialExpression; + +#if WITH_EDITORONLY_DATA + FVectorMaterialInput WorldDisplacement; + FScalarMaterialInput TessellationMultiplier; + FColorMaterialInput SubsurfaceColor; + FScalarMaterialInput ClearCoat; + FScalarMaterialInput ClearCoatRoughness; + FScalarMaterialInput AmbientOcclusion; + FVector2MaterialInput CustomizedUVs[8]; +#endif + int32 NumCustomizedUVs; + + // 材质标记. + uint8 bCastDynamicShadowAsMasked : 1; + uint8 bEnableSeparateTranslucency : 1; + uint8 bEnableResponsiveAA : 1; + uint8 bScreenSpaceReflections : 1; + uint8 bContactShadows : 1; + uint8 TwoSided : 1; + uint8 DitheredLODTransition : 1; + uint8 DitherOpacityMask : 1; + uint8 bAllowNegativeEmissiveColor : 1; + + // 透明相关. + TEnumAsByte TranslucencyLightingMode; + uint8 bEnableMobileSeparateTranslucency : 1; + float TranslucencyDirectionalLightingIntensity; + float TranslucentShadowDensityScale; + float TranslucentSelfShadowDensityScale; + float TranslucentSelfShadowSecondDensityScale; + float TranslucentSelfShadowSecondOpacity; + float TranslucentBackscatteringExponent; + FLinearColor TranslucentMultipleScatteringExtinction; + float TranslucentShadowStartOffset; + + // 使用标记. + uint8 bDisableDepthTest : 1; + uint8 bWriteOnlyAlpha : 1; + uint8 bGenerateSphericalParticleNormals : 1; + uint8 bTangentSpaceNormal : 1; + uint8 bUseEmissiveForDynamicAreaLighting : 1; + uint8 bBlockGI : 1; + uint8 bUsedAsSpecialEngineMaterial : 1; + uint8 bUsedWithSkeletalMesh : 1; + uint8 bUsedWithEditorCompositing : 1; + uint8 bUsedWithParticleSprites : 1; + uint8 bUsedWithBeamTrails : 1; + uint8 bUsedWithMeshParticles : 1; + uint8 bUsedWithNiagaraSprites : 1; + uint8 bUsedWithNiagaraRibbons : 1; + uint8 bUsedWithNiagaraMeshParticles : 1; + uint8 bUsedWithGeometryCache : 1; + uint8 bUsedWithStaticLighting : 1; + uint8 bUsedWithMorphTargets : 1; + uint8 bUsedWithSplineMeshes : 1; + uint8 bUsedWithInstancedStaticMeshes : 1; + uint8 bUsedWithGeometryCollections : 1; + uint8 bUsesDistortion : 1; + uint8 bUsedWithClothing : 1; + uint32 bUsedWithWater : 1; + uint32 bUsedWithHairStrands : 1; + uint32 bUsedWithLidarPointCloud : 1; + uint32 bUsedWithVirtualHeightfieldMesh : 1; + uint8 bAutomaticallySetUsageInEditor : 1; + uint8 bFullyRough : 1; + uint8 bUseFullPrecision : 1; + uint8 bUseLightmapDirectionality : 1; + uint8 bUseAlphaToCoverage : 1; + uint32 bForwardRenderUsePreintegratedGFForSimpleIBL : 1; + uint8 bUseHQForwardReflections : 1; + uint8 bUsePlanarForwardReflections : 1; + + // 根据屏幕空间法向变化降低粗糙度. + uint8 bNormalCurvatureToRoughness : 1; + uint8 AllowTranslucentCustomDepthWrites : 1; + uint8 Wireframe : 1; + // 着色频率. + TEnumAsByte ShadingRate; + uint8 bCanMaskedBeAssumedOpaque : 1; + uint8 bIsPreviewMaterial : 1; + uint8 bIsFunctionPreviewMaterial : 1; + uint8 bUseMaterialAttributes : 1; + uint8 bCastRayTracedShadows : 1; + uint8 bUseTranslucencyVertexFog : 1; + uint8 bApplyCloudFogging : 1; + uint8 bIsSky : 1; + uint8 bComputeFogPerPixel : 1; + uint8 bOutputTranslucentVelocity : 1; + uint8 bAllowDevelopmentShaderCompile : 1; + uint8 bIsMaterialEditorStatsMaterial : 1; + TEnumAsByte BlendableLocation; + uint8 BlendableOutputAlpha : 1; + uint8 bEnableStencilTest : 1; + TEnumAsByte StencilCompare; + uint8 StencilRefValue = 0; + TEnumAsByte RefractionMode; + int32 BlendablePriority; + uint8 bIsBlendable : 1; + uint32 UsageFlagWarnings; + float RefractionDepthBias; + FGuid StateId; + float MaxDisplacement; + + // 当渲染器需要获取参数值时，代表这个材质到渲染器的FMaterialRenderProxy衍生物. + class FDefaultMaterialInstance* DefaultMaterialInstance; + +#if WITH_EDITORONLY_DATA + // 编辑器参数. + TMap > EditorParameters; + // 材质图. 编辑器模型下的数据. + class UMaterialGraph* MaterialGraph; +#endif + +private: + // 从地盘序列化而来的内联材质资源. 由游戏线程的PostLoad处理. + TArray LoadedMaterialResources; + // 用于渲染材质的资源列表. + TArray MaterialResources; +#if WITH_EDITOR + // 正在缓存或烘焙的材质资源. + TMap> CachedMaterialResourcesForCooking; +#endif + + // 用于保证在清理之前使用此UMaterial中的各种资源完成RT的标志. + FThreadSafeBool ReleasedByRT; + FMaterialCachedExpressionData CachedExpressionData; + +public: + //~ Begin UMaterialInterface Interface. + virtual UMaterial* GetMaterial() override; + virtual const UMaterial* GetMaterial() const override; + virtual const UMaterial* GetMaterial_Concurrent(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const override; + virtual bool GetScalarParameterValue(...) const override; + (......) + void SetShadingModel(EMaterialShadingModel NewModel); + virtual bool IsPropertyActive(EMaterialProperty InProperty) const override; + //~ End UMaterialInterface Interface. + + //~ Begin UObject Interface + virtual void PreSave(const class ITargetPlatform* TargetPlatform) override; + virtual void PostInitProperties() override; + virtual void Serialize(FArchive& Ar) override; + virtual void PostDuplicate(bool bDuplicateForPIE) override; + virtual void PostLoad() override; + virtual void BeginDestroy() override; + virtual bool IsReadyForFinishDestroy() override; + virtual void FinishDestroy() override; + virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override; + static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector); + virtual bool CanBeClusterRoot() const override; + virtual void GetAssetRegistryTags(TArray& OutTags) const override; + //~ End UObject Interface + + // 数据获取接口. + bool IsDefaultMaterial() const; + void ReleaseResources(); + bool IsUsageFlagDirty(EMaterialUsage Usage); + bool IsCompilingOrHadCompileError(ERHIFeatureLevel::Type InFeatureLevel); + + (......) + +private: + // 新版的获取材质数据接口. + bool GetScalarParameterValue_New(...) const; + bool GetVectorParameterValue_New(...) const; + bool GetTextureParameterValue_New(...) const; + bool GetRuntimeVirtualTextureParameterValue_New(...) const; + bool GetFontParameterValue_New(...) const; + + FString GetUsageName(const EMaterialUsage Usage) const; + bool GetUsageByFlag(const EMaterialUsage Usage) const; + bool SetMaterialUsage(bool &bNeedsRecompile, const EMaterialUsage Usage); + + (......) + +private: + virtual void FlushResourceShaderMaps(); + // 缓冲资源或数据. + void CacheResourceShadersForRendering(bool bRegenerateId); + void CacheResourceShadersForCooking(...); + void CacheShadersForResources(...); + +public: + // 静态工具箱或操作接口. + static UMaterial* GetDefaultMaterial(EMaterialDomain Domain); + static void UpdateMaterialShaders(...); + static void BackupMaterialShadersToMemory(...); + static void RestoreMaterialShadersFromMemory(...); + static void CompileMaterialsForRemoteRecompile(...); + static bool GetExpressionParameterName(const UMaterialExpression* Expression, FName& OutName); + static bool CopyExpressionParameters(UMaterialExpression* Source, UMaterialExpression* Destination); + static bool IsParameter(const UMaterialExpression* Expression); + static bool IsDynamicParameter(const UMaterialExpression* Expression); + static const TCHAR* GetMaterialShadingModelString(EMaterialShadingModel InMaterialShadingModel); + static EMaterialShadingModel GetMaterialShadingModelFromString(const TCHAR* InMaterialShadingModelStr); + static const TCHAR* GetBlendModeString(EBlendMode InBlendMode); + static EBlendMode GetBlendModeFromString(const TCHAR* InBlendModeStr); + virtual TArrayView GetReferencedTextures() const override final; + + (......) +}; +``` +# UMaterialInstance +UMaterialInstance是材质实例，不能单独存在，而需要依赖UMaterialInterface类型的父类，意味着父类可以是UMaterialInterface的任意一个子类，但最上层的父类必须是UMaterial。 +```c++ +class UMaterialInstance : public UMaterialInterface +{ + // 物理材质. + class UPhysicalMaterial* PhysMaterial; + class UPhysicalMaterial* PhysicalMaterialMap[EPhysicalMaterialMaskColor::MAX]; + // 材质父亲. + class UMaterialInterface* Parent; + // 当渲染器需要获取参数值时，代表这个材质实例的FMaterialRenderProxy的子类. + class FMaterialInstanceResource* Resource; + + // 可以部分覆盖Parent的属性, 和UMaterial相比, 只是一小部分. + uint8 bHasStaticPermutationResource:1; + uint8 bOverrideSubsurfaceProfile:1; + uint8 TwoSided : 1; + uint8 DitheredLODTransition : 1; + uint8 bCastDynamicShadowAsMasked : 1; + uint8 bIsShadingModelFromMaterialExpression : 1; + TEnumAsByte BlendMode; + float OpacityMaskClipValue; + FMaterialShadingModelField ShadingModels; + + // 覆盖Parent的各种类型的数据. + TArray ScalarParameterValues; + TArray VectorParameterValues; + TArray TextureParameterValues; + TArray RuntimeVirtualTextureParameterValues; + TArray FontParameterValues; + struct FMaterialInstanceBasePropertyOverrides BasePropertyOverrides; + (......) +private: + FStaticParameterSet StaticParameters; + FMaterialCachedParameters CachedLayerParameters; + TArray CachedReferencedTextures; + // 已加载的材质资源. + TArray LoadedMaterialResources; + TArray StaticPermutationMaterialResources; + FThreadSafeBool ReleasedByRT; +public: + // Begin UMaterialInterface interface. + virtual ENGINE_API UMaterial* GetMaterial() override; + virtual ENGINE_API const UMaterial* GetMaterial() const override; + virtual ENGINE_API const UMaterial* GetMaterial_Concurrent(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const override; + virtual ENGINE_API FMaterialResource* AllocatePermutationResource(); + (......) + //~ End UMaterialInterface Interface. + //~ Begin UObject Interface. + virtual ENGINE_API void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override; + virtual ENGINE_API void PostInitProperties() override; + virtual ENGINE_API void Serialize(FArchive& Ar) override; + virtual ENGINE_API void PostLoad() override; + virtual ENGINE_API void BeginDestroy() override; + virtual ENGINE_API bool IsReadyForFinishDestroy() override; + virtual ENGINE_API void FinishDestroy() override; + ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector); + //~ End UObject Interface. + + void GetAllShaderMaps(TArray& OutShaderMaps); + void GetAllParametersOfType(EMaterialParameterType Type, TArray& OutParameterInfo, TArray& OutParameterIds) const; + + (......) +protected: + void CopyMaterialUniformParametersInternal(UMaterialInterface* Source); + bool UpdateParameters(); + ENGINE_API void SetParentInternal(class UMaterialInterface* NewParent, bool RecacheShaders); + + (......) + // 初始化材质实例的资源. + ENGINE_API void InitResources(); + + // 缓存资源. + void CacheResourceShadersForRendering(); + void CacheResourceShadersForRendering(FMaterialResourceDeferredDeletionArray& OutResourcesToFree); + void CacheShadersForResources(...); + void DeleteDeferredResources(FMaterialResourceDeferredDeletionArray& ResourcesToFree); + + ENGINE_API void CopyMaterialInstanceParameters(UMaterialInterface* Source); + (......) +}; +``` + +UMaterialInstance和UMaterial不一样，它需要依附于父亲实例，而且最顶层的父亲必然是UMaterial实例。它**只能覆盖UMaterial的一小部分参数**，通常不会被单独创建，而是以它的两个子类**UMaterialInstanceConstant**和**UMaterialInstanceDynamic**被创建。 + +# FMaterialRenderProxy +FMaterialRenderProxy负责接收游戏线程代表的数据，然后传递给渲染器去处理和渲染。 +```c++ +// Engine\Source\Runtime\Engine\Public\MaterialShared.h + +class FMaterialRenderProxy : public FRenderResource +{ +public: + // 缓存数据. + mutable FUniformExpressionCacheContainer UniformExpressionCache; + mutable FImmutableSamplerState ImmutableSamplerState; + + // 构造/析构函数. + ENGINE_API FMaterialRenderProxy(); + ENGINE_API virtual ~FMaterialRenderProxy(); + + // 计算表达式并存储到OutUniformExpressionCache. + void ENGINE_API EvaluateUniformExpressions(FUniformExpressionCache& OutUniformExpressionCache, const FMaterialRenderContext& Context, class FRHICommandList* CommandListIfLocalMode = nullptr) const; + + // UniformExpression接口. + void ENGINE_API CacheUniformExpressions(bool bRecreateUniformBuffer); + void ENGINE_API CacheUniformExpressions_GameThread(bool bRecreateUniformBuffer); + void ENGINE_API InvalidateUniformExpressionCache(bool bRecreateUniformBuffer); + void ENGINE_API UpdateUniformExpressionCacheIfNeeded(ERHIFeatureLevel::Type InFeatureLevel) const; + + // 返回有效的FMaterial实例. + const class FMaterial* GetMaterial(ERHIFeatureLevel::Type InFeatureLevel) const; + // 查找用于渲染此FMaterialRenderProxy的FMaterial实例. + virtual const FMaterial& GetMaterialWithFallback(ERHIFeatureLevel::Type InFeatureLevel, const FMaterialRenderProxy*& OutFallbackMaterialRenderProxy) const = 0; + virtual FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type InFeatureLevel) const { return NULL; } + // 获取对应的UMaterialInterface实例. + virtual UMaterialInterface* GetMaterialInterface() const { return NULL; } + + // 获取材质属性的值. + virtual bool GetVectorValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor* OutValue, const FMaterialRenderContext& Context) const = 0; + virtual bool GetScalarValue(const FHashedMaterialParameterInfo& ParameterInfo, float* OutValue, const FMaterialRenderContext& Context) const = 0; + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo,const UTexture** OutValue, const FMaterialRenderContext& Context) const = 0; + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const URuntimeVirtualTexture** OutValue, const FMaterialRenderContext& Context) const = 0; + + bool IsDeleted() const; + void MarkForGarbageCollection(); + bool IsMarkedForGarbageCollection() const; + + // FRenderResource interface. + ENGINE_API virtual void InitDynamicRHI() override; + ENGINE_API virtual void ReleaseDynamicRHI() override; + ENGINE_API virtual void ReleaseResource() override; + + // 获取静态的材质渲染代表的映射表. + ENGINE_API static const TSet& GetMaterialRenderProxyMap(); + + void SetSubsurfaceProfileRT(const USubsurfaceProfile* Ptr); + const USubsurfaceProfile* GetSubsurfaceProfileRT() const; + + ENGINE_API static void UpdateDeferredCachedUniformExpressions(); + static inline bool HasDeferredUniformExpressionCacheRequests(); + + int32 GetExpressionCacheSerialNumber() const { return UniformExpressionCacheSerialNumber; } + +private: + const USubsurfaceProfile* SubsurfaceProfileRT; + mutable int32 UniformExpressionCacheSerialNumber = 0; + + // 材质标记. + mutable int8 MarkedForGarbageCollection : 1; + mutable int8 DeletedFlag : 1; + mutable int8 ReleaseResourceFlag : 1; + mutable int8 HasVirtualTextureCallbacks : 1; + + // 追踪在所有场景的所有材质渲染代表. 只可在渲染线程访问. 用来传播新的着色器映射到渲染所用的材质. + ENGINE_API static TSet MaterialRenderProxyMap; + ENGINE_API static TSet DeferredUniformExpressionCacheRequests; +}; +``` +我们将注意力放到两个重要的子类：FDefaultMaterialInstance和FMaterialInstanceResource，它们的定义如下： +```c++ +// Engine\Source\Runtime\Engine\Private\Materials\Material.cpp + +// 用于渲染UMaterial的默认渲染代表, 默认的参数值已经存储于FMaterialUniformExpressionXxxParameter对象, 此资源值用来存储选中的颜色. +class FDefaultMaterialInstance : public FMaterialRenderProxy +{ +public: + + // 游戏线程销毁接口. + void GameThread_Destroy() + { + FDefaultMaterialInstance* Resource = this; + ENQUEUE_RENDER_COMMAND(FDestroyDefaultMaterialInstanceCommand)( + [Resource](FRHICommandList& RHICmdList) + { + delete Resource; + }); + } + + // FMaterialRenderProxy interface. + // 获取材质接口. + virtual const FMaterial& GetMaterialWithFallback(ERHIFeatureLevel::Type InFeatureLevel, const FMaterialRenderProxy*& OutFallbackMaterialRenderProxy) const + { + const FMaterialResource* MaterialResource = Material->GetMaterialResource(InFeatureLevel); + if (MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + return *MaterialResource; + } + + OutFallbackMaterialRenderProxy = &GetFallbackRenderProxy(); + return OutFallbackMaterialRenderProxy->GetMaterialWithFallback(InFeatureLevel, OutFallbackMaterialRenderProxy); + } + virtual FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type InFeatureLevel) const + { + return Material->GetMaterialResource(InFeatureLevel); + } + + // 获取对应的UMaterialInterface接口. + virtual UMaterialInterface* GetMaterialInterface() const override + { + return Material; + } + + // 获取向量的参数值. + virtual bool GetVectorValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor* OutValue, const FMaterialRenderContext& Context) const + { + const FMaterialResource* MaterialResource = Material->GetMaterialResource(Context.Material.GetFeatureLevel()); + if(MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + return false; + } + else + { + return GetFallbackRenderProxy().GetVectorValue(ParameterInfo, OutValue, Context); + } + } + // 获取标量的参数值. + virtual bool GetScalarValue(const FHashedMaterialParameterInfo& ParameterInfo, float* OutValue, const FMaterialRenderContext& Context) const + { + const FMaterialResource* MaterialResource = Material->GetMaterialResource(Context.Material.GetFeatureLevel()); + if(MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + static FName NameSubsurfaceProfile(TEXT("__SubsurfaceProfile")); + if (ParameterInfo.Name == NameSubsurfaceProfile) + { + const USubsurfaceProfile* MySubsurfaceProfileRT = GetSubsurfaceProfileRT(); + + int32 AllocationId = 0; + if(MySubsurfaceProfileRT) + { + // can be optimized (cached) + AllocationId = GSubsurfaceProfileTextureObject.FindAllocationId(MySubsurfaceProfileRT); + } + else + { + // no profile specified means we use the default one stored at [0] which is human skin + AllocationId = 0; + } + + *OutValue = AllocationId / 255.0f; + + return true; + } + + return false; + } + else + { + return GetFallbackRenderProxy().GetScalarValue(ParameterInfo, OutValue, Context); + } + } + // 获取纹理的参数值. + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo,const UTexture** OutValue, const FMaterialRenderContext& Context) const + { + const FMaterialResource* MaterialResource = Material->GetMaterialResource(Context.Material.GetFeatureLevel()); + if(MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + return false; + } + else + { + return GetFallbackRenderProxy().GetTextureValue(ParameterInfo,OutValue,Context); + } + } + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const URuntimeVirtualTexture** OutValue, const FMaterialRenderContext& Context) const + { + const FMaterialResource* MaterialResource = Material->GetMaterialResource(Context.Material.GetFeatureLevel()); + if (MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + return false; + } + else + { + return GetFallbackRenderProxy().GetTextureValue(ParameterInfo, OutValue, Context); + } + } + + // FRenderResource interface. + virtual FString GetFriendlyName() const { return Material->GetName(); } + + // Constructor. + FDefaultMaterialInstance(UMaterial* InMaterial); + +private: + // 获取备份的材质渲染代理. + FMaterialRenderProxy& GetFallbackRenderProxy() const + { + return *(UMaterial::GetDefaultMaterial(Material->MaterialDomain)->GetRenderProxy()); + } + + // 对应的材质实例. + UMaterial* Material; +}; + +// Engine\Source\Runtime\Engine\Private\Materials\MaterialInstanceSupport.h +// 渲染UMaterialInstance的材质资源. +class FMaterialInstanceResource: public FMaterialRenderProxy +{ +public: + // 存储材质实例的名称和值的配对. + template + struct TNamedParameter + { + FHashedMaterialParameterInfo Info; + ValueType Value; + }; + + FMaterialInstanceResource(UMaterialInstance* InOwner); + + void GameThread_Destroy() + { + FMaterialInstanceResource* Resource = this; + ENQUEUE_RENDER_COMMAND(FDestroyMaterialInstanceResourceCommand)( + [Resource](FRHICommandList& RHICmdList) + { + delete Resource; + }); + } + + // FRenderResource interface. + virtual FString GetFriendlyName() const override { return Owner->GetName(); } + + // FMaterialRenderProxy interface. + // 获取材质渲染资源. + virtual const FMaterial& GetMaterialWithFallback(ERHIFeatureLevel::Type FeatureLevel, const FMaterialRenderProxy*& OutFallbackMaterialRenderProxy) const override; + virtual FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type FeatureLevel) const override; + virtual UMaterialInterface* GetMaterialInterface() const override; + + // 获取材质的值. + virtual bool GetVectorValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor* OutValue, const FMaterialRenderContext& Context) const override; + virtual bool GetScalarValue(const FHashedMaterialParameterInfo& ParameterInfo, float* OutValue, const FMaterialRenderContext& Context) const override; + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const UTexture** OutValue, const FMaterialRenderContext& Context) const override; + virtual bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const URuntimeVirtualTexture** OutValue, const FMaterialRenderContext& Context) const override; + + void GameThread_SetParent(UMaterialInterface* ParentMaterialInterface); + void InitMIParameters(struct FMaterialInstanceParameterSet& ParameterSet); + void RenderThread_ClearParameters() + { + VectorParameterArray.Empty(); + ScalarParameterArray.Empty(); + TextureParameterArray.Empty(); + RuntimeVirtualTextureParameterArray.Empty(); + InvalidateUniformExpressionCache(false); + } + + // 更新参数. + template + void RenderThread_UpdateParameter(const FHashedMaterialParameterInfo& ParameterInfo, const ValueType& Value ) + { + LLM_SCOPE(ELLMTag::MaterialInstance); + + InvalidateUniformExpressionCache(false); + TArray >& ValueArray = GetValueArray(); + const int32 ParameterCount = ValueArray.Num(); + for (int32 ParameterIndex = 0; ParameterIndex < ParameterCount; ++ParameterIndex) + { + TNamedParameter& Parameter = ValueArray[ParameterIndex]; + if (Parameter.Info == ParameterInfo) + { + Parameter.Value = Value; + return; + } + } + TNamedParameter NewParameter; + NewParameter.Info = ParameterInfo; + NewParameter.Value = Value; + ValueArray.Add(NewParameter); + } + + // 查找指定名字的参数值. + template + const ValueType* RenderThread_FindParameterByName(const FHashedMaterialParameterInfo& ParameterInfo) const + { + const TArray >& ValueArray = GetValueArray(); + const int32 ParameterCount = ValueArray.Num(); + for (int32 ParameterIndex = 0; ParameterIndex < ParameterCount; ++ParameterIndex) + { + const TNamedParameter& Parameter = ValueArray[ParameterIndex]; + if (Parameter.Info == ParameterInfo) + { + return &Parameter.Value; + } + } + return NULL; + } +private: + template TArray >& GetValueArray(); + + // 材质实例的父亲. + UMaterialInterface* Parent; + // 游戏线程的父亲. + UMaterialInterface* GameThreadParent; + // 所属的材质实例. + UMaterialInstance* Owner; + + // 各种类型的参数值列表. + TArray > VectorParameterArray; + TArray > ScalarParameterArray; + TArray > TextureParameterArray; + TArray > RuntimeVirtualTextureParameterArray; +}; +``` +需要格外注意的是，FMaterialRenderProxy既会被游戏线程处理，又会被渲染线程处理，需要小心注意它们之间的数据访问和接口调用。带有GameThread的是专用于游戏线程，带有RenderThread的专用于渲染线程，如果没有特别说明，一般（非绝对）用于渲染线程。 + +# FMaterial & FMaterialResource +FMaterial有3个功能： +- 表示材质到材质的编译过程，并提供可扩展性钩子(CompileProperty等) 。 +- 将材质数据传递到渲染器，并使用函数访问材质属性。 +- 存储缓存的shader map和其他来自编译的瞬态输出，这对异步着色器编译是必要的。 + +下面是FMaterial的定义： +```c++ +// Engine\Source\Runtime\Engine\Public\MaterialShared.h + +class FMaterial +{ +public: +#if UE_CHECK_FMATERIAL_LIFETIME + uint32 AddRef() const; + uint32 Release() const; + inline uint32 GetRefCount() const { return uint32(NumDebugRefs.GetValue()); } + + mutable FThreadSafeCounter NumDebugRefs; +#else + FORCEINLINE uint32 AddRef() const { return 0u; } + FORCEINLINE uint32 Release() const { return 0u; } + FORCEINLINE uint32 GetRefCount() const { return 0u; } +#endif + + FMaterial(); + ENGINE_API virtual ~FMaterial(); + + // 缓存shader. + ENGINE_API bool CacheShaders(EShaderPlatform Platform, const ITargetPlatform* TargetPlatform = nullptr); + ENGINE_API bool CacheShaders(const FMaterialShaderMapId& ShaderMapId, EShaderPlatform Platform, const ITargetPlatform* TargetPlatform = nullptr); + + // 是否需要缓存指定shader type的数据. + ENGINE_API virtual bool ShouldCache(EShaderPlatform Platform, const FShaderType* ShaderType, const FVertexFactoryType* VertexFactoryType) const; + ENGINE_API bool ShouldCachePipeline(EShaderPlatform Platform, const FShaderPipelineType* PipelineType, const FVertexFactoryType* VertexFactoryType) const; + + // 序列化. + ENGINE_API virtual void LegacySerialize(FArchive& Ar); + void SerializeInlineShaderMap(FArchive& Ar); + + // ShaderMap接口. + void RegisterInlineShaderMap(bool bLoadedByCookedMaterial); + void ReleaseShaderMap(); + void DiscardShaderMap(); + + // 材质属性. + ENGINE_API virtual void GetShaderMapId(EShaderPlatform Platform, const ITargetPlatform* TargetPlatform, FMaterialShaderMapId& OutId) const; + virtual EMaterialDomain GetMaterialDomain() const = 0; // See EMaterialDomain. + virtual bool IsTwoSided() const = 0; + virtual bool IsDitheredLODTransition() const = 0; + virtual bool IsTranslucencyWritingCustomDepth() const { return false; } + virtual bool IsTranslucencyWritingVelocity() const { return false; } + virtual bool IsTangentSpaceNormal() const { return false; } + + (......) + + // 是否需要保存到磁盘. + virtual bool IsPersistent() const = 0; + // 获取材质实例. + virtual UMaterialInterface* GetMaterialInterface() const { return NULL; } + + ENGINE_API bool HasValidGameThreadShaderMap() const; + inline bool ShouldCastDynamicShadows() const; + EMaterialQualityLevel::Type GetQualityLevel() const + + // 数据访问接口. + ENGINE_API const FUniformExpressionSet& GetUniformExpressions() const; + ENGINE_API TArrayView GetUniformTextureExpressions(EMaterialTextureParameterType Type) const; + ENGINE_API TArrayView GetUniformVectorParameterExpressions() const; + ENGINE_API TArrayView GetUniformScalarParameterExpressions() const; + inline TArrayView GetUniform2DTextureExpressions() const { return GetUniformTextureExpressions(EMaterialTextureParameterType::Standard2D); } + inline TArrayView GetUniformCubeTextureExpressions() const { return GetUniformTextureExpressions(EMaterialTextureParameterType::Cube); } + inline TArrayView GetUniform2DArrayTextureExpressions() const { return GetUniformTextureExpressions(EMaterialTextureParameterType::Array2D); } + inline TArrayView GetUniformVolumeTextureExpressions() const { return GetUniformTextureExpressions(EMaterialTextureParameterType::Volume); } + inline TArrayView GetUniformVirtualTextureExpressions() const { return GetUniformTextureExpressions(EMaterialTextureParameterType::Virtual); } + + const FStaticFeatureLevel GetFeatureLevel() const { return FeatureLevel; } + bool GetUsesDynamicParameter() const; + ENGINE_API bool RequiresSceneColorCopy_GameThread() const; + ENGINE_API bool RequiresSceneColorCopy_RenderThread() const; + ENGINE_API bool NeedsSceneTextures() const; + ENGINE_API bool NeedsGBuffer() const; + ENGINE_API bool UsesEyeAdaptation() const; + ENGINE_API bool UsesGlobalDistanceField_GameThread() const; + ENGINE_API bool UsesWorldPositionOffset_GameThread() const; + + // 材质标记. + ENGINE_API bool MaterialModifiesMeshPosition_RenderThread() const; + ENGINE_API bool MaterialModifiesMeshPosition_GameThread() const; + ENGINE_API bool MaterialUsesPixelDepthOffset() const; + ENGINE_API bool MaterialUsesDistanceCullFade_GameThread() const; + ENGINE_API bool MaterialUsesSceneDepthLookup_RenderThread() const; + ENGINE_API bool MaterialUsesSceneDepthLookup_GameThread() const; + ENGINE_API bool UsesCustomDepthStencil_GameThread() const; + ENGINE_API bool MaterialMayModifyMeshPosition() const; + ENGINE_API bool MaterialUsesAnisotropy_GameThread() const; + ENGINE_API bool MaterialUsesAnisotropy_RenderThread() const; + + // shader map接口. + class FMaterialShaderMap* GetGameThreadShaderMap() const + { + return GameThreadShaderMap; + } + void SetGameThreadShaderMap(FMaterialShaderMap* InMaterialShaderMap) + { + GameThreadShaderMap = InMaterialShaderMap; + + TRefCountPtr ShaderMap = GameThreadShaderMap; + TRefCountPtr Material = this; + + // 将游戏线程的shader map设置到渲染线程. + ENQUEUE_RENDER_COMMAND(SetGameThreadShaderMap)([Material = MoveTemp(Material), ShaderMap = MoveTemp(ShaderMap)](FRHICommandListImmediate& RHICmdList) mutable + { + Material->RenderingThreadShaderMap = MoveTemp(ShaderMap); + }); + } + void SetInlineShaderMap(FMaterialShaderMap* InMaterialShaderMap); + ENGINE_API class FMaterialShaderMap* GetRenderingThreadShaderMap() const; + ENGINE_API void SetRenderingThreadShaderMap(const TRefCountPtr& InMaterialShaderMap); + + ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector); + + virtual TArrayView GetReferencedTextures() const = 0; + + // 获取shader/shader pipeline. + template + TShaderRef GetShader(FVertexFactoryType* VertexFactoryType, const typename ShaderType::FPermutationDomain& PermutationVector, bool bFatalIfMissing = true) const; + template + TShaderRef GetShader(FVertexFactoryType* VertexFactoryType, int32 PermutationId = 0, bool bFatalIfMissing = true) const; + ENGINE_API FShaderPipelineRef GetShaderPipeline(class FShaderPipelineType* ShaderPipelineType, FVertexFactoryType* VertexFactoryType, bool bFatalIfNotFound = true) const; + + // 材质接口. + virtual FString GetMaterialUsageDescription() const = 0; + virtual bool GetAllowDevelopmentShaderCompile()const{ return true; } + virtual EMaterialShaderMapUsage::Type GetMaterialShaderMapUsage() const { return EMaterialShaderMapUsage::Default; } + ENGINE_API bool GetMaterialExpressionSource(FString& OutSource); + ENGINE_API bool WritesEveryPixel(bool bShadowPass = false) const; + virtual void SetupExtaCompilationSettings(const EShaderPlatform Platform, FExtraShaderCompilerSettings& Settings) const; + + (......) + +protected: + const FMaterialShaderMap* GetShaderMapToUse() const; + + virtual int32 CompilePropertyAndSetMaterialProperty(EMaterialProperty Property, class FMaterialCompiler* Compiler, EShaderFrequency OverrideShaderFrequency = SF_NumFrequencies, bool bUsePreviousFrameTime = false) const = 0; + + void SetQualityLevelProperties(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type InQualityLevel = EMaterialQualityLevel::Num); + virtual EMaterialShaderMapUsage::Type GetShaderMapUsage() const; + virtual FGuid GetMaterialId() const = 0; + ENGINE_API void GetDependentShaderAndVFTypes(EShaderPlatform Platform, TArray& OutShaderTypes, TArray& OutShaderPipelineTypes, TArray& OutVFTypes) const; + bool GetLoadedCookedShaderMapId() const; + +private: + // 游戏线程和渲染线程的shader map. + TRefCountPtr GameThreadShaderMap; + TRefCountPtr RenderingThreadShaderMap; + + // 质量等级. + EMaterialQualityLevel::Type QualityLevel; + ERHIFeatureLevel::Type FeatureLevel; + + // 特殊标记. + uint32 bStencilDitheredLOD : 1; + uint32 bContainsInlineShaders : 1; + uint32 bLoadedCookedShaderMapId : 1; + + bool BeginCompileShaderMap( + const FMaterialShaderMapId& ShaderMapId, + const FStaticParameterSet &StaticParameterSet, + EShaderPlatform Platform, + TRefCountPtr& OutShaderMap, + const ITargetPlatform* TargetPlatform = nullptr); + void SetupMaterialEnvironment( + EShaderPlatform Platform, + const FShaderParametersMetadata& InUniformBufferStruct, + const FUniformExpressionSet& InUniformExpressionSet, + FShaderCompilerEnvironment& OutEnvironment + ) const; + + ENGINE_API TShaderRef GetShader(class FMeshMaterialShaderType* ShaderType, FVertexFactoryType* VertexFactoryType, int32 PermutationId, bool bFatalIfMissing = true) const; +}; +``` +由上面可知，FMaterial集大之所成，囊括了材质、Shader、VertexFactory、ShaderPipeline、ShaderMap等各种数据和操作接口，是这些数据的集散地。不过，它只是个抽象的父类，具体的功能需要由子类实现。它的子类只有FMaterialResource： +```c++ +// 实现FMaterial的接口, 用于渲染UMaterial或UMaterialInstance. +class FMaterialResource : public FMaterial +{ +public: + ENGINE_API FMaterialResource(); + ENGINE_API virtual ~FMaterialResource(); + + // 设置材质. + void SetMaterial(UMaterial* InMaterial, UMaterialInstance* InInstance, ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type InQualityLevel = EMaterialQualityLevel::Num) + { + Material = InMaterial; + MaterialInstance = InInstance; + SetQualityLevelProperties(InFeatureLevel, InQualityLevel); + } + + ENGINE_API uint32 GetNumVirtualTextureStacks() const; + ENGINE_API virtual FString GetMaterialUsageDescription() const override; + + // FMaterial interface. + ENGINE_API virtual void GetShaderMapId(EShaderPlatform Platform, const ITargetPlatform* TargetPlatform, FMaterialShaderMapId& OutId) const override; + ENGINE_API virtual EMaterialDomain GetMaterialDomain() const override; + ENGINE_API virtual bool IsTwoSided() const override; + ENGINE_API virtual bool IsDitheredLODTransition() const override; + ENGINE_API virtual bool IsTranslucencyWritingCustomDepth() const override; + ENGINE_API virtual bool IsTranslucencyWritingVelocity() const override; + ENGINE_API virtual bool IsTangentSpaceNormal() const override; + ENGINE_API virtual EMaterialShadingRate GetShadingRate() const override; + (......) + // 材质接口. + inline const UMaterial* GetMaterial() const { return Material; } + inline const UMaterialInstance* GetMaterialInstance() const { return MaterialInstance; } + inline void SetMaterial(UMaterial* InMaterial) { Material = InMaterial; } + inline void SetMaterialInstance(UMaterialInstance* InMaterialInstance) { MaterialInstance = InMaterialInstance; } +protected: + // 对应的材质. + UMaterial* Material; + // 对应的材质实例. + UMaterialInstance* MaterialInstance; + + // 编译指定材质属性的入口, 须有SetMaterialProperty调用. + ENGINE_API virtual int32 CompilePropertyAndSetMaterialProperty(EMaterialProperty Property, class FMaterialCompiler* Compiler, EShaderFrequency OverrideShaderFrequency, bool bUsePreviousFrameTime) const override; + + ENGINE_API virtual bool HasVertexPositionOffsetConnected() const override; + ENGINE_API virtual bool HasPixelDepthOffsetConnected() const override; + ENGINE_API virtual bool HasMaterialAttributesConnected() const override; + (......) +}; +``` +FMaterialResource只是实现了FMaterial未实现的接口，并且存储了UMaterial或UMaterialInstance的实例。如果UMaterialInstance和UMaterial的实例都有效的情况下，那么它们重叠的数据会优先取UMaterialInstance的数据，比如： +```c++ +// 获取着色模型域 +FMaterialShadingModelField FMaterialResource::GetShadingModels() const +{ + // 优先选用MaterialInstance的数据. + return MaterialInstance ? MaterialInstance->GetShadingModels() : Material->GetShadingModels(); +} +``` +渲染资源除了FMaterial之外，还有个比较核心的概念就是**FMaterialRenderContext**，它保存了**FMaterialRenderProxy和FMaterial**之间的关联配对： +```c++ +struct ENGINE_API FMaterialRenderContext +{ + // 用于材质shader的材质渲染代表. + const FMaterialRenderProxy* MaterialRenderProxy; + // 材质渲染资源. + const FMaterial& Material; + + // 是否显示选中时的颜色. + bool bShowSelection; + + // 构造函数. + FMaterialRenderContext(const FMaterialRenderProxy* InMaterialRenderProxy, const FMaterial& InMaterial, const FSceneView* InView); +}; +``` +FMaterialRenderContext较多地用于材质各种类型的接口的形参，比如： +```c++ +// FDefaultMaterialInstance中的获取向量参数值, 用到了FMaterialRenderContext参数. +virtual bool FDefaultMaterialInstance::GetVectorValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor* OutValue, const FMaterialRenderContext& Context) const +{ + const FMaterialResource* MaterialResource = Material->GetMaterialResource(Context.Material.GetFeatureLevel()); + + if(MaterialResource && MaterialResource->GetRenderingThreadShaderMap()) + { + return false; + } + else + { + return GetFallbackRenderProxy().GetVectorValue(ParameterInfo, OutValue, Context); + } +} +``` + +# 材质渲染 +材质数据的发起者依然是游戏线程侧的资源，一般是从磁盘加载的二进制资源，然后序列化成UMaterialInterface实例，或者由运行时动态创建并设置材质数据。不过绝大多数是由磁盘加载而来。 +当使用了材质的图元组件在被要求**收集MeshBatch**的时候，可以将其使用的UMaterialInterface对应的**FMaterialRenderProxy传递到FMeshBatchElement**中。下面以StaticMesh为例： +```c++ +// Engine\Source\Runtime\Engine\Private\StaticMeshRender.cpp + +bool FStaticMeshSceneProxy::GetMeshElement( + int32 LODIndex, + int32 BatchIndex, + int32 SectionIndex, + uint8 InDepthPriorityGroup, + bool bUseSelectionOutline, + bool bAllowPreCulledIndices, + FMeshBatch& OutMeshBatch) const +{ + const ERHIFeatureLevel::Type FeatureLevel = GetScene().GetFeatureLevel(); + const FStaticMeshLODResources& LOD = RenderData->LODResources[LODIndex]; + const FStaticMeshVertexFactories& VFs = RenderData->LODVertexFactories[LODIndex]; + const FStaticMeshSection& Section = LOD.Sections[SectionIndex]; + const FLODInfo& ProxyLODInfo = LODs[LODIndex]; + + // 获取材质的各种实例(包含UMaterialInterface, FMaterialRenderProxy和FMaterial) + UMaterialInterface* MaterialInterface = ProxyLODInfo.Sections[SectionIndex].Material; + FMaterialRenderProxy* MaterialRenderProxy = MaterialInterface->GetRenderProxy(); + const FMaterial* Material = MaterialRenderProxy->GetMaterial(FeatureLevel); + + FMeshBatchElement& OutMeshBatchElement = OutMeshBatch.Elements[0]; + + // 处理顶点工厂 + const FVertexFactory* VertexFactory = nullptr; + if (ProxyLODInfo.OverrideColorVertexBuffer) + { + (......) + } + + (......) + + if(NumPrimitives > 0) + { + OutMeshBatch.SegmentIndex = SectionIndex; + OutMeshBatch.LODIndex = LODIndex; + + // 赋值材质和渲染代表. + OutMeshBatch.MaterialRenderProxy = MaterialRenderProxy; + + (......) + } +} +``` +因此，可以知道，在组件收集网格元素的时候，材质的所有类型的数据已经准备好，并且可以被访问了。说明在游戏线程阶段，材质的各种类型的实例已经被加载、设置和创建。我们继续深究到底是什么时候创建的。首先看FMaterialRenderProxy，不同的UMaterialInterface的子类稍有不一样，具体如下代码所示： +```c++ +// Engine\Source\Runtime\Engine\Private\Materials\MaterialInstance.cpp +void UMaterialInstance::PostInitProperties() +{ + Super::PostInitProperties(); + + if(!HasAnyFlags(RF_ClassDefaultObject)) + { + // 创建FMaterialRenderProxy. + Resource = new FMaterialInstanceResource(this); + } +} + +FMaterialRenderProxy* UMaterialInstance::GetRenderProxy() const +{ + return Resource; +} + +// Engine\Source\Runtime\Engine\Private\Materials\Material.cpp + +void UMaterial::PostInitProperties() +{ + Super::PostInitProperties(); + if(!HasAnyFlags(RF_ClassDefaultObject)) + { + // 创建FMaterialRenderProxy. + DefaultMaterialInstance = new FDefaultMaterialInstance(this); + } + + FPlatformMisc::CreateGuid(StateId); +} + +FMaterialRenderProxy* UMaterial::GetRenderProxy() const +{ + return DefaultMaterialInstance; +} +``` +由此可推断，UMaterialInstance对应的FMaterialRenderProxy是在子类的PostInitProperties阶段被创建的。 +我们继续查明UMaterialInterface获取对应的FMaterial实例是哪个接口哪个成员： +```c++ +// Engine\Source\Runtime\Engine\Private\Materials\Material.cpp +// 获取UMaterial对应的FMaterialResource(FMaterial的子类)实例. +FMaterialResource* UMaterial::GetMaterialResource(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel) +{ + if (QualityLevel == EMaterialQualityLevel::Num) + { + QualityLevel = GetCachedScalabilityCVars().MaterialQualityLevel; + } + return FindMaterialResource(MaterialResources, InFeatureLevel, QualityLevel, true); +} +``` +以上可以知道，是查找UMaterial::MaterialResources，那么继续深究其何时被创建： +```c++ +FMaterialResource* FindOrCreateMaterialResource(TArray& MaterialResources, + UMaterial* OwnerMaterial, + UMaterialInstance* OwnerMaterialInstance, + ERHIFeatureLevel::Type InFeatureLevel, + EMaterialQualityLevel::Type InQualityLevel) +{ + (......) + + FMaterialResource* CurrentResource = FindMaterialResource(MaterialResources, InFeatureLevel, QualityLevelForResource, false); + + // 如果当前资源列表不存在就创建新的FMaterialResource实例. + if (!CurrentResource) + { + // 优先使用材质实例的的接口来创建. + CurrentResource = OwnerMaterialInstance ? OwnerMaterialInstance->AllocatePermutationResource() : OwnerMaterial->AllocateResource(); + CurrentResource->SetMaterial(OwnerMaterial, OwnerMaterialInstance, InFeatureLevel, QualityLevelForResource); + // 添加到FMaterialResource实例列表. + MaterialResources.Add(CurrentResource); + } + + (......) + + return CurrentResource; +} +``` +以上创建FMaterialResource实例时会优先使用有效的OwnerMaterialInstance，然后才使用UMaterial的接口，下面进入它们创建FMaterialResource实例的接口： +```c++ +FMaterialResource* UMaterialInstance::AllocatePermutationResource() +{ + return new FMaterialResource(); +} + +FMaterialResource* UMaterial::AllocateResource() +{ + return new FMaterialResource(); +} +``` +好家伙，逻辑一样的，都是直接new一个FMaterialResource对象并返回。下面继续追踪有哪些接口会调用FindOrCreateMaterialResource： +- ProcessSerializedInlineShaderMaps +- UMaterial::PostLoad +- UMaterial::CacheResourceShadersForRendering +- UMaterial::AllMaterialsCacheResourceShadersForRendering +- UMaterial::ForceRecompileForRendering +- UMaterial::PostEditChangePropertyInternal +- UMaterial::SetMaterialUsage +- UMaterial::UpdateMaterialShaders +- UMaterial::UpdateMaterialShaderCacheAndTextureReferences + +以上接口都会直接或间接调用到FindOrCreateMaterialResource接口，从而触发FMaterialResource对象的创建。但在运行时的版本中，通常由UMaterial::PostLoad触发，调用堆栈如下所示： +- UMaterial::PostLoad + - ProcessSerializedInlineShaderMaps + - FindOrCreateMaterialResource + +此外，UMaterialInstance的部分接口也会触发FMaterialResource实例的创建，此文不继续追踪了。 + +我们继续研究FMaterial的GameThreadShaderMap和RenderingThreadShaderMap是在何处何时被设置和传递的： +```c++ +// 直接设置RenderingThreadShaderMap +void FMaterial::SetRenderingThreadShaderMap(const TRefCountPtr& InMaterialShaderMap) +{ + RenderingThreadShaderMap = InMaterialShaderMap; +} + +// 设置游戏线程ShaderMap. +void FMaterial::SetGameThreadShaderMap(FMaterialShaderMap* InMaterialShaderMap) +{ + GameThreadShaderMap = InMaterialShaderMap; + + TRefCountPtr ShaderMap = GameThreadShaderMap; + TRefCountPtr Material = this; + // 向渲染线程推送设置ShaderMap的指令. + ENQUEUE_RENDER_COMMAND(SetGameThreadShaderMap)([Material = MoveTemp(Material), ShaderMap = MoveTemp(ShaderMap)](FRHICommandListImmediate& RHICmdList) mutable + { + Material->RenderingThreadShaderMap = MoveTemp(ShaderMap); + }); +} + +// 设置内联ShaderMap +void FMaterial::SetInlineShaderMap(FMaterialShaderMap* InMaterialShaderMap) +{ + GameThreadShaderMap = InMaterialShaderMap; + bContainsInlineShaders = true; + bLoadedCookedShaderMapId = true; + + TRefCountPtr ShaderMap = GameThreadShaderMap; + TRefCountPtr Material = this; + // 向渲染线程推送设置ShaderMap的指令. + ENQUEUE_RENDER_COMMAND(SetInlineShaderMap)([Material = MoveTemp(Material), ShaderMap = MoveTemp(ShaderMap)](FRHICommandListImmediate& RHICmdList) mutable + { + Material->RenderingThreadShaderMap = MoveTemp(ShaderMap); + }); +} +``` +以上可以设置FMaterial的RenderingThreadShaderMap有3个接口，继续追踪有哪些接口会调用到它们： +- FMaterial::CacheShaders + - FMaterial::SetGameThreadShaderMap +- FMaterialShaderMap::LoadForRemoteRecompile + - FMaterial::SetGameThreadShaderMap +- ProcessSerializedInlineShaderMaps + - FMaterial::SetInlineShaderMap +- SetShaderMapsOnMaterialResources_RenderThread + - FMaterial::SetRenderingThreadShaderMap + +虽然上面有很多接口最终会设置到FMaterial的RenderingThreadShaderMap，不过多数情况下，运行时RenderingThreadShaderMap被设置的调用堆栈如下： +- UMaterial::PostLoad + - ProcessSerializedInlineShaderMaps + - FMaterial::SetInlineShaderMap + +一旦FMaterial的RenderingThreadShaderMap被正确设置，材质相关的其它众多数据将被渲染线程和渲染器自由地读取，如同鱼儿无忧无虑地遨游在湛蓝的大海之中。 + +# 材质编译 +UMaterialExpression就是表达式，每个材质节点UMaterialGraphNode都有一个UMaterialExpression实例。下面进入FMaterialCompiler（是抽象类，由子类FHLSLMaterialTranslator实现）的这两个接口的实现： +```c++ +// Engine\Source\Runtime\Engine\Private\Materials\HLSLMaterialTranslator.cpp + +int32 FHLSLMaterialTranslator::Add(int32 A,int32 B) +{ + if(A == INDEX_NONE || B == INDEX_NONE) + { + return INDEX_NONE; + } + + const uint64 Hash = CityHash128to64({ GetParameterHash(A), GetParameterHash(B) }); + if(GetParameterUniformExpression(A) && GetParameterUniformExpression(B)) + { + return AddUniformExpressionWithHash(Hash, new FMaterialUniformExpressionFoldedMath(GetParameterUniformExpression(A),GetParameterUniformExpression(B),FMO_Add),GetArithmeticResultType(A,B),TEXT("(%s + %s)"),*GetParameterCode(A),*GetParameterCode(B)); + } + else + { + return AddCodeChunkWithHash(Hash, GetArithmeticResultType(A,B),TEXT("(%s + %s)"),*GetParameterCode(A),*GetParameterCode(B)); + } +} + +int32 FHLSLMaterialTranslator::DDX( int32 X ) +{ + if (X == INDEX_NONE) + { + return INDEX_NONE; + } + + if (ShaderFrequency == SF_Compute) + { + // running a material in a compute shader pass (e.g. when using SVOGI) + return AddInlinedCodeChunk(MCT_Float, TEXT("0")); + } + + if (ShaderFrequency != SF_Pixel) + { + return NonPixelShaderExpressionError(); + } + + return AddCodeChunk(GetParameterType(X),TEXT("DDX(%s)"),*GetParameterCode(X)); +} +``` + +**UMaterialGraphNode即我们在材质编辑器创建的材质节点**，继承的父类依次是UMaterialGraphNode_Base、UEdGraphNode。 + +## FHLSLMaterialTranslator +FHLSLMaterialTranslator继承自FMaterialCompiler，作用就是将材质的表达式转译成HLSL代码，填充到MaterialTemplate.ush的宏和空缺代码段。 +```c++ +// Engine\Source\Runtime\Engine\Public\MaterialCompiler.h +class FMaterialCompiler +{ +public: + virtual ~FMaterialCompiler() { } + // 材质属性接口. + virtual void SetMaterialProperty(EMaterialProperty InProperty, EShaderFrequency OverrideShaderFrequency = SF_NumFrequencies, bool bUsePreviousFrameTime = false) = 0; + virtual void PushMaterialAttribute(const FGuid& InAttributeID) = 0; + virtual FGuid PopMaterialAttribute() = 0; + virtual const FGuid GetMaterialAttribute() = 0; + virtual void SetBaseMaterialAttribute(const FGuid& InAttributeID) = 0; + virtual void PushParameterOwner(const FMaterialParameterInfo& InOwnerInfo) = 0; + virtual FMaterialParameterInfo PopParameterOwner() = 0; + + // 调用材质表达式. + virtual int32 CallExpression(FMaterialExpressionKey ExpressionKey,FMaterialCompiler* InCompiler) = 0; + + // 平台和着色模型相关. + virtual EShaderFrequency GetCurrentShaderFrequency() const = 0; + virtual EMaterialCompilerType GetCompilerType() const; + inline bool IsVertexInterpolatorBypass() const; + virtual EMaterialValueType GetType(int32 Code) = 0; + virtual EMaterialQualityLevel::Type GetQualityLevel() = 0; + virtual ERHIFeatureLevel::Type GetFeatureLevel() = 0; + virtual EShaderPlatform GetShaderPlatform() = 0; + virtual const ITargetPlatform* GetTargetPlatform() const = 0; + virtual FMaterialShadingModelField GetMaterialShadingModels() const = 0; + (......) + // 材质表达式对应的接口. + virtual int32 AccessCollectionParameter(UMaterialParameterCollection* ParameterCollection, int32 ParameterIndex, int32 ComponentIndex) = 0; + virtual int32 ScalarParameter(FName ParameterName, float DefaultValue) = 0; + virtual int32 VectorParameter(FName ParameterName, const FLinearColor& DefaultValue) = 0; + virtual int32 Constant(float X) = 0; + virtual int32 Constant2(float X,float Y) = 0; + virtual int32 Sine(int32 X) = 0; + virtual int32 Cosine(int32 X) = 0; + virtual int32 Tangent(int32 X) = 0; + virtual int32 ReflectionVector() = 0; + + virtual int32 If(int32 A,int32 B,int32 AGreaterThanB,int32 AEqualsB,int32 ALessThanB,int32 Threshold) = 0; + virtual int32 VertexInterpolator(uint32 InterpolatorIndex) = 0; + + virtual int32 Add(int32 A,int32 B) = 0; + virtual int32 Sub(int32 A,int32 B) = 0; + virtual int32 Mul(int32 A,int32 B) = 0; + virtual int32 Div(int32 A,int32 B) = 0; + virtual int32 Dot(int32 A,int32 B) = 0; + virtual int32 Cross(int32 A,int32 B) = 0; + + virtual int32 DDX(int32 X) = 0; + virtual int32 DDY(int32 X) = 0; + + (......) +}; + +// Engine\Source\Runtime\Engine\Private\Materials\HLSLMaterialTranslator.h +class FHLSLMaterialTranslator : public FMaterialCompiler +{ +protected: + // 编译的材质. + FMaterial* Material; + // 编译输出结果, 会被存储到DDC. + FMaterialCompilationOutput& MaterialCompilationOutput; + + // 资源字符串. + FString ResourcesString; + // MaterialTemplate.usf字符串内容. + FString MaterialTemplate; + + // 平台相关. + EShaderFrequency ShaderFrequency; + EShaderPlatform Platform; + EMaterialQualityLevel::Type QualityLevel; + ERHIFeatureLevel::Type FeatureLevel; + FMaterialShadingModelField ShadingModelsFromCompilation; + const ITargetPlatform* TargetPlatform; + + // 编译的中间数据. + EMaterialProperty MaterialProperty; + TArray MaterialAttributesStack; + TArray ParameterOwnerStack; + TArray* CurrentScopeChunks; + bool SharedPixelProperties[CompiledMP_MAX]; + TArray FunctionStacks[SF_NumFrequencies]; + FStaticParameterSet StaticParameters; + + TArray SharedPropertyCodeChunks[SF_NumFrequencies]; + TArray UniformExpressions; + TArray > UniformVectorExpressions; + TArray > UniformScalarExpressions; + TArray > UniformTextureExpressions[NumMaterialTextureParameterTypes]; + TArray> UniformExternalTextureExpressions; + + TArray ParameterCollections; + TArray CustomExpressions; + TArray CustomOutputImplementations; + TArray CustomVertexInterpolators; + + // 顶点工厂栈入口. + TArray VTStacks; + FHashTable VTStackHash; + + TBitArray<> AllocatedUserTexCoords; + TBitArray<> AllocatedUserVertexTexCoords; + (.....) +public: + // 执行HLSL转译. + bool Translate(); + // 获取材质环境. + void GetMaterialEnvironment(EShaderPlatform InPlatform, FShaderCompilerEnvironment& OutEnvironment); + void GetSharedInputsMaterialCode(FString& PixelMembersDeclaration, FString& NormalAssignment, FString& PixelMembersInitializationEpilog); + // 获取材质着色器代码. + FString GetMaterialShaderCode(); +protected: + // 获取所有定义. + FString GetDefinitions(TArray& CodeChunks, int32 StartChunk, int32 EndChunk) const; + + // 代码块. + int32 AddCodeChunkInner(uint64 Hash, const TCHAR* FormattedCode, EMaterialValueType Type, bool bInlined); + int32 AddCodeChunk(EMaterialValueType Type, const TCHAR* Format, ...); + int32 AddCodeChunkWithHash(uint64 BaseHash, EMaterialValueType Type, const TCHAR* Format, ...); + int32 AddInlinedCodeChunk(EMaterialValueType Type, const TCHAR* Format, ...); + int32 AddInlinedCodeChunkWithHash(uint64 BaseHash, EMaterialValueType Type, const TCHAR* Format, ...); + + int32 AddUniformExpressionInner(uint64 Hash, FMaterialUniformExpression* UniformExpression, EMaterialValueType Type, const TCHAR* FormattedCode); + int32 AddUniformExpression(FMaterialUniformExpression* UniformExpression, EMaterialValueType Type, const TCHAR* Format, ...); + int32 AddUniformExpressionWithHash(uint64 BaseHash, FMaterialUniformExpression* UniformExpression, EMaterialValueType Type, const TCHAR* Format, ...); + + // 材质表达式. + virtual int32 Sine(int32 X) override; + virtual int32 Cosine(int32 X) override; + virtual int32 Tangent(int32 X) override; + virtual int32 Arcsine(int32 X) override; + virtual int32 ArcsineFast(int32 X) override; + virtual int32 Arccosine(int32 X) override; + virtual int32 Floor(int32 X) override; + virtual int32 Ceil(int32 X) override; + virtual int32 Round(int32 X) override; + virtual int32 Truncate(int32 X) override; + virtual int32 Sign(int32 X) override; + virtual int32 Frac(int32 X) override; + virtual int32 Fmod(int32 A, int32 B) override; + (......) +}; +``` \ No newline at end of file diff --git a/08-Assets/Images/ImageBag/Images/UE_UMaterial.png b/08-Assets/Images/ImageBag/Images/UE_UMaterial.png new file mode 100644 index 0000000..01557fc Binary files /dev/null and b/08-Assets/Images/ImageBag/Images/UE_UMaterial.png differ