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/LiveSendExecutionState.cs

@@ -4,6 +4,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+using PlateauResoniteLink.Domain.Importing;
+
 namespace PlateauResoniteLink.Targets.Resonite;
 
 internal sealed class LiveSendProgressSink
@@ -51,9 +53,13 @@ internal sealed class CommonMaterialAssetCache
 
 internal sealed class TerrainTextureAssetCache
 {
-    public AsyncInFlightResultCache<string, SharedTerrainTextureAsset> AssetsByMeshCode { get; } = new();
+    public AsyncInFlightResultCache<TerrainTextureAssetKey, SharedTerrainTextureAsset> AssetsByOverlay { get; } = new();
 }
 
+internal sealed record TerrainTextureAssetKey(
+    ThirdRegionalMeshCode MeshCode,
+    TerrainTextureOverlay Overlay);
+
 internal sealed record SharedTerrainTextureAsset(
     Uri TextureUri,
     CreatedComponent TextureComponent,

src/PlateauResoniteLink/Targets/Resonite/ResonitePreparedCityObjectImporter.cs

@@ -85,7 +85,7 @@ public async Task ImportAsync(
                 cityObject,
                 uploadedTextureAssets.TextureUrisByPayload,
                 uploadedTextureAssets.TerrainTextureUrisByOverlay,
-                uploadedTextureAssets.TerrainTexturePropertyBlockComponentsByMeshCode,
+                uploadedTextureAssets.TerrainTexturePropertyBlockComponentsByKey,
                 message => ReportImportStep(progressReporter, cityObject, message),
                 importStepCancellation.Token);
             plannedMaterials = await materialPlanningTask;

src/PlateauResoniteLink/Targets/Resonite/ResonitePreparedTextureUploader.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -16,7 +18,7 @@ namespace PlateauResoniteLink.Targets.Resonite;
 internal sealed record ResoniteUploadedTextureAssetSet(
     Dictionary<ResoniteTexturePayload, Uri> TextureUrisByPayload,
     Dictionary<TerrainTextureOverlay, Uri> TerrainTextureUrisByOverlay,
-    Dictionary<ThirdRegionalMeshCode, ResoniteComponentLocator> TerrainTexturePropertyBlockComponentsByMeshCode);
+    Dictionary<TerrainTextureAssetKey, ResoniteComponentLocator> TerrainTexturePropertyBlockComponentsByKey);
 
 internal static class ResonitePreparedTextureUploader
 {
@@ -28,7 +30,7 @@ public static async Task<ResoniteUploadedTextureAssetSet> UploadAsync(
     {
         Dictionary<ResoniteTexturePayload, Uri> textureUrisByPayload = new(ResoniteTexturePayloadReferenceComparer.Instance);
         Dictionary<TerrainTextureOverlay, Uri> terrainTextureUrisByOverlay = [];
-        Dictionary<ThirdRegionalMeshCode, ResoniteComponentLocator> terrainTexturePropertyBlockComponentsByMeshCode = [];
+        Dictionary<TerrainTextureAssetKey, ResoniteComponentLocator> terrainTexturePropertyBlockComponentsByKey = [];
         HashSet<ResoniteTexturePayload> queuedPayloads = new(ResoniteTexturePayloadReferenceComparer.Instance);
         List<(PreparedMaterialTextureReference Texture, Task<Uri> ImportTask)> textureImportTasks = [];
         List<(PreparedTerrainOverlayTextureReference Texture, Task<SharedTerrainTextureAsset> ImportTask)> terrainTextureImportTasks = [];
@@ -56,6 +58,7 @@ public static async Task<ResoniteUploadedTextureAssetSet> UploadAsync(
                         state,
                         importClient,
                         terrainTexture.MeshCode,
+                        terrainTexture.Overlay,
                         terrainTexture.TextureSource,
                         cancellationToken)));
                 continue;
@@ -80,33 +83,36 @@ public static async Task<ResoniteUploadedTextureAssetSet> UploadAsync(
         foreach ((PreparedTerrainOverlayTextureReference texture, Task<SharedTerrainTextureAsset> importTask) in terrainTextureImportTasks)
         {
             SharedTerrainTextureAsset sharedTexture = await importTask;
-            terrainTextureUrisByOverlay.Add(texture.Overlay, sharedTexture.TextureUri);
-            terrainTexturePropertyBlockComponentsByMeshCode.TryAdd(texture.MeshCode, sharedTexture.MainTexturePropertyBlockComponent.Locator);
+            TerrainTextureAssetKey key = new(texture.MeshCode, texture.Overlay);
+            terrainTextureUrisByOverlay.TryAdd(texture.Overlay, sharedTexture.TextureUri);
+            terrainTexturePropertyBlockComponentsByKey.TryAdd(key, sharedTexture.MainTexturePropertyBlockComponent.Locator);
         }
 
         return new ResoniteUploadedTextureAssetSet(
             textureUrisByPayload,
             terrainTextureUrisByOverlay,
-            terrainTexturePropertyBlockComponentsByMeshCode);
+            terrainTexturePropertyBlockComponentsByKey);
     }
 
     private static Task<SharedTerrainTextureAsset> EnsureSharedTerrainTextureAssetAsync(
         LiveSendRunState state,
         IResoniteLinkClient importClient,
         ThirdRegionalMeshCode meshCode,
+        TerrainTextureOverlay overlay,
         ITextureImportSource textureSource,
         CancellationToken cancellationToken)
     {
-        return state.TerrainTextures.AssetsByMeshCode.GetOrCreateAsync(
-            meshCode.Value,
-            () => EnsureSharedTerrainTextureAssetCoreAsync(state, importClient, meshCode, textureSource, cancellationToken),
+        TerrainTextureAssetKey key = new(meshCode, overlay);
+        return state.TerrainTextures.AssetsByOverlay.GetOrCreateAsync(
+            key,
+            () => EnsureSharedTerrainTextureAssetCoreAsync(state, importClient, key, textureSource, cancellationToken),
             cancellationToken);
     }
 
     private static async Task<SharedTerrainTextureAsset> EnsureSharedTerrainTextureAssetCoreAsync(
         LiveSendRunState state,
         IResoniteLinkClient importClient,
-        ThirdRegionalMeshCode meshCode,
+        TerrainTextureAssetKey key,
         ITextureImportSource textureSource,
         CancellationToken cancellationToken)
     {
@@ -118,11 +124,16 @@ private static async Task<SharedTerrainTextureAsset> EnsureSharedTerrainTextureA
         CreatedSlot meshSlot = await state.Placement.GetOrCreateSharedChildSlotAsync(
             importClient,
             terrainTexturesRoot.Locator,
-            meshCode.Value,
+            key.MeshCode.Value,
+            cancellationToken);
+        CreatedSlot overlaySlot = await state.Placement.GetOrCreateSharedChildSlotAsync(
+            importClient,
+            meshSlot.Locator,
+            CreateOverlaySlotName(key),
             cancellationToken);
         SharedTerrainTextureAsset? existingTexture = await TryFindSharedTerrainTextureAssetAsync(
             importClient,
-            meshSlot,
+            overlaySlot,
             cancellationToken);
         if (existingTexture is not null)
         {
@@ -145,15 +156,15 @@ await importClient.UpdateComponentAsync(
         Uri importedTextureUri = await importClient.ImportTextureAsync(textureSource, cancellationToken);
         CreatedComponent textureComponent = await ResoniteMaterialPlanning.CreateComponentAsync(
             importClient,
-            meshSlot.Locator,
+            overlaySlot.Locator,
             "[FrooxEngine]FrooxEngine.StaticTexture2D",
             ResoniteSceneMaterialConventions.CreateTextureMembers(
                 importedTextureUri,
                 ResoniteSceneMaterialConventions.TextureMemberRole.TerrainMainTextureOverride),
             cancellationToken);
         CreatedComponent propertyBlockComponent = await CreateTerrainMainTexturePropertyBlockAsync(
             importClient,
-            meshSlot.Locator,
+            overlaySlot.Locator,
             textureComponent.Locator,
             cancellationToken);
         return new SharedTerrainTextureAsset(
@@ -162,13 +173,26 @@ await importClient.UpdateComponentAsync(
             propertyBlockComponent);
     }
 
+    private static string CreateOverlaySlotName(TerrainTextureAssetKey key)
+    {
+        string identity = string.Join(
+            "|",
+            key.MeshCode.Value,
+            key.Overlay.PackageName,
+            TerrainTextureDescriptorFormatting.FormatBounds(key.Overlay.GeographicBounds),
+            key.Overlay.MaxTextureSize.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            key.Overlay.SourceDescriptorKey);
+        string digest = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(identity))).ToLowerInvariant()[..16];
+        return $"overlay-{digest}";
+    }
+
     private static async Task<SharedTerrainTextureAsset?> TryFindSharedTerrainTextureAssetAsync(
         IResoniteLinkClient importClient,
-        CreatedSlot meshSlot,
+        CreatedSlot overlaySlot,
         CancellationToken cancellationToken)
     {
         Slot? slot = await importClient.GetSlotAsync(
-            new ResoniteTransportSlotLocator(meshSlot.Locator.Value),
+            new ResoniteTransportSlotLocator(overlaySlot.Locator.Value),
             depth: 0,
             cancellationToken);
         Component? textureComponent = slot?.Components?
@@ -186,13 +210,14 @@ await importClient.UpdateComponentAsync(
 
         CreatedComponent createdTextureComponent = new(new ResoniteComponentLocator(textureComponent.ID), textureComponent.ComponentType);
         Component? propertyBlockComponent = slot?.Components?
-            .Where(component => IsSharedTerrainMainTexturePropertyBlockComponent(component, textureComponent.ID))
-            .OrderBy(static component => component.ID, StringComparer.Ordinal)
+            .Where(IsSharedTerrainMainTexturePropertyBlockComponent)
+            .OrderByDescending(component => ReferencesComponent(component, textureComponent.ID))
+            .ThenBy(static component => component.ID, StringComparer.Ordinal)
             .FirstOrDefault();
         CreatedComponent createdPropertyBlockComponent = propertyBlockComponent?.ID is null
             ? await CreateTerrainMainTexturePropertyBlockAsync(
                 importClient,
-                meshSlot.Locator,
+                overlaySlot.Locator,
                 createdTextureComponent.Locator,
                 cancellationToken)
             : new CreatedComponent(new ResoniteComponentLocator(propertyBlockComponent.ID), propertyBlockComponent.ComponentType);
@@ -223,15 +248,21 @@ private static Task<CreatedComponent> CreateTerrainMainTexturePropertyBlockAsync
             cancellationToken);
     }
 
-    private static bool IsSharedTerrainMainTexturePropertyBlockComponent(Component component, string textureComponentId)
+    private static bool IsSharedTerrainMainTexturePropertyBlockComponent(Component component)
     {
         return string.Equals(
                 component.ComponentType,
                 "[FrooxEngine]FrooxEngine.MainTexturePropertyBlock",
                 StringComparison.Ordinal)
             && component.Members.TryGetValue("Texture", out Member? textureMember)
+            && textureMember is Reference;
+    }
+
+    private static bool ReferencesComponent(Component component, string componentId)
+    {
+        return component.Members.TryGetValue("Texture", out Member? textureMember)
             && textureMember is Reference { TargetID: string targetId }
-            && string.Equals(targetId, textureComponentId, StringComparison.Ordinal);
+            && string.Equals(targetId, componentId, StringComparison.Ordinal);
     }
 
     private static bool IsSharedTerrainTextureComponent(Component component)

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(