Keep terrain overlay material mesh codes

Author: esnya

src/PlateauResoniteLink/Application/Importing/CityGmlSurfaceMaterialResolver.cs

@@ -140,7 +140,11 @@ internal static MaterialBinding CreateMaterialBinding(
     {
         TerrainOverlayMaterialBinding? terrainOverlayMaterial = representativeSurface.Material.TerrainOverlay is null
             ? null
-            : new TerrainOverlayMaterialBinding(representativeSurface.Material.TerrainOverlay);
+            : new TerrainOverlayMaterialBinding(
+                ThirdRegionalMeshCode.TryParse(actualMeshCode, out ThirdRegionalMeshCode parsedActualMeshCode)
+                    ? parsedActualMeshCode
+                    : representativeSurface.Material.TerrainOverlay.MeshCode,
+                representativeSurface.Material.TerrainOverlay);
         ColorRgba baseColor = representativeSurface.Material.TerrainOverlay is null
             ? ToContractColor(representativeSurface.Surface.BaseColor)
             : new ColorRgba(1.0, 1.0, 1.0, 1.0);

src/PlateauResoniteLink/Application/Importing/SceneImportContractTypes.cs

@@ -200,14 +200,22 @@ public enum MaterialReuseScope
 
 public sealed record TerrainOverlayMaterialBinding
 {
-    public TerrainOverlayMaterialBinding(TerrainTextureOverlay overlay)
+    public TerrainOverlayMaterialBinding(
+        ThirdRegionalMeshCode meshCode,
+        TerrainTextureOverlay overlay)
     {
+        if (!ThirdRegionalMeshCode.TryParse(meshCode.Value, out _))
+        {
+            throw new ArgumentException("Terrain overlay material mesh code must be a valid third regional mesh code.", nameof(meshCode));
+        }
+
+        MeshCode = meshCode;
         Overlay = overlay ?? throw new ArgumentNullException(nameof(overlay));
     }
 
-    public TerrainTextureOverlay Overlay { get; init; }
+    public ThirdRegionalMeshCode MeshCode { get; }
 
-    public ThirdRegionalMeshCode MeshCode => Overlay.MeshCode;
+    public TerrainTextureOverlay Overlay { get; }
 }
 
 public sealed record MaterialBinding(

src/PlateauResoniteLink/Targets/Resonite/ResonitePreparedTextureUploader.cs

@@ -80,7 +80,7 @@ public static async Task<ResoniteUploadedTextureAssetSet> UploadAsync(
         foreach ((PreparedTerrainOverlayTextureReference texture, Task<SharedTerrainTextureAsset> importTask) in terrainTextureImportTasks)
         {
             SharedTerrainTextureAsset sharedTexture = await importTask;
-            terrainTextureUrisByOverlay.Add(texture.Overlay, sharedTexture.TextureUri);
+            terrainTextureUrisByOverlay.TryAdd(texture.Overlay, sharedTexture.TextureUri);
             terrainTexturePropertyBlockComponentsByMeshCode.TryAdd(texture.MeshCode, sharedTexture.MainTexturePropertyBlockComponent.Locator);
         }
 

src/PlateauResoniteLink/Targets/Resonite/ResoniteQueuedCityObjectPreparation.cs

@@ -108,11 +108,12 @@ private async Task<PreparedCityObject> PrepareCityObjectAsync(
             progressReporter,
             cancellationToken);
         PreparedConstructionGeometry preparedGeometry = await geometryPreparationTask.WaitAsync(cancellationToken);
-        Dictionary<TerrainTextureOverlay, GeneratedTerrainTexture> preparedTerrainTextureDataByOverlay = preparedTextures
-            .OfType<PreparedTerrainOverlayTextureReference>()
-            .ToDictionary(
-                static texture => texture.Overlay,
-                static texture => texture.GeneratedTerrainTexture);
+        Dictionary<TerrainTextureOverlay, GeneratedTerrainTexture> preparedTerrainTextureDataByOverlay = [];
+        foreach (PreparedTerrainOverlayTextureReference texture in preparedTextures.OfType<PreparedTerrainOverlayTextureReference>())
+        {
+            preparedTerrainTextureDataByOverlay.TryAdd(texture.Overlay, texture.GeneratedTerrainTexture);
+        }
+
         cityObject = ResoniteCityObjectPreparation.ApplyTerrainTextureCanvasUv(
             cityObject,
             preparedTerrainTextureDataByOverlay,

src/PlateauResoniteLink/Targets/Resonite/ResoniteQueuedTexturePreparer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
@@ -40,11 +41,11 @@ public async Task<PreparedTextureReference[]> PrepareAsync(
         ArgumentNullException.ThrowIfNull(routedClient);
         ArgumentNullException.ThrowIfNull(cityObject);
 
-        (ThirdRegionalMeshCode TerrainMeshCode, TerrainTextureOverlay TerrainOverlay)[] distinctTerrainOverlays = cityObject.Materials
+        (ThirdRegionalMeshCode TerrainMeshCode, TerrainTextureOverlay TerrainOverlay)[] distinctTerrainOverlayBindings = cityObject.Materials
             .Select((material, materialIndex) => (Material: material, MaterialIndex: materialIndex))
             .Where(static entry => entry.Material.TerrainOverlayMaterial is not null)
             .Select(entry => (
-                TerrainMeshCode: entry.Material.TerrainOverlayMaterial!.Overlay.MeshCode,
+                TerrainMeshCode: entry.Material.TerrainOverlayMaterial!.MeshCode,
                 TerrainOverlay: entry.Material.TerrainOverlayMaterial!.Overlay))
             .Distinct()
             .OrderBy(static entry => entry.TerrainMeshCode.Value, StringComparer.Ordinal)
@@ -53,31 +54,51 @@ public async Task<PreparedTextureReference[]> PrepareAsync(
             .ThenBy(static entry => entry.TerrainOverlay.GeographicBounds.MinLongitude)
             .ToArray();
 
-        Task<PreparedTextureReference?>[] terrainOverlayTexturePreparationTasks = distinctTerrainOverlays
-            .Select(entry => PrepareTerrainOverlayTextureReferenceAsync(
+        TerrainTextureOverlay[] distinctTerrainOverlays = distinctTerrainOverlayBindings
+            .Select(static entry => entry.TerrainOverlay)
+            .Distinct()
+            .OrderBy(static overlay => overlay.PackageName, StringComparer.Ordinal)
+            .ThenBy(static overlay => overlay.MeshCode.Value, StringComparer.Ordinal)
+            .ThenBy(static overlay => overlay.GeographicBounds.MinLatitude)
+            .ThenBy(static overlay => overlay.GeographicBounds.MinLongitude)
+            .ToArray();
+
+        Task<(TerrainTextureOverlay Overlay, GeneratedTerrainTexture Texture)>[] terrainOverlayTexturePreparationTasks = distinctTerrainOverlays
+            .Select(async overlay => (
+                Overlay: overlay,
+                Texture: await PrepareTerrainOverlayTextureAsync(
                 state,
                 routedClient,
                 progressReporter,
+                overlay,
+                cancellationToken)))
+            .ToArray();
+        Task<PreparedTextureReference?>[] directTexturePreparationTasks = cityObject.Materials
+            .Where(static material => material.TexturePayload is not null)
+            .Select(PrepareDirectMaterialTextureReferenceAsync)
+            .ToArray();
+        await Task.WhenAll(terrainOverlayTexturePreparationTasks);
+        PreparedTextureReference?[] preparedDirectTextureResults = await Task.WhenAll(directTexturePreparationTasks);
+        Dictionary<TerrainTextureOverlay, GeneratedTerrainTexture> terrainTexturesByOverlay = terrainOverlayTexturePreparationTasks
+            .Select(static task => task.Result)
+            .ToDictionary(static result => result.Overlay, static result => result.Texture);
+        PreparedTerrainOverlayTextureReference[] preparedTerrainTextureReferences = distinctTerrainOverlayBindings
+            .Select(entry => new PreparedTerrainOverlayTextureReference(
                 entry.TerrainMeshCode,
                 entry.TerrainOverlay,
-                cancellationToken))
+                terrainTexturesByOverlay[entry.TerrainOverlay]))
             .ToArray();
-        PreparedTextureReference?[] preparedTextureResults = await Task.WhenAll(
-            terrainOverlayTexturePreparationTasks
-                .Concat(cityObject.Materials
-                    .Where(static material => material.TexturePayload is not null)
-                    .Select(PrepareDirectMaterialTextureReferenceAsync)
-                    .ToArray()));
-        return preparedTextureResults
+        return preparedTerrainTextureReferences
+            .Cast<PreparedTextureReference>()
+            .Concat(preparedDirectTextureResults.OfType<PreparedTextureReference>())
             .OfType<PreparedTextureReference>()
             .ToArray();
     }
 
-    private async Task<PreparedTextureReference?> PrepareTerrainOverlayTextureReferenceAsync(
+    private async Task<GeneratedTerrainTexture> PrepareTerrainOverlayTextureAsync(
         LiveSendRunState state,
         IResoniteLinkClient routedClient,
         Action<string>? progressReporter,
-        ThirdRegionalMeshCode terrainMeshCode,
         TerrainTextureOverlay terrainTextureOverlay,
         CancellationToken cancellationToken)
     {
@@ -107,10 +128,7 @@ public async Task<PreparedTextureReference[]> PrepareAsync(
             }
         }
 
-        return new PreparedTerrainOverlayTextureReference(
-            terrainMeshCode,
-            terrainTextureOverlay,
-            terrainTexture);
+        return terrainTexture;
     }
 
     private static TerrainTextureSource[] GetTrackedTerrainTextureSources(

tests/PlateauResoniteLink.Tests/Profiles/CityGmlSurfaceMaterialResolverTests.cs

@@ -40,7 +40,7 @@ public void EnumerateSurfacesPreservesLazyScanAfterFirstGeneratedDemSurface()
     }
 
     [Fact]
-    public void CreateMaterialBindingUsesTerrainOverlayMeshCodeWithoutMatchingActualMeshCode()
+    public void CreateMaterialBindingKeepsMaterialMeshCodeSeparateFromTerrainOverlayMeshCode()
     {
         ResolvedSurfaceMaterial representativeSurface = new(
             CreateSurface(),
@@ -60,10 +60,36 @@ public void CreateMaterialBindingUsesTerrainOverlayMeshCodeWithoutMatchingActual
             representativeSurface,
             materialIndex: 0);
 
-        Assert.Equal("53394525", binding.TerrainMeshCode);
+        Assert.Equal("53394600", binding.TerrainMeshCode);
         Assert.Same(representativeSurface.Material.TerrainOverlay, binding.TerrainOverlay);
     }
 
+    [Fact]
+    public void CreateMaterialBindingFallsBackToOverlayMeshCodeWhenMaterialMeshCodeIsNotThirdLevel()
+    {
+        TerrainTextureOverlay overlay = CreateOverlay("53394525");
+        ResolvedSurfaceMaterial representativeSurface = new(
+            CreateSurface(),
+            new ResolvedMaterial(
+                MaterialType.Standard,
+                TexturePayload: null,
+                TextureSourceKind.Bundled,
+                MaterialProjection.Uv,
+                Family: "terrain",
+                TextureScale: null,
+                MaterialReuseScope.Shared,
+                TerrainOverlay: overlay),
+            depthOffset: null);
+
+        MaterialBinding binding = CityGmlSurfaceMaterialResolver.CreateMaterialBinding(
+            "533945",
+            representativeSurface,
+            materialIndex: 0);
+
+        Assert.Equal("53394525", binding.TerrainMeshCode);
+        Assert.Same(overlay, binding.TerrainOverlay);
+    }
+
     [Fact]
     public void EnumerateSurfacesUsesConstructionRoleInsteadOfParsedSemanticForGeneratedNoWallSlabParts()
     {

tests/PlateauResoniteLink.Tests/Profiles/ImportedDynamicMaterialUvNormalizerTests.cs

@@ -279,6 +279,6 @@ private static MaterialBinding CreateDynamicUvMaterial(
             TextureOffset: textureOffset,
             TerrainOverlayMaterial: terrainOverlay is null
                 ? null
-                : new TerrainOverlayMaterialBinding(terrainOverlay));
+                : new TerrainOverlayMaterialBinding(terrainOverlay.MeshCode, terrainOverlay));
     }
 }

tests/PlateauResoniteLink.Tests/Profiles/LocalCityGmlObjectProjectionTests.cs

@@ -1501,7 +1501,7 @@ public void ProjectCityObjectUsesPerObjectAlbedoOnlyMaterialForTexturelessDemTer
     }
 
     [Fact]
-    public void ProjectCityObjectUsesProvidedTerrainOverlayMeshCodeForTexturelessRoof()
+    public void ProjectCityObjectKeepsMaterialMeshCodeForMismatchedTerrainOverlayRoof()
     {
         CoordinateReferenceSystem referenceSystem = CoordinateReferenceSystem.Parse("http://www.opengis.net/def/crs/EPSG/0/6697");
         TerrainTextureOverlay mismatchedOverlay = CreateThirdMeshOverlay("53394526");
@@ -1523,7 +1523,7 @@ public void ProjectCityObjectUsesProvidedTerrainOverlayMeshCodeForTexturelessRoo
 
         MaterialBinding material = Assert.Single(projected.Materials);
         Assert.Same(mismatchedOverlay, material.TerrainOverlay);
-        Assert.Equal("53394526", material.TerrainMeshCode);
+        Assert.Equal("53394525", material.TerrainMeshCode);
         Assert.Equal(TextureSourceKind.Dataset, material.TextureSourceKind);
     }
 

tests/PlateauResoniteLink.Tests/Targets/NonDemCityObjectBakerTests.cs

@@ -844,7 +844,7 @@ public async Task TryBufferAsyncPreservesTerrainOverlayAlbedoOnlyProviderWithGen
                     DepthOffset: null,
                     SubmeshIndices: [0],
                     AssetScope: ResoniteMaterialAssetScope.Common,
-                    TerrainOverlayMaterial: new TerrainOverlayMaterialBinding(overlay),
+                    TerrainOverlayMaterial: new TerrainOverlayMaterialBinding(overlay.MeshCode, overlay),
                     CommonMaterial: CommonMaterialCatalog.Create().Generic.Uv),
             ],
         };

tests/PlateauResoniteLink.Tests/Targets/ResoniteDynamicMaterialUvNormalizerTests.cs

@@ -298,6 +298,6 @@ private static ResoniteMaterialBinding CreateDynamicUvMaterial(
             AssetScope: ResoniteMaterialAssetScope.PresentationSlotScoped,
             TerrainOverlayMaterial: terrainOverlay is null
                 ? null
-                : new TerrainOverlayMaterialBinding(terrainOverlay));
+                : new TerrainOverlayMaterialBinding(terrainOverlay.MeshCode, terrainOverlay));
     }
 }