Add support for measure function on nodes with ILayoutElement components

gilzoide · gilzoide · commit e11eff67bb0a · 2024-12-12T21:38:03.000-03:00
diff --git a/Plugins/src~/flex-ui.cpp b/Plugins/src~/flex-ui.cpp
@@ -95,6 +95,10 @@ EXPORT void FlexUi_NodeRemoveAllChildren(YGNodeRef node) {
 	YGNodeRemoveAllChildren(node);
 }
 
+EXPORT int FlexUi_NodeGetChildCount(YGNodeConstRef node) {
+	return YGNodeGetChildCount(node);
+}
+
 EXPORT const char *FlexUi_NodeSetConfig(YGNodeRef node, YGConfigRef config) {
 	try {
 		YGNodeSetConfig(node, config);
@@ -105,6 +109,26 @@ EXPORT const char *FlexUi_NodeSetConfig(YGNodeRef node, YGConfigRef config) {
 	}
 }
 
+EXPORT void FlexUi_NodeSetContext(YGNodeRef node, void* context) {
+	YGNodeSetContext(node, context);
+}
+
+EXPORT void *FlexUi_NodeGetContext(YGNodeRef node) {
+	return YGNodeGetContext(node);
+}
+
+EXPORT void FlexUi_NodeSetMeasureFunc(YGNodeRef node, YGMeasureFunc measureFunc) {
+	YGNodeSetMeasureFunc(node, measureFunc);
+}
+
+EXPORT bool FlexUi_NodeHasMeasureFunc(YGNodeRef node) {
+	return YGNodeHasMeasureFunc(node);
+}
+
+EXPORT void FlexUi_NodeSetDirty(YGNodeRef node) {
+	YGNodeMarkDirty(node);
+}
+
 EXPORT float FlexUi_NodeLayoutGetLeft(YGNodeConstRef node) {
 	return YGNodeLayoutGetLeft(node);
 }
diff --git a/Runtime/FlexLayout.cs b/Runtime/FlexLayout.cs
@@ -1,8 +1,12 @@
+using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
+using AOT;
 using Gilzoide.FlexUi.Yoga;
 using UnityEngine;
 using UnityEngine.EventSystems;
+using UnityEngine.UI;
 
 namespace Gilzoide.FlexUi
 {
@@ -442,6 +446,7 @@ protected YGNode LayoutNode
                 if (_layoutNode.IsNull)
                 {
                     _layoutNode.Instantiate();
+                    UpdateNodeMeasure();
                     UpdateNodeStyle();
                     RefreshRootLayout();
                 }
@@ -490,7 +495,17 @@ protected virtual void OnTransformChildrenChanged()
         protected override void OnRectTransformDimensionsChange()
         {
             base.OnRectTransformDimensionsChange();
-            if (IsActive() && IsRootLayoutNode)
+            if (!IsActive())
+            {
+                return;
+            }
+
+            if (LayoutNode.HasMeasureFunc())
+            {
+                LayoutNode.SetDirty();
+                RefreshRootLayout();
+            }
+            else if (IsRootLayoutNode && !_isRefreshScheduled)
             {
                 RefreshLayout();
             }
@@ -603,6 +618,20 @@ protected void UpdateNodeStyle()
             layoutNode.StyleSetGap(Gutter.Row, _gapRow);
         }
 
+        protected void UpdateNodeMeasure()
+        {
+            if (_layoutNode.GetChildCount() == 0 && TryGetComponent(out ILayoutElement _))
+            {
+                _layoutNode.SetContext(RectTransform);
+                _layoutNode.SetMeasureFunc(RectTransformMeasureFuncPtr);
+            }
+            else
+            {
+                _layoutNode.SetContext(default);
+                _layoutNode.SetMeasureFunc(IntPtr.Zero);
+            }
+        }
+
         protected void RefreshParent()
         {
             Transform parent = RectTransform.parent;
@@ -725,5 +754,40 @@ protected override void Reset()
             }
         }
 #endif
+
+        [MonoPInvokeCallback(typeof(Yoga.Yoga.YGMeasureFunc))]
+        private static Vector2 RectTransformMeasureFunc(IntPtr nodePtr, float width, MeasureMode widthMode, float height, MeasureMode heightMode)
+        {
+            var node = new YGNode(nodePtr);
+            RectTransform rectTransform = node.GetContext<RectTransform>();
+            switch (widthMode)
+            {
+                case MeasureMode.Undefined:
+                    width = LayoutUtility.GetPreferredWidth(rectTransform);
+                    break;
+
+                case MeasureMode.AtMost:
+                    width = Mathf.Min(width, LayoutUtility.GetPreferredWidth(rectTransform));
+                    break;
+
+                default:
+                    break;
+            }
+            switch (heightMode)
+            {
+                case MeasureMode.Undefined:
+                    height = LayoutUtility.GetPreferredHeight(rectTransform);
+                    break;
+
+                case MeasureMode.AtMost:
+                    height = Mathf.Min(height, LayoutUtility.GetPreferredHeight(rectTransform));
+                    break;
+
+                default:
+                    break;
+            }
+            return new Vector2(width, height);
+        }
+        private static readonly IntPtr RectTransformMeasureFuncPtr = Marshal.GetFunctionPointerForDelegate<Yoga.Yoga.YGMeasureFunc>(RectTransformMeasureFunc);
     }
 }
diff --git a/Runtime/Yoga/Enums.cs b/Runtime/Yoga/Enums.cs
@@ -133,4 +133,11 @@ public enum Wrap
         Wrap,
         WrapReverse,
     }
+
+    public enum MeasureMode
+    {
+        Undefined,
+        Exactly,
+        AtMost,
+    }
 }
diff --git a/Runtime/Yoga/YGNode.cs b/Runtime/Yoga/YGNode.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.InteropServices;
 using UnityEngine;
 
 namespace Gilzoide.FlexUi.Yoga
@@ -9,6 +10,11 @@ public struct YGNode : IDisposable, IEquatable<YGNode>
 
         public bool IsNull => _nodePtr == IntPtr.Zero;
 
+        internal YGNode(IntPtr nodePtr)
+        {
+            _nodePtr = nodePtr;
+        }
+
         public void Instantiate()
         {
             _nodePtr = Yoga.YGNodeNew();
@@ -253,6 +259,11 @@ public void StyleSetPadding(Edge edge, YGValue value)
 
         public void Free()
         {
+            GCHandle ctx = GetContext();
+            if (ctx.IsAllocated)
+            {
+                ctx.Free();
+            }
             Yoga.YGNodeFree(_nodePtr);
         }
 
@@ -263,6 +274,10 @@ public void CalculateLayout(float availableWidth, float availableHeight, Directi
 
         public bool InsertChild(YGNode child, int index)
         {
+            // Nodes with children cannot have measure functions
+            SetContext(default);
+            SetMeasureFunc(IntPtr.Zero);
+
             string error = Yoga.YGNodeInsertChild(_nodePtr, child._nodePtr, index);
             if (error != null)
             {
@@ -283,6 +298,11 @@ public void RemoveAllChildren()
             Yoga.YGNodeRemoveAllChildren(_nodePtr);
         }
 
+        public int GetChildCount()
+        {
+            return Yoga.YGNodeGetChildCount(_nodePtr);
+        }
+
         public void SetConfig(YGConfig config)
         {
             string error = Yoga.YGNodeSetConfig(_nodePtr, config._configPtr);
@@ -292,6 +312,56 @@ public void SetConfig(YGConfig config)
             }
         }
 
+        public void SetContext<T>(T value)
+        {
+            SetContext(GCHandle.Alloc(value));
+        }
+
+        public void SetContext(GCHandle value)
+        {
+            GCHandle ctx = GetContext();
+            if (ctx.IsAllocated)
+            {
+                ctx.Free();
+            }
+            Yoga.YGNodeSetContext(_nodePtr, GCHandle.ToIntPtr(value));
+        }
+
+        public T GetContext<T>()
+        {
+            GCHandle handle = GetContext();
+            return handle.IsAllocated ? (T) handle.Target : default;
+        }
+
+        public GCHandle GetContext()
+        {
+            IntPtr ptr = Yoga.YGNodeGetContext(_nodePtr);
+            return ptr != IntPtr.Zero ? GCHandle.FromIntPtr(ptr) : default;
+        }
+
+        public void SetMeasureFunc(Yoga.YGMeasureFunc measureFunc)
+        {
+            Yoga.YGNodeSetMeasureFunc(_nodePtr, measureFunc);
+        }
+
+        public void SetMeasureFunc(IntPtr measureFunc)
+        {
+            Yoga.YGNodeSetMeasureFunc(_nodePtr, measureFunc);
+        }
+
+        public bool HasMeasureFunc()
+        {
+            return Yoga.YGNodeHasMeasureFunc(_nodePtr);
+        }
+
+        public void SetDirty()
+        {
+            if (HasMeasureFunc())
+            {
+                Yoga.YGNodeSetDirty(_nodePtr);
+            }
+        }
+
         #endregion
 
         #region Layout
diff --git a/Runtime/Yoga/Yoga.cs b/Runtime/Yoga/Yoga.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using UnityEngine;
 
 namespace Gilzoide.FlexUi.Yoga
 {
@@ -33,9 +34,22 @@ public class Yoga
         [DllImport(YogaDll, EntryPoint = "FlexUi_NodeInsertChild")] public static extern string YGNodeInsertChild(IntPtr node, IntPtr child, int index);
         [DllImport(YogaDll, EntryPoint = "FlexUi_NodeRemoveChild")] public static extern void YGNodeRemoveChild(IntPtr node, IntPtr child);
         [DllImport(YogaDll, EntryPoint = "FlexUi_NodeRemoveAllChildren")] public static extern void YGNodeRemoveAllChildren(IntPtr node);
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeGetChildCount")] public static extern int YGNodeGetChildCount(IntPtr node);
 
         [DllImport(YogaDll, EntryPoint = "FlexUi_NodeSetConfig")] public static extern string YGNodeSetConfig(IntPtr node, IntPtr config);
 
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeSetContext")] public static extern void YGNodeSetContext(IntPtr node, IntPtr context);
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeGetContext")] public static extern IntPtr YGNodeGetContext(IntPtr node);
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeSetMeasureFunc")] public static extern void YGNodeSetMeasureFunc(IntPtr node, IntPtr measureFunc);
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeHasMeasureFunc")] public static extern bool YGNodeHasMeasureFunc(IntPtr node);
+        [DllImport(YogaDll, EntryPoint = "FlexUi_NodeSetDirty")] public static extern void YGNodeSetDirty(IntPtr node);
+
+        public delegate Vector2 YGMeasureFunc(IntPtr nodePtr, float width, MeasureMode widthMode, float height, MeasureMode heightMode);
+        public static void YGNodeSetMeasureFunc(IntPtr node, YGMeasureFunc measureFunc)
+        {
+            YGNodeSetMeasureFunc(node, Marshal.GetFunctionPointerForDelegate(measureFunc));
+        }
+
         #endregion
 
         #region YGNodeLayout

Original file line number	Diff line number	Diff line change
`@@ -133,4 +133,11 @@ public enum Wrap`
`133`	`133`	`Wrap,`
`134`	`134`	`WrapReverse,`
`135`	`135`	`}`
	`136`	`+`
	`137`	`+ public enum MeasureMode`
	`138`	`+ {`
	`139`	`+ Undefined,`
	`140`	`+ Exactly,`
	`141`	`+ AtMost,`
	`142`	`+ }`
`136`	`143`	`}`