use approx equality for prop value updates

Author: al2me6

Source/DynamicProperties/Props.cs

@@ -57,31 +57,68 @@ internal abstract class Prop
 internal abstract class Prop<T>(T value) : Prop
 {
 	internal T Value = value;
+
+	internal abstract bool UpdateIfChanged(T value);
 	public override string ToString() => Value.ToString();
 }
 
 internal class PropColor(Color value) : Prop<Color>(value)
 {
+	internal override bool UpdateIfChanged(Color value)
+	{
+		if (Utils.ApproxEquals(value, Value)) return false;
+		Value = value;
+		return true;
+	}
+
 	internal override void Write(int id, MaterialPropertyBlock mpb) => mpb.SetColor(id, Value);
 }
 
 internal class PropFloat(float value) : Prop<float>(value)
 {
+	internal override bool UpdateIfChanged(float value)
+	{
+		if (Utils.ApproxEqualsRel(value, Value)) return false;
+		Value = value;
+		return true;
+	}
+
 	internal override void Write(int id, MaterialPropertyBlock mpb) => mpb.SetFloat(id, Value);
 }
 
 internal class PropInt(int value) : Prop<int>(value)
 {
+	internal override bool UpdateIfChanged(int value)
+	{
+		if (value == Value) return false;
+		Value = value;
+		return true;
+	}
+
 	internal override void Write(int id, MaterialPropertyBlock mpb) => mpb.SetInt(id, Value);
 }
 
 internal class PropTexture(Texture value) : Prop<Texture>(value)
 {
+	internal override bool UpdateIfChanged(Texture value)
+	{
+		if (ReferenceEquals(value, Value)) return false;
+		Value = value;
+		return true;
+	}
+
 	internal override void Write(int id, MaterialPropertyBlock mpb) => mpb.SetTexture(id, Value);
 }
 
 internal class PropVector(Vector4 value) : Prop<Vector4>(value)
 {
+	internal override bool UpdateIfChanged(Vector4 value)
+	{
+		if (Utils.ApproxEqualsRel(value, Value)) return false;
+		Value = value;
+		return true;
+	}
+
 	internal override void Write(int id, MaterialPropertyBlock mpb) => mpb.SetVector(id, Value);
 }
 
@@ -118,17 +155,15 @@ public sealed class Props(int priority) : IDisposable
 	public void SuppressEagerUpdatesThisFrame()
 	{
 		SuppressEagerUpdate = true;
-		MaterialPropertyManager.Instance.ScheduleLateUpdate(this);
+		MaterialPropertyManager.Instance?.ScheduleLateUpdate(this);
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private void _internalSet<T, TProp>(int id, T value) where TProp : Prop<T>
 	{
 		if (props.TryGetValue(id, out var prop)) {
 			if (prop is TProp typedProp) {
-				if (EqualityComparer<T>.Default.Equals(value, typedProp.Value)) return;
-
-				typedProp.Value = value;
+				if (!typedProp.UpdateIfChanged(value)) return;
 
 				if (!SuppressEagerUpdate) {
 					OnValueChanged(this);
@@ -179,7 +214,7 @@ internal void Write(int id, MaterialPropertyBlock mpb)
 			throw new KeyNotFoundException($"property {PropIdToName.Get(id)} not found");
 		}
 
-		MaterialPropertyManager.Instance.LogDebug(
+		MaterialPropertyManager.Instance?.LogDebug(
 			$"writing property {PropIdToName.Get(id)} = {prop}");
 
 		prop.Write(id, mpb);

Source/DynamicProperties/Utils.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Shabby.DynamicProperties;
+
+public static class Utils
+{
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool ApproxEqualsAbs(float a, float b, float eps) =>
+		Math.Abs(b - a) <= eps;
+
+	/// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool ApproxEqualsRel(float a, float b,
+		float absDiff = 1e-4f, float relDiff = float.Epsilon)
+	{
+		if (a == b) return true;
+
+		var diff = Math.Abs(a - b);
+		if (diff < absDiff) return true;
+
+		a = Math.Abs(a);
+		b = Math.Abs(b);
+		var largest = b > a ? b : a;
+		return diff <= largest * relDiff;
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool ApproxEqualsRel(Vector4 a, Vector4 b,
+		float absDiff = 1e-4f, float relDiff = float.Epsilon) =>
+		ApproxEqualsRel(a.x, b.x, absDiff, relDiff) &&
+		ApproxEqualsRel(a.y, b.y, absDiff, relDiff) &&
+		ApproxEqualsRel(a.z, b.z, absDiff, relDiff) &&
+		ApproxEqualsRel(a.w, b.w, absDiff, relDiff);
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static bool ApproxEquals(Color a, Color b, float eps = 1e-2f) =>
+		ApproxEqualsAbs(a.r, b.r, eps) && ApproxEqualsAbs(a.g, b.g, eps) &&
+		ApproxEqualsAbs(a.b, b.b, eps) && ApproxEqualsAbs(a.a, b.a, eps);
+}