Merge pull request #1687 from CesiumGS/non-instance-materials

Support Materials, not just MaterialInstances, and fix normal flip when computing tangents

Author: kring

Source/CesiumRuntime/Private/CesiumGltfComponent.cpp

@@ -643,6 +643,7 @@ static void mikkSetTSpaceBasic(
 
   TangentX.Y = -TangentX.Y;
   TangentY.Y = -TangentY.Y;
+  TangentZ.Y = -TangentZ.Y;
 
   vertexBuffer.SetVertexTangents(vertexIndex, TangentX, TangentY, TangentZ);
 }
@@ -3147,83 +3148,87 @@ static void loadPrimitiveGameThreadPart(
 
 #if PLATFORM_MAC
   // TODO: figure out why water material crashes mac
-  UMaterialInterface* pBaseMaterial = is_in_blend_mode(loadResult)
-                                          ? pGltf->BaseMaterialWithTranslucency
-                                          : pGltf->BaseMaterial;
+  UMaterialInterface* pUserDesignatedMaterial =
+      is_in_blend_mode(loadResult) ? pGltf->BaseMaterialWithTranslucency
+                                   : pGltf->BaseMaterial;
 #else
-  UMaterialInterface* pBaseMaterial;
+  UMaterialInterface* pUserDesignatedMaterial;
   if (loadResult.onlyWater || !loadResult.onlyLand) {
-    pBaseMaterial = pGltf->BaseMaterialWithWater;
+    pUserDesignatedMaterial = pGltf->BaseMaterialWithWater;
   } else {
-    pBaseMaterial = is_in_blend_mode(loadResult)
-                        ? pGltf->BaseMaterialWithTranslucency
-                        : pGltf->BaseMaterial;
+    pUserDesignatedMaterial = is_in_blend_mode(loadResult)
+                                  ? pGltf->BaseMaterialWithTranslucency
+                                  : pGltf->BaseMaterial;
   }
 #endif
 
-  UMaterialInstanceDynamic* pMaterial;
+  UMaterialInstanceDynamic* pMaterialForGltfPrimitive;
   {
     TRACE_CPUPROFILER_EVENT_SCOPE(Cesium::SetupMaterial)
 
-    UMaterialInstanceDynamic* pBaseAsMaterialInstanceDynamic =
-        Cast<UMaterialInstanceDynamic>(pBaseMaterial);
-    UMaterialInstance* pParentMaterialInstance =
-        Cast<UMaterialInstance>(pBaseMaterial);
+    UMaterialInstanceDynamic* pUserDesignatedMaterialAsDynamic =
+        Cast<UMaterialInstanceDynamic>(pUserDesignatedMaterial);
 
-    // If the base material is a UMaterialInstanceDynamic, Create() will
-    // reject it as a valid instance parent.  Defer to its non-dynamic parent
-    // instead.
-    if (pBaseAsMaterialInstanceDynamic) {
-      pParentMaterialInstance =
-          Cast<UMaterialInstance>(pParentMaterialInstance->Parent.Get());
-    }
+    // If the user-designated material is a UMaterialInstanceDynamic, Create()
+    // will reject it as a valid instance parent.  Defer to its non-dynamic
+    // parent instead.
+    UMaterialInterface* pBaseMaterial =
+        pUserDesignatedMaterialAsDynamic
+            ? pUserDesignatedMaterialAsDynamic->Parent.Get()
+            : pUserDesignatedMaterial;
 
-    pMaterial = UMaterialInstanceDynamic::Create(
-        pParentMaterialInstance,
+    pMaterialForGltfPrimitive = UMaterialInstanceDynamic::Create(
+        pBaseMaterial,
         nullptr,
         ImportedSlotName);
 
-    pMaterial->SetFlags(
+    pMaterialForGltfPrimitive->SetFlags(
         RF_Transient | RF_DuplicateTransient | RF_TextExportTransient);
     SetGltfParameterValues(
         model,
         loadResult,
         material,
         pbr,
-        pMaterial,
+        pMaterialForGltfPrimitive,
         EMaterialParameterAssociation::GlobalParameter,
         INDEX_NONE);
     SetWaterParameterValues(
         model,
         loadResult,
-        pMaterial,
+        pMaterialForGltfPrimitive,
         EMaterialParameterAssociation::GlobalParameter,
         INDEX_NONE);
 
+    // The base material might be a Material, or it might be a MaterialInstance.
+    // Only MaterialInstances can use the material layer system, so only
+    // MaterialInstances will have UCesiumMaterialUserData.
+    UMaterialInstance* pBaseAsMaterialInstance =
+        Cast<UMaterialInstance>(pBaseMaterial);
+
     UCesiumMaterialUserData* pCesiumData =
-        pParentMaterialInstance
-            ? pParentMaterialInstance
+        pBaseAsMaterialInstance
+            ? pBaseAsMaterialInstance
                   ->GetAssetUserData<UCesiumMaterialUserData>()
             : nullptr;
 
     // If possible and necessary, attach the CesiumMaterialUserData now.
 #if WITH_EDITORONLY_DATA
-    if (pParentMaterialInstance && !pCesiumData) {
+    if (pBaseAsMaterialInstance && !pCesiumData) {
       const FStaticParameterSet& parameters =
-          pParentMaterialInstance->GetStaticParameters();
+          pBaseAsMaterialInstance->GetStaticParameters();
 
       bool hasLayers = parameters.bHasMaterialLayers;
       if (hasLayers) {
 #if WITH_EDITOR
         FScopedTransaction transaction(
             FText::FromString("Add Cesium User Data to Material"));
-        pParentMaterialInstance->Modify();
+        pBaseAsMaterialInstance->Modify();
 #endif
         pCesiumData = NewObject<UCesiumMaterialUserData>(
-            pParentMaterialInstance,
+            pBaseAsMaterialInstance,
             NAME_None,
             RF_Transactional);
-        pParentMaterialInstance->AddAssetUserData(pCesiumData);
+        pBaseAsMaterialInstance->AddAssetUserData(pCesiumData);
         pCesiumData->PostEditChangeOwner();
       }
     }
@@ -3232,11 +3237,13 @@ static void loadPrimitiveGameThreadPart(
     // If CesiumMaterialUserData was not attached (e.g., material was
     // dynamically created at runtime), then walk the parent chain of the
     // material to find it.
-    while (pParentMaterialInstance && !pCesiumData) {
-      pParentMaterialInstance =
-          Cast<UMaterialInstance>(pParentMaterialInstance->Parent.Get());
-      pCesiumData =
-          pParentMaterialInstance->GetAssetUserData<UCesiumMaterialUserData>();
+    while (pBaseAsMaterialInstance && !pCesiumData) {
+      pBaseAsMaterialInstance =
+          Cast<UMaterialInstance>(pBaseAsMaterialInstance->Parent.Get());
+      if (pBaseAsMaterialInstance) {
+        pCesiumData = pBaseAsMaterialInstance
+                          ->GetAssetUserData<UCesiumMaterialUserData>();
+      }
     }
 
     if (pCesiumData) {
@@ -3245,21 +3252,21 @@ static void loadPrimitiveGameThreadPart(
           loadResult,
           material,
           pbr,
-          pMaterial,
+          pMaterialForGltfPrimitive,
           EMaterialParameterAssociation::LayerParameter,
           0);
 
       // Initialize fade uniform to fully visible, in case LOD transitions
       // are off.
       int fadeLayerIndex = pCesiumData->LayerNames.Find("DitherFade");
       if (fadeLayerIndex >= 0) {
-        pMaterial->SetScalarParameterValueByInfo(
+        pMaterialForGltfPrimitive->SetScalarParameterValueByInfo(
             FMaterialParameterInfo(
                 "FadePercentage",
                 EMaterialParameterAssociation::LayerParameter,
                 fadeLayerIndex),
             1.0f);
-        pMaterial->SetScalarParameterValueByInfo(
+        pMaterialForGltfPrimitive->SetScalarParameterValueByInfo(
             FMaterialParameterInfo(
                 "FadingType",
                 EMaterialParameterAssociation::LayerParameter,
@@ -3273,7 +3280,7 @@ static void loadPrimitiveGameThreadPart(
         SetWaterParameterValues(
             model,
             loadResult,
-            pMaterial,
+            pMaterialForGltfPrimitive,
             EMaterialParameterAssociation::LayerParameter,
             waterIndex);
       }
@@ -3286,7 +3293,7 @@ static void loadPrimitiveGameThreadPart(
             model,
             *pGltf,
             loadResult,
-            pMaterial,
+            pMaterialForGltfPrimitive,
             EMaterialParameterAssociation::LayerParameter,
             featuresMetadataIndex);
       } else if (metadataIndex >= 0) {
@@ -3295,42 +3302,43 @@ static void loadPrimitiveGameThreadPart(
             model,
             *pGltf,
             loadResult,
-            pMaterial,
+            pMaterialForGltfPrimitive,
             EMaterialParameterAssociation::LayerParameter,
             metadataIndex);
       }
     }
 
-    if (pBaseAsMaterialInstanceDynamic) {
+    if (pUserDesignatedMaterialAsDynamic) {
       // Ensure any parameters on the original UMaterialInstanceDynamic are
       // transferred to the copy.
-      for (auto& it : pBaseAsMaterialInstanceDynamic->ScalarParameterValues) {
-        pMaterial->SetScalarParameterValueByInfo(
+      for (auto& it : pUserDesignatedMaterialAsDynamic->ScalarParameterValues) {
+        pMaterialForGltfPrimitive->SetScalarParameterValueByInfo(
             it.ParameterInfo,
             it.ParameterValue);
       }
 
-      for (auto& it : pBaseAsMaterialInstanceDynamic->VectorParameterValues) {
-        pMaterial->SetVectorParameterValueByInfo(
+      for (auto& it : pUserDesignatedMaterialAsDynamic->VectorParameterValues) {
+        pMaterialForGltfPrimitive->SetVectorParameterValueByInfo(
             it.ParameterInfo,
             it.ParameterValue);
       }
 
       for (auto& it :
-           pBaseAsMaterialInstanceDynamic->DoubleVectorParameterValues) {
-        pMaterial->SetVectorParameterValueByInfo(
+           pUserDesignatedMaterialAsDynamic->DoubleVectorParameterValues) {
+        pMaterialForGltfPrimitive->SetVectorParameterValueByInfo(
             it.ParameterInfo,
             it.ParameterValue);
       }
 
-      for (auto& it : pBaseAsMaterialInstanceDynamic->TextureParameterValues) {
-        pMaterial->SetTextureParameterValueByInfo(
+      for (auto& it :
+           pUserDesignatedMaterialAsDynamic->TextureParameterValues) {
+        pMaterialForGltfPrimitive->SetTextureParameterValueByInfo(
             it.ParameterInfo,
             it.ParameterValue);
       }
 
-      for (auto& it : pBaseAsMaterialInstanceDynamic->FontParameterValues) {
-        pMaterial->SetFontParameterValue(
+      for (auto& it : pUserDesignatedMaterialAsDynamic->FontParameterValues) {
+        pMaterialForGltfPrimitive->SetFontParameterValue(
             it.ParameterInfo,
             it.FontValue,
             it.FontPage);
@@ -3361,9 +3369,9 @@ static void loadPrimitiveGameThreadPart(
 
   PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
-  pMaterial->TwoSided = true;
+  pMaterialForGltfPrimitive->TwoSided = true;
 
-  pStaticMesh->AddMaterial(pMaterial);
+  pStaticMesh->AddMaterial(pMaterialForGltfPrimitive);
 
   pStaticMesh->SetLightingGuid();