Merge remote-tracking branch 'cesium/main' into enh-1658_mesh-build-callbacks

Author: GhisBntly

CHANGES.md

@@ -1,6 +1,6 @@
 # Change Log {#changes}
 
-### ? - ?
+### v2.16.1 - 2025-06-02
 
 ##### Additions :tada:
 
@@ -9,12 +9,14 @@
 ##### Fixes :wrench:
 
 - Worked around an Unreal Engine limitation that prevented collisions and line traces from working correctly for tilesets with a very small scale factor.
-- Add a missing include for `GEngine` when packaging from source, introduced in *v2.16.0*.
+- Add a missing include for `GEngine` when packaging from source, introduced in `v2.16.0`.
 - Fixed a bug in `UCesiumFeaturesMetadataComponent` where multiple references to same feature ID set would cause improper encoding of its feature IDs.
 - Fixed a crash that would occur when duplicating an `ACesiumGeoreference`.
 - Fixed a bug that caused tilesets to render incorrectly when Dynamic Material Instances were used for their material settings.
 - Removed an unnecessary copy operation that happened while constructing tile meshes.
 
+In addition to the above, this release updates [cesium-native](https://github.com/CesiumGS/cesium-native) from v0.47.0 to v0.48.0. See the [changelog](https://github.com/CesiumGS/cesium-native/blob/main/CHANGES.md) for a complete list of changes in cesium-native.
+
 ### v2.16.0 - 2025-05-01
 
 ##### Additions :tada:

CesiumForUnreal.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
-	"Version": 75,
-	"VersionName": "2.16.0",
+	"Version": 76,
+	"VersionName": "2.16.1",
 	"FriendlyName": "Cesium for Unreal",
 	"Description": "Unlock the 3D geospatial ecosystem in Unreal Engine with real-world 3D content and a high accuracy full-scale WGS84 globe.",
 	"Category": "Geospatial",

Source/CesiumRuntime/Private/CesiumGltfComponent.cpp

@@ -645,6 +645,7 @@ static void mikkSetTSpaceBasic(
 
   TangentX.Y = -TangentX.Y;
   TangentY.Y = -TangentY.Y;
+  TangentZ.Y = -TangentZ.Y;
 
   vertexBuffer.SetVertexTangents(vertexIndex, TangentX, TangentY, TangentZ);
 }
@@ -3149,17 +3150,17 @@ 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
 
@@ -3170,88 +3171,91 @@ static void loadPrimitiveGameThreadPart(
   primData.Features = std::move(loadResult.Features);
   primData.Metadata = std::move(loadResult.Metadata);
 
-  UMaterialInstanceDynamic* pMaterial = nullptr;
+  UMaterialInstanceDynamic* pMaterialForGltfPrimitive = nullptr;
   ICesium3DTilesetLifecycleEventReceiver* pLifecycleEventReceiver =
       pTilesetActor->GetLifecycleEventReceiver();
   {
     TRACE_CPUPROFILER_EVENT_SCOPE(Cesium::SetupMaterial)
-    ensure(pBaseMaterial);
-
-    UMaterialInstanceDynamic* pBaseAsMaterialInstanceDynamic =
-        Cast<UMaterialInstanceDynamic>(pBaseMaterial);
-    UMaterialInstance* pParentMaterialInstance =
-        Cast<UMaterialInstance>(pBaseMaterial);
-    // 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());
-    }
+    ensure(pUserDesignatedMaterial);
+
+    UMaterialInstanceDynamic* pUserDesignatedMaterialAsDynamic =
+        Cast<UMaterialInstanceDynamic>(pUserDesignatedMaterial);
+    // 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;
 
     if (pLifecycleEventReceiver) {
       // Possibility to override the material for this primitive
-      pMaterial = pLifecycleEventReceiver->CreateMaterial(
+      pMaterialForGltfPrimitive = pLifecycleEventReceiver->CreateMaterial(
           *pCesiumPrimitive,
-          pParentMaterialInstance,
+          pBaseMaterial,
           ImportedSlotName);
-      if (pMaterial) {
-        // pMaterial created above may not have used the suggested pBaseMaterial
-        // passed as input
-        pBaseMaterial = pMaterial->Parent.Get();
-        pBaseAsMaterialInstanceDynamic =
-            Cast<UMaterialInstanceDynamic>(pBaseMaterial);
-        pParentMaterialInstance = Cast<UMaterialInstance>(pBaseMaterial);
+      if (pMaterialForGltfPrimitive) {
+        // pMaterialForGltfPrimitive created above may not have used the suggested
+        // pBaseMaterial passed as input
+        pBaseMaterial = pMaterialForGltfPrimitive->Parent.Get();
+        // may have changed but we don't need it from now on:
+        pUserDesignatedMaterialAsDynamic = nullptr;
       }
     }
-    if (!pMaterial) {
-      pMaterial = UMaterialInstanceDynamic::Create(
-          pParentMaterialInstance,
+    if (!pMaterialForGltfPrimitive) {
+      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();
       }
     }
@@ -3260,11 +3264,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) {
@@ -3273,21 +3279,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,
@@ -3301,7 +3307,7 @@ static void loadPrimitiveGameThreadPart(
         SetWaterParameterValues(
             model,
             loadResult,
-            pMaterial,
+            pMaterialForGltfPrimitive,
             EMaterialParameterAssociation::LayerParameter,
             waterIndex);
       }
@@ -3314,7 +3320,7 @@ static void loadPrimitiveGameThreadPart(
             model,
             *pGltf,
             loadResult,
-            pMaterial,
+            pMaterialForGltfPrimitive,
             EMaterialParameterAssociation::LayerParameter,
             featuresMetadataIndex);
       } else if (metadataIndex >= 0) {
@@ -3323,42 +3329,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);
@@ -3369,7 +3376,7 @@ static void loadPrimitiveGameThreadPart(
     if (pLifecycleEventReceiver) {
       pLifecycleEventReceiver->CustomizeMaterial(
           *pCesiumPrimitive,
-          *pMaterial,
+          *pMaterialForGltfPrimitive,
           pCesiumData,
           material,
           pbr);
@@ -3396,9 +3403,9 @@ static void loadPrimitiveGameThreadPart(
 
   PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
-  pMaterial->TwoSided = true;
+  pMaterialForGltfPrimitive->TwoSided = true;
 
-  pStaticMesh->AddMaterial(pMaterial);
+  pStaticMesh->AddMaterial(pMaterialForGltfPrimitive);
 
   pStaticMesh->SetLightingGuid();
 

extern/cesium-native

@@ -1,6 +1,6 @@
 {
   "name": "cesium-unreal",
-  "version": "2.16.0",
+  "version": "2.16.1",
   "description": "Cesium for Unreal",
   "main": "index.js",
   "directories": {