rewrite it again

...to a "push" architecture

Author: al2me6

Source/DynamicProperties/CompiledProps.cs

@@ -11,7 +11,7 @@ public sealed class MaterialPropertyManager : MonoBehaviour
 
 	public static MaterialPropertyManager Instance { get; private set; }
 
-	private readonly Dictionary<Renderer, CompiledProps> compiledProperties = [];
+	private readonly Dictionary<Renderer, PropsCascade> rendererCascades = [];
 
 	#endregion
 
@@ -32,56 +32,55 @@ private void Awake()
 		Instance = this;
 	}
 
-	private void LateUpdate() => Refresh();
-
 	private void OnDestroy()
 	{
 		if (Instance != this) return;
 
 		Instance = null;
-		CompiledProps.ClearCache();
+		PropsCascade.ClearCache();
+
+		// Poor man's GC :'(
+		MaterialColorUpdaterPatch.temperatureColorProps.Clear();
+		ModuleColorChangerPatch.mccProps.Clear();
+
 		this.LogDebug("destroyed");
 	}
 
 	#endregion
 
 	public bool Set(Renderer renderer, Props props)
 	{
-		if (!compiledProperties.TryGetValue(renderer, out var compiledProps)) {
-			compiledProperties[renderer] = compiledProps = new CompiledProps();
+		if (renderer == null) {
+			Log.LogError(this, $"cannot set property on null renderer {renderer.GetHashCode()}");
+			return false;
+		}
+
+		if (!rendererCascades.TryGetValue(renderer, out var cascade)) {
+			rendererCascades[renderer] = cascade = new PropsCascade(renderer);
 		}
 
-		return compiledProps.Add(props);
+		return cascade.Add(props);
 	}
 
 	public bool Remove(Renderer renderer, Props props)
 	{
-		if (!compiledProperties.TryGetValue(renderer, out var compiledProps)) return false;
-		return compiledProps.Remove(props);
+		if (!rendererCascades.TryGetValue(renderer, out var cascade)) return false;
+		return cascade.Remove(props);
 	}
 
-	private static readonly List<Renderer> _deadRenderers = [];
-
-	private void Refresh()
+	public bool Remove(Renderer renderer)
 	{
-		CompiledProps.RefreshChangedProps();
+		return rendererCascades.Remove(renderer);
+	}
 
-		foreach (var (renderer, compiledProps) in compiledProperties) {
-			if (renderer == null) {
-				this.LogDebug($"dead renderer {renderer.GetHashCode()}");
-				_deadRenderers.Add(renderer);
-				continue;
-			}
+	public bool Remove(Props props)
+	{
+		var removed = false;
 
-			if (!renderer.gameObject.activeInHierarchy) continue;
+		foreach (var cascade in rendererCascades.Values) removed |= cascade.Remove(props);
 
-			if (compiledProps.GetIfChanged(out var mpb)) {
-				this.LogDebug($"set mpb on renderer {renderer.name} {renderer.GetHashCode()}\n");
-				renderer.SetPropertyBlock(mpb);
-			}
-		}
+		PropsCascade.RemoveCacheEntriesWith(props);
 
-		foreach (var dead in _deadRenderers) compiledProperties.Remove(dead);
-		_deadRenderers.Clear();
+		return removed;
 	}
 }

Source/DynamicProperties/MaterialPropertyManager.cs

@@ -0,0 +1,143 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using KSPBuildTools;
+using UnityEngine;
+
+namespace Shabby.DynamicProperties;
+
+internal class MpbCompiler : IDisposable
+{
+	/// Immutable.
+	internal readonly SortedSet<Props> Cascade;
+
+	private readonly HashSet<Renderer> linkedRenderers = [];
+	private readonly MaterialPropertyBlock mpb = new();
+	private readonly Dictionary<Props, List<int>> idManagerMap = [];
+
+	private static readonly MaterialPropertyBlock EmptyMpb = new();
+
+	internal MpbCompiler(SortedSet<Props> cascades)
+	{
+		Cascade = cascades;
+		RebuildManagerMap();
+		RewriteMpb();
+		foreach (var props in Cascade) {
+			props.OnValueChanged += OnPropsValueChanged;
+			props.OnEntriesChanged += OnPropsEntriesChanged;
+		}
+	}
+
+	internal void Register(Renderer renderer)
+	{
+		linkedRenderers.Add(renderer);
+		Apply(renderer);
+	}
+
+	internal void Unregister(Renderer renderer)
+	{
+		linkedRenderers.Remove(renderer);
+		renderer.SetPropertyBlock(EmptyMpb);
+	}
+
+	private void RebuildManagerMap()
+	{
+		idManagerMap.Clear();
+
+		Dictionary<int, Props> idManagers = [];
+		foreach (var props in Cascade) {
+			foreach (var id in props.ManagedIds) {
+				idManagers[id] = props;
+			}
+		}
+
+		foreach (var (id, props) in idManagers) {
+			if (!idManagerMap.TryGetValue(props, out var ids)) {
+				idManagerMap[props] = ids = [];
+			}
+
+			ids.Add(id);
+		}
+	}
+
+	private void OnPropsValueChanged(Props props)
+	{
+		WriteMpb(props);
+		Apply();
+	}
+
+	private void OnPropsEntriesChanged(Props props)
+	{
+		RebuildManagerMap();
+		RewriteMpb();
+		Apply();
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private void WriteMpb(Props props)
+	{
+		foreach (var id in idManagerMap[props]) props.Write(id, mpb);
+	}
+
+	private void RewriteMpb()
+	{
+		mpb.Clear();
+		foreach (var props in idManagerMap.Keys) WriteMpb(props);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private void Apply(Renderer renderer) => renderer.SetPropertyBlock(mpb);
+
+	private readonly List<Renderer> _deadRenderers = [];
+
+	internal void Apply()
+	{
+		foreach (var renderer in linkedRenderers) {
+			if (renderer == null) {
+				_deadRenderers.Add(renderer!);
+				continue;
+			}
+
+			Apply(renderer);
+		}
+
+		foreach (var dead in _deadRenderers) {
+			MaterialPropertyManager.Instance.LogDebug($"dead renderer {dead.GetHashCode()}");
+			MaterialPropertyManager.Instance.Remove(dead);
+		}
+
+		if (linkedRenderers.Count == 0) {
+			MaterialPropertyManager.Instance.LogDebug("dead cache entry");
+			PropsCascade.RemoveCacheEntry(this);
+		}
+	}
+
+	private bool _disposed = false;
+
+	private void UnlinkProps()
+	{
+		if (_disposed) return;
+
+		Debug.Log("disposing MPB cache entry");
+
+		foreach (var props in Cascade) {
+			props.OnValueChanged -= OnPropsValueChanged;
+			props.OnEntriesChanged -= OnPropsEntriesChanged;
+		}
+
+		_disposed = true;
+	}
+
+	public void Dispose()
+	{
+		UnlinkProps();
+		GC.SuppressFinalize(this);
+	}
+
+	~MpbCompiler()
+	{
+		UnlinkProps();
+	}
+}

Source/DynamicProperties/MpbCompiler.cs

@@ -122,6 +122,8 @@ private static IEnumerable<CodeInstruction> Highlight_Transpiler(
 	[HarmonyPatch("OnDestroy")]
 	private static void OnDestroy_Postfix(Part __instance)
 	{
-		rimHighlightProps.Remove(__instance);
+		if (rimHighlightProps.Remove(__instance, out var props)) {
+			props.Dispose();
+		}
 	}
 }