Unreal Engine开发：Unreal Engine基础入门_（8）.材质与纹理

于 2025-07-02 23:17:48 发布
阅读量587 收藏 21
点赞数 16
CC 4.0 BY-SA版权
分类专栏： 虚拟现实游戏2 文章标签： 虚幻 材质 游戏引擎 java 服务器 unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenlz2007/article/details/149081025

材质与纹理

在Unreal Engine中，材质与纹理是创建逼真和引人入胜的虚拟现实游戏的关键要素。本节将详细介绍如何在Unreal Engine中使用材质和纹理，包括它们的基本概念、创建方法、编辑技巧以及应用实例。

材质的基本概念

材质是用于定义物体表面外观的资源。在Unreal Engine中，材质可以通过多种方式来创建和编辑，以实现不同的视觉效果。材质主要由以下几个部分组成：

  1. 材质表达式：这些是用于定义材质属性的节点，如颜色、粗糙度、金属度等。

  2. 材质输入：这些是材质属性的输入端口，用于连接不同的材质表达式。

  3. 材质输出：这是材质属性的输出端口，用于将材质属性应用到物体的表面。

  4. 材质参数：这些是可以在材质中进行调整的变量，使得材质可以灵活地适应不同的场景和需求。

材质类型

Unreal Engine支持多种材质类型，每种类型都有其特定的用途和属性：

  • 基础材质：用于定义物体的基本表面属性。

  • 透明材质：用于定义透明或半透明的表面，如玻璃、水等。

  • 不透明材质：用于定义不透明的表面，如金属、木材等。

  • 遮罩材质：用于定义遮罩效果，如树叶、草地等。

创建和编辑材质

创建材质

在Unreal Engine中创建材质的步骤如下：

  1. 打开内容浏览器：首先，打开Unreal Engine的内容浏览器。

  2. 右键点击空白区域：在内容浏览器中右键点击空白区域。

  3. 选择创建材质：在弹出的菜单中选择“Material”。

  4. 命名材质：为新创建的材质命名，例如“M_Wood”。

  5. 双击材质：双击新创建的材质以打开材质编辑器。

编辑材质

在材质编辑器中，可以使用材质表达式来编辑材质的属性。以下是一些常用的材质表达式：

  • Constant：用于设置常量值。

  • TextureSample：用于采样纹理。

  • LinearInterpolate (Lerp)：用于在两个值之间进行线性插值。

  • Multiply：用于将两个值相乘。

  • Add：用于将两个值相加。

示例：创建一个简单的木材质

  1. 创建纹理：首先，创建或导入一张木材质纹理。假设我们已经有一张名为“T_Wood”的纹理。

  2. 打开材质编辑器：双击新创建的“M_Wood”材质以打开材质编辑器。

  3. 添加TextureSample节点：在材质编辑器中，右键点击空白区域，选择“TextureSample”，然后从弹出的菜单中选择“T_Wood”纹理。

  4. 连接节点：将“TextureSample”节点的输出连接到材质的“Base Color”输入。

  5. 设置粗糙度：右键点击空白区域，选择“Constant”，然后将值设置为0.7。将“Constant”节点的输出连接到材质的“Roughness”输入。

  6. 设置金属度：右键点击空白区域，选择“Constant”，然后将值设置为0.0。将“Constant”节点的输出连接到材质的“Metallic”输入。

  7. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：创建一个简单的木材质

UMaterial* CreateSimpleWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_Wood"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood")));

    UMaterialExpressionTextureSample* TextureSample = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample->Texture = WoodTexture;



    // 创建Constant节点

    UMaterialExpressionConstant* RoughnessConstant = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionConstant::StaticClass());

    RoughnessConstant->R = 0.7f;



    UMaterialExpressionConstant* MetallicConstant = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionConstant::StaticClass());

    MetallicConstant->R = 0.0f;



    // 连接节点

    MaterialEditor->ConnectMaterialExpression(TextureSample, TEXT(""), Material, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(RoughnessConstant, TEXT(""), Material, TEXT("Roughness"));

    MaterialEditor->ConnectMaterialExpression(MetallicConstant, TEXT(""), Material, TEXT("Metallic"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

材质参数

材质参数使得材质可以更加灵活地适应不同的场景。常见的材质参数包括：

  • Scalar Parameter：用于设置浮点数值。

  • Vector Parameter：用于设置颜色或向量值。

  • Texture Parameter：用于设置纹理。

示例：使用材质参数创建一个可调节的木材质

  1. 创建材质参数：在材质编辑器中，右键点击空白区域，选择“Scalar Parameter”，然后命名为“RoughnessParam”。

  2. 连接参数：将“RoughnessParam”节点的输出连接到材质的“Roughness”输入。

  3. 设置参数值：在材质编辑器的细节面板中，设置“RoughnessParam”的默认值为0.7。

  4. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：使用材质参数创建一个可调节的木材质

UMaterial* CreateParameterizedWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_Wood_Param"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood")));

    UMaterialExpressionTextureSample* TextureSample = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample->Texture = WoodTexture;



    // 创建Scalar Parameter节点

    UMaterialExpressionScalarParameter* RoughnessParam = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionScalarParameter::StaticClass());

    RoughnessParam->ParameterName = TEXT("RoughnessParam");

    RoughnessParam->DefaultValue = 0.7f;



    // 创建Vector Parameter节点

    UMaterialExpressionVectorParameter* BaseColorParam = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionVectorParameter::StaticClass());

    BaseColorParam->ParameterName = TEXT("BaseColorParam");

    BaseColorParam->DefaultValue = FLinearColor(1.0f, 0.647f, 0.376f, 1.0f); // 木材质的默认颜色



    // 连接节点

    MaterialEditor->ConnectMaterialExpression(TextureSample, TEXT(""), Material, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(RoughnessParam, TEXT(""), Material, TEXT("Roughness"));

    MaterialEditor->ConnectMaterialExpression(BaseColorParam, TEXT(""), Material, TEXT("BaseColor"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

纹理的基本概念

纹理是用于定义物体表面细节的图像资源。在Unreal Engine中，纹理可以用于多种目的，包括：

  • 基础颜色：定义物体的颜色。

  • 法线贴图：定义物体表面的凹凸效果。

  • 粗糙度贴图：定义物体表面的粗糙度。

  • 金属度贴图：定义物体表面的金属度。

  • AO（环境光遮挡）贴图：定义物体表面的阴影效果。

创建和导入纹理

  1. 创建纹理：在内容浏览器中右键点击空白区域，选择“Texture2D”。

  2. 导入纹理：将外部纹理文件拖入内容浏览器，或者右键点击空白区域，选择“Import”，然后选择纹理文件。

  3. 设置纹理属性：在纹理的细节面板中，设置纹理的属性，如“Compression Settings”、“LOD Group”等。

纹理属性

纹理属性决定了纹理在渲染中的表现。常见的纹理属性包括：

  • Compression Settings：纹理的压缩设置，影响纹理的文件大小和渲染效果。

  • LOD Group：纹理的细节层次设置，影响纹理在不同距离下的显示。

  • Filter：纹理的过滤方式，影响纹理在缩放时的平滑度。

示例：导入并设置一个木材质纹理

  1. 创建纹理：在内容浏览器中右键点击空白区域，选择“Texture2D”。

  2. 导入纹理：将外部木材质纹理文件拖入内容浏览器，或者右键点击空白区域，选择“Import”，然后选择纹理文件。

  3. 设置纹理属性：在纹理的细节面板中，设置“Compression Settings”为“TC_Default”，“LOD Group”为“TEXTUREGROUP_World”，“Filter”为“Point”（无平滑）。


// 示例代码：导入并设置一个木材质纹理

UTexture2D* ImportWoodTexture(UObject* Outer, const FString& FilePath)

{

    // 导入纹理

    FString PackageName = FPaths::Combine(Outer->GetPathName(), "T_Wood");

    UPackage* Package = CreatePackage(*PackageName);

    FString AssetName = FPaths::GetBaseFilename(FilePath);

    UTexture2D* WoodTexture = Cast<UTexture2D>(FEditorFileUtils::ImportAsset(FilePath, Package, AssetName));



    // 设置纹理属性

    if (WoodTexture)

    {

        WoodTexture->CompressionSettings = TextureCompressionSettings::TC_Default;

        WoodTexture->LODGroup = TextureGroup::TEXTUREGROUP_World;

        WoodTexture->Filter = ETextureFilter::Point;

        WoodTexture->UpdateResource();

    }



    return WoodTexture;

}

材质实例

材质实例是材质的一个实例，可以在运行时动态调整材质参数。这使得同一材质可以用于多个物体，而每个物体的材质属性可以不同。

创建材质实例

  1. 打开内容浏览器：首先，打开Unreal Engine的内容浏览器。

  2. 右键点击空白区域：在内容浏览器中右键点击空白区域。

  3. 选择创建材质实例：在弹出的菜单中选择“Material Instance Dynamic”或“Material Instance Constant”。

  4. 命名材质实例：为新创建的材质实例命名，例如“MI_Wood”。

  5. 选择基础材质：在材质实例的细节面板中，选择基础材质“M_Wood_Param”。

  6. 调整参数值：在材质实例的细节面板中，调整“RoughnessParam”和“BaseColorParam”的值。

使用材质实例

材质实例可以在蓝图中动态调整，也可以在代码中动态设置。以下是一个使用材质实例的示例：

示例：在蓝图中使用材质实例

  1. 创建材质实例：在内容浏览器中右键点击空白区域，选择“Material Instance Dynamic”，然后选择基础材质“M_Wood_Param”。

  2. 创建蓝图：在内容浏览器中右键点击空白区域，选择“Blueprint Class”，然后选择“Actor”。

  3. 打开蓝图编辑器：双击新创建的蓝图以打开蓝图编辑器。

  4. 创建StaticMeshComponent：在蓝图编辑器中，右键点击组件列表，选择“Add Component”，然后选择“Static Mesh”。

  5. 设置StaticMesh：在StaticMeshComponent的细节面板中，选择一个木材质的Static Mesh。

  6. 设置材质实例：在StaticMeshComponent的细节面板中，选择“Material Slot”，然后设置为创建的材质实例“MI_Wood”。

  7. 调整材质参数：在事件图表中，使用“Set Scalar Parameter Value”和“Set Vector Parameter Value”节点来动态调整材质参数。


// 示例代码：在代码中创建和使用材质实例

UMaterialInstanceDynamic* CreateAndUseWoodMaterialInstance(AActor* Actor, const FString& MaterialPath, const FString& MeshPath)

{

    // 加载基础材质

    UMaterial* BaseMaterial = Cast<UMaterial>(StaticLoadObject(UMaterial::StaticClass(), NULL, *MaterialPath));

    if (!BaseMaterial)

    {

        UE_LOG(LogTemp, Warning, TEXT("Base material not found: %s"), *MaterialPath);

        return nullptr;

    }



    // 创建材质实例

    UMaterialInstanceDynamic* MaterialInstance = UMaterialInstanceDynamic::Create(BaseMaterial, Actor);

    if (MaterialInstance)

    {

        // 设置材质参数

        MaterialInstance->SetScalarParameterValue(TEXT("RoughnessParam"), 0.5f);

        MaterialInstance->SetVectorParameterValue(TEXT("BaseColorParam"), FLinearColor(1.0f, 0.5f, 0.3f, 1.0f));



        // 加载Static Mesh

        UStaticMesh* StaticMesh = Cast<UStaticMesh>(StaticLoadObject(UStaticMesh::StaticClass(), NULL, *MeshPath));

        if (!StaticMesh)

        {

            UE_LOG(LogTemp, Warning, TEXT("Static mesh not found: %s"), *MeshPath);

            return MaterialInstance;

        }



        // 创建StaticMeshComponent

        UStaticMeshComponent* MeshComponent = NewObject<UStaticMeshComponent>(Actor);

        MeshComponent->SetStaticMesh(StaticMesh);

        MeshComponent->SetMaterial(0, MaterialInstance);

        MeshComponent->RegisterComponent();



        // 将组件添加到Actor

        Actor->AddInstanceComponent(MeshComponent);

    }



    return MaterialInstance;

}

材质函数

材质函数是用于封装常用材质逻辑的资源，可以被多个材质复用。这使得材质的管理和维护更加方便。

创建材质函数

  1. 打开内容浏览器：首先，打开Unreal Engine的内容浏览器。

  2. 右键点击空白区域：在内容浏览器中右键点击空白区域。

  3. 选择创建材质函数：在弹出的菜单中选择“Material Function”。

  4. 命名材质函数：为新创建的材质函数命名，例如“MF_WoodPattern”。

  5. 双击材质函数：双击新创建的材质函数以打开材质函数编辑器。

  6. 添加输入和输出：在材质函数编辑器中，添加输入和输出节点。

  7. 编辑材质逻辑：使用材质表达式编辑材质逻辑。

使用材质函数

材质函数可以在材质编辑器中被复用。以下是一个使用材质函数的示例：

示例：创建一个木材质函数并使用

  1. 创建材质函数：在内容浏览器中右键点击空白区域，选择“Material Function”，然后命名为“MF_WoodPattern”。

  2. 编辑材质函数：双击“MF_WoodPattern”以打开材质函数编辑器，添加“TextureSample”节点和“Multiply”节点，将“TextureSample”节点的输出连接到“Multiply”节点的一个输入，将“Multiply”节点的输出连接到“Output”节点。

  3. 创建材质：在内容浏览器中右键点击空白区域，选择“Material”，然后命名为“M_Wood_Function”。

  4. 编辑材质：双击“M_Wood_Function”以打开材质编辑器，添加“MF_WoodPattern”节点，将“MF_WoodPattern”节点的输出连接到材质的“Base Color”输入。

  5. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：创建一个木材质函数并使用

UMaterialFunction* CreateWoodPatternFunction(UObject* Outer)

{

    // 创建材质函数

    UMaterialFunction* Function = NewObject<UMaterialFunction>(Outer, UMaterialFunction::StaticClass(), TEXT("MF_WoodPattern"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood")));

    UMaterialExpressionTextureSample* TextureSample = MaterialEditor->CreateMaterialExpression(Function, UMaterialExpressionTextureSample::StaticClass());

    TextureSample->Texture = WoodTexture;



    // 创建Multiply节点

    UMaterialExpressionMultiply* Multiply = MaterialEditor->CreateMaterialExpression(Function, UMaterialExpressionMultiply::StaticClass());

    MaterialEditor->ConnectMaterialExpression(TextureSample, TEXT(""), Multiply, TEXT("A"));



    // 创建Constant节点

    UMaterialExpressionConstant* Constant = MaterialEditor->CreateMaterialExpression(Function, UMaterialExpressionConstant::StaticClass());

    Constant->R = 0.5f;

    MaterialEditor->ConnectMaterialExpression(Constant, TEXT(""), Multiply, TEXT("B"));



    // 创建Output节点

    UMaterialExpressionFunctionOutput* Output = MaterialEditor->CreateMaterialExpression(Function, UMaterialExpressionFunctionOutput::StaticClass());

    MaterialEditor->ConnectMaterialExpression(Multiply, TEXT(""), Output, TEXT(""));



    // 应用材质函数

    MaterialEditor->CompileMaterial(Function);



    return Function;

}



UMaterial* CreateWoodMaterialWithFunction(UObject* Outer, const FString& FunctionPath)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_Wood_Function"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 加载材质函数

    UMaterialFunction* WoodPatternFunction = Cast<UMaterialFunction>(StaticLoadObject(UMaterialFunction::StaticClass(), NULL, *FunctionPath));

    if (!WoodPatternFunction)

    {

        UE_LOG(LogTemp, Warning, TEXT("Material function not found: %s"), *FunctionPath);

        return Material;

    }



    // 创建FunctionCall节点

    UMaterialExpressionFunctionCall* FunctionCall = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionFunctionCall::StaticClass());

    FunctionCall->MaterialFunction = WoodPatternFunction;



    // 连接节点

    MaterialEditor->ConnectMaterialExpression(FunctionCall, TEXT(""), Material, TEXT("BaseColor"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

材质编辑器高级技巧

材质编辑器中还有一些高级技巧，可以用于创建更复杂和精细的材质效果。以下是一些常用的高级技巧：

使用材质表达式组合

材质表达式可以组合使用，以实现更复杂的材质效果。例如，可以使用多个TextureSample节点来混合不同的纹理，或者使用Noise节点来添加随机的表面细节。

示例：创建一个混合纹理的材质

  1. 创建纹理：在内容浏览器中创建或导入两张纹理，假设分别为“T_Wood1”和“T_Wood2”。

  2. 打开材质编辑器：双击新创建的材质以打开材质编辑器。

  3. 添加TextureSample节点：在材质编辑器中，右键点击空白区域，选择“TextureSample”，然后从弹出的菜单中选择“T_Wood1”和“T_Wood2”纹理。

  4. 添加LinearInterpolate节点：在材质编辑器中，右键点击空白区域，选择“LinearInterpolate (Lerp)”，用于在两个纹理之间进行线性插值。

  5. 添加Scalar Parameter节点：在材质编辑器中，右键点击空白区域，选择“Scalar Parameter”，然后命名为“BlendFactor”。

  6. 连接节点：将“T_Wood1”和“T_Wood2”节点的输出分别连接到“LinearInterpolate”节点的“A”和“B”输入，将“BlendFactor”节点的输出连接到“LinearInterpolate”节点的“Alpha”输入。

  7. 设置参数值：在材质编辑器的细节面板中，设置“BlendFactor”的默认值为0.5。

  8. 连接到材质输出：将“LinearInterpolate”节点的输出连接到材质的“Base Color”输入。

  9. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：创建一个混合纹理的材质

UMaterial* CreateBlendedWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_BlendedWood"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture1 = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood1")));

    UTexture* WoodTexture2 = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood2")));

    UMaterialExpressionTextureSample* TextureSample1 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample1->Texture = WoodTexture1;

    UMaterialExpressionTextureSample* TextureSample2 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample2->Texture = WoodTexture2;



    // 创建LinearInterpolate节点

    UMaterialExpressionLinearInterpolate* Lerp = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionLinearInterpolate::StaticClass());



    // 创建Scalar Parameter节点

    UMaterialExpressionScalarParameter* BlendFactor = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionScalarParameter::StaticClass());

    BlendFactor->ParameterName = TEXT("BlendFactor");

    BlendFactor->DefaultValue = 0.5f;



    // 连接节点

    MaterialEditor->ConnectMaterialExpression(TextureSample1, TEXT(""), Lerp, TEXT("A"));

    MaterialEditor->ConnectMaterialExpression(TextureSample2, TEXT(""), Lerp, TEXT("B"));

    MaterialEditor->ConnectMaterialExpression(BlendFactor, TEXT(""), Lerp, TEXT("Alpha"));

    MaterialEditor->ConnectMaterialExpression(Lerp, TEXT(""), Material, TEXT("BaseColor"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

使用材质属性节点

材质属性节点可以用于更精细地控制材质的各个属性。例如，可以使用MaterialAttributes节点来组合多个属性，或者使用MaterialAttributeLayer节点来实现分层材质效果。

示例：创建一个分层材质

  1. 创建材质：在内容浏览器中创建一个新材质，命名为“M_LayeredWood”。

  2. 打开材质编辑器：双击新创建的材质以打开材质编辑器。

  3. 添加TextureSample节点：在材质编辑器中，右键点击空白区域，选择“TextureSample”，然后从弹出的菜单中选择“T_Wood1”和“T_Wood2”纹理。

  4. 添加MaterialAttributeLayer节点：在材质编辑器中，右键点击空白区域，选择“MaterialAttributeLayer”，用于实现分层材质效果。

  5. 添加Scalar Parameter节点：在材质编辑器中，右键点击空白区域，选择“Scalar Parameter”，然后命名为“LayerBlendFactor”。

  6. 连接节点：将“T_Wood1”和“T_Wood2”节点的输出分别连接到“MaterialAttributeLayer”节点的“Layer 1”和“Layer 2”输入，将“LayerBlendFactor”节点的输出连接到“MaterialAttributeLayer”节点的“Alpha”输入。

  7. 设置参数值：在材质编辑器的细节面板中，设置“LayerBlendFactor”的默认值为0.5。

  8. 连接到材质输出：将“MaterialAttributeLayer”节点的输出连接到材质的各个属性输入。

  9. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：创建一个分层材质

UMaterial* CreateLayeredWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_LayeredWood"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture1 = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood1")));

    UTexture* WoodTexture2 = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood2")));

    UMaterialExpressionTextureSample* TextureSample1 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample1->Texture = WoodTexture1;

    UMaterialExpressionTextureSample* TextureSample2 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample2->Texture = WoodTexture2;



    // 创建MaterialAttributeLayer节点

    UMaterialExpressionMaterialAttributeLayers* LayeredAttributes = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionMaterialAttributeLayers::StaticClass());



    // 创建Scalar Parameter节点

    UMaterialExpressionScalarParameter* LayerBlendFactor = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionScalarParameter::StaticClass());

    LayerBlendFactor->ParameterName = TEXT("LayerBlendFactor");

    LayerBlendFactor->DefaultValue = 0.5f;



    // 创建MaterialAttributes节点

    UMaterialExpressionMaterialAttributes* Attributes1 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionMaterialAttributes::StaticClass());

    UMaterialExpressionMaterialAttributes* Attributes2 = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionMaterialAttributes::StaticClass());



    // 连接TextureSample节点到MaterialAttributes节点

    MaterialEditor->ConnectMaterialExpression(TextureSample1, TEXT(""), Attributes1, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(TextureSample2, TEXT(""), Attributes2, TEXT("BaseColor"));



    // 连接MaterialAttributes节点到MaterialAttributeLayer节点

    MaterialEditor->ConnectMaterialExpression(Attributes1, TEXT(""), LayeredAttributes, TEXT("Layer 1"));

    MaterialEditor->ConnectMaterialExpression(Attributes2, TEXT(""), LayeredAttributes, TEXT("Layer 2"));

    MaterialEditor->ConnectMaterialExpression(LayerBlendFactor, TEXT(""), LayeredAttributes, TEXT("Alpha"));



    // 连接到材质输出

    MaterialEditor->ConnectMaterialExpression(LayeredAttributes, TEXT(""), Material, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(LayeredAttributes, TEXT(""), Material, TEXT("Roughness"));

    MaterialEditor->ConnectMaterialExpression(LayeredAttributes, TEXT(""), Material, TEXT("Metallic"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

使用材质属性节点优化性能

材质属性节点可以通过组合多个属性来减少材质编辑器中的节点数量，从而优化性能。例如，可以使用MaterialAttributes节点来组合颜色、粗糙度和金属度等属性。

示例：优化材质性能

  1. 创建材质：在内容浏览器中创建一个新材质，命名为“M_OptimizedWood”。

  2. 打开材质编辑器：双击新创建的材质以打开材质编辑器。

  3. 添加TextureSample节点：在材质编辑器中，右键点击空白区域，选择“TextureSample”，然后从弹出的菜单中选择“T_Wood”纹理。

  4. 添加MaterialAttributes节点：在材质编辑器中，右键点击空白区域，选择“MaterialAttributes”，用于组合多个属性。

  5. 添加Scalar Parameter节点：在材质编辑器中，右键点击空白区域，选择“Scalar Parameter”，然后命名为“RoughnessParam”和“MetallicParam”。

  6. 连接节点：将“TextureSample”节点的输出连接到“MaterialAttributes”节点的“BaseColor”输入，将“RoughnessParam”和“MetallicParam”节点的输出分别连接到“MaterialAttributes”节点的“Roughness”和“Metallic”输入。

  7. 设置参数值：在材质编辑器的细节面板中，设置“RoughnessParam”的默认值为0.7，设置“MetallicParam”的默认值为0.0。

  8. 连接到材质输出：将“MaterialAttributes”节点的输出连接到材质的各个属性输入。

  9. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：优化材质性能

UMaterial* CreateOptimizedWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_OptimizedWood"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood")));

    UMaterialExpressionTextureSample* TextureSample = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample->Texture = WoodTexture;



    // 创建MaterialAttributes节点

    UMaterialExpressionMaterialAttributes* MaterialAttributes = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionMaterialAttributes::StaticClass());



    // 创建Scalar Parameter节点

    UMaterialExpressionScalarParameter* RoughnessParam = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionScalarParameter::StaticClass());

    RoughnessParam->ParameterName = TEXT("RoughnessParam");

    RoughnessParam->DefaultValue = 0.7f;



    UMaterialExpressionScalarParameter* MetallicParam = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionScalarParameter::StaticClass());

    MetallicParam->ParameterName = TEXT("MetallicParam");

    MetallicParam->DefaultValue = 0.0f;



    // 连接节点

    MaterialEditor->ConnectMaterialExpression(TextureSample, TEXT(""), MaterialAttributes, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(RoughnessParam, TEXT(""), MaterialAttributes, TEXT("Roughness"));

    MaterialEditor->ConnectMaterialExpression(MetallicParam, TEXT(""), MaterialAttributes, TEXT("Metallic"));



    // 连接到材质输出

    MaterialEditor->ConnectMaterialExpression(MaterialAttributes, TEXT(""), Material, TEXT("BaseColor"));

    MaterialEditor->ConnectMaterialExpression(MaterialAttributes, TEXT(""), Material, TEXT("Roughness"));

    MaterialEditor->ConnectMaterialExpression(MaterialAttributes, TEXT(""), Material, TEXT("Metallic"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

使用材质蓝图

材质蓝图是一种可以动态调整材质参数的蓝图类。通过材质蓝图，可以实现更复杂的逻辑，例如根据时间变化调整材质颜色或透明度。

示例：创建一个动态变化的木材质蓝图

  1. 创建材质：在内容浏览器中创建一个新材质，命名为“M_DynamicWood”。

  2. 打开材质编辑器：双击新创建的材质以打开材质编辑器。

  3. 添加Time节点：在材质编辑器中，右键点击空白区域，选择“Time”节点。

  4. 添加Sine节点：在材质编辑器中，右键点击空白区域，选择“Sine”节点。

  5. 添加Multiply节点：在材质编辑器中，右键点击空白区域，选择“Multiply”节点。

  6. 添加Base Color节点：在材质编辑器中，右键点击空白区域，选择“TextureSample”，然后从弹出的菜单中选择“T_Wood”纹理。

  7. 连接节点：将“Time”节点的输出连接到“Sine”节点的输入，将“Sine”节点的输出连接到“Multiply”节点的一个输入，将“Base Color”节点的输出连接到“Multiply”节点的另一个输入。

  8. 连接到材质输出：将“Multiply”节点的输出连接到材质的“Base Color”输入。

  9. 保存材质：点击“Apply”按钮，然后保存材质。


// 示例代码：创建一个动态变化的木材质蓝图

UMaterial* CreateDynamicWoodMaterial(UObject* Outer)

{

    // 创建材质

    UMaterial* Material = NewObject<UMaterial>(Outer, UMaterial::StaticClass(), TEXT("M_DynamicWood"));



    // 创建材质编辑器

    UMaterialEditingLibrary* MaterialEditor = NewObject<UMaterialEditingLibrary>();



    // 创建TextureSample节点

    UTexture* WoodTexture = Cast<UTexture>(StaticLoadObject(UTexture::StaticClass(), NULL, TEXT("T_Wood")));

    UMaterialExpressionTextureSample* TextureSample = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTextureSample::StaticClass());

    TextureSample->Texture = WoodTexture;



    // 创建Time节点

    UMaterialExpressionTime* Time = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionTime::StaticClass());



    // 创建Sine节点

    UMaterialExpressionSine* Sine = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionSine::StaticClass());

    MaterialEditor->ConnectMaterialExpression(Time, TEXT(""), Sine, TEXT(""));



    // 创建Multiply节点

    UMaterialExpressionMultiply* Multiply = MaterialEditor->CreateMaterialExpression(Material, UMaterialExpressionMultiply::StaticClass());

    MaterialEditor->ConnectMaterialExpression(TextureSample, TEXT(""), Multiply, TEXT("A"));

    MaterialEditor->ConnectMaterialExpression(Sine, TEXT(""), Multiply, TEXT("B"));



    // 连接到材质输出

    MaterialEditor->ConnectMaterialExpression(Multiply, TEXT(""), Material, TEXT("BaseColor"));



    // 应用材质

    MaterialEditor->CompileMaterial(Material);



    return Material;

}

总结

在Unreal Engine中，材质和纹理是创建高质量虚拟现实游戏的关键要素。通过理解材质的基本概念、创建和编辑方法、材质参数的使用以及高级技巧，可以实现各种复杂的视觉效果。材质实例和材质函数的使用，使得材质的管理和维护更加方便和高效。希望本节的内容能帮助你在Unreal Engine中更好地利用材质和纹理资源。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值