Readonly Property Drawer Unity

2025-07-08 09:35 UTC o4-mini-high Open in ChatGPT ↗

Here’s a drop-in “ReadOnly” attribute you can stick on any serialized field, plus a PropertyDrawer that will grey it out in the Inspector—and because it simply wraps a normal EditorGUI.PropertyField in a disabled scope, any other custom drawers (e.g. [Range], [Tooltip], nested/complex-type drawers, etc.) will still run, only non-editable.

1. Create the attribute (anywhere in your runtime or Editor folder)

using System;
using UnityEngine;

/// <summary>
/// Put this on any serialized field to make it read-only in the Inspector.
/// </summary>
[AttributeUsage(AttributeTargets.Field, Inherited = true)]
public class ReadOnlyAttribute : PropertyAttribute
{
    // no data needed
}

2. Create the PropertyDrawer
Place this script in an Editor folder (so it compiles only in the Editor):

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;

[CustomPropertyDrawer(typeof(ReadOnlyAttribute), true)]
public class ReadOnlyDrawer : PropertyDrawer
{
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        // disable GUI, draw property normally (so other drawers still apply), then re-enable
        EditorGUI.BeginDisabledGroup(true);
        EditorGUI.PropertyField(position, property, label, true);
        EditorGUI.EndDisabledGroup();
    }

    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        // make sure multi-line properties still size themselves correctly
        return EditorGUI.GetPropertyHeight(property, label, true);
    }
}
#endif

How it works and why it’s compatible

Disabling only: By calling EditorGUI.BeginDisabledGroup(true) you don’t replace or bypass any other drawer—you simply tell Unity “draw everything exactly as you normally would… but greyed‐out and non-interactive.”
GetPropertyHeight pass-through: Ensures arrays, structs, multi-line strings, nested properties, etc., all size correctly.
inherit: true on the [CustomPropertyDrawer] means if you ever subclass your own ReadOnlyAttribute, it’ll still pick this drawer.
Editor‐only: Wrapped in #if UNITY_EDITOR and placed in an Editor folder so it doesn’t bloat build size.

Just drop those two scripts into your project, mark any field with [ReadOnly], and it’ll be non-editable in the Inspector—while still playing nicely with any other Editor scripts or custom drawers you might have.

Place the following script in an Editor folder (e.g. Assets/Editor/HeaderGroupEditor.cs). It will—as a fallback—wrap Unity’s default inspector for any MonoBehaviour (only when you don’t already have a custom editor for that type), scan your serialized fields in declaration order, and:

Start a new fold-out whenever it hits [Header("…")]
Put everything under that header into the fold, until it sees two [Space] attributes in a row (on the same field), which “exits” the fold
If another [Header("…")] shows up, it closes the old fold and opens a new one
Fields outside any header (or after an exit) draw normally

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System.Reflection;
using System.Collections.Generic;

/// <summary>
/// Fallback editor that groups fields under each [Header] into a foldout,
/// exits on a double-[Space] marker, and otherwise defers to Unity’s default inspector.
/// </summary>
[CustomEditor(typeof(MonoBehaviour), true, true)]  // the third 'true' makes this a fallback editor
[CanEditMultipleObjects]
public class HeaderGroupEditor : Editor
{
    // keeps track of which headers are open
    private Dictionary<string, bool> _foldoutStates = new Dictionary<string, bool>();

    public override void OnInspectorGUI()
    {
        serializedObject.Update();

        // iterate through all visible serialized properties
        var prop = serializedObject.GetIterator();
        bool enterChildren = true;

        // draw the “Script” field first, if present
        if (prop.NextVisible(enterChildren))
        {
            EditorGUILayout.PropertyField(prop, true);
        }

        bool grouping = false;
        string currentHeader = null;

        // now handle the rest
        while (prop.NextVisible(false))
        {
            var fi = GetFieldInfo(prop);
            var headerAttr = fi?.GetCustomAttribute<HeaderAttribute>(true);
            var spaceAttrs = fi?.GetCustomAttributes(typeof(SpaceAttribute), true);

            bool isHeader = headerAttr != null;
            bool isExit   = spaceAttrs != null && spaceAttrs.Length >= 2;

            if (isHeader)
            {
                // close previous group if needed
                if (grouping)
                    EditorGUI.indentLevel--;

                grouping = true;
                currentHeader = headerAttr.header;

                // get or create foldout state
                if (!_foldoutStates.ContainsKey(currentHeader))
                    _foldoutStates[currentHeader] = true;

                // draw the foldout header
                _foldoutStates[currentHeader] = EditorGUILayout.Foldout(
                    _foldoutStates[currentHeader],
                    currentHeader,
                    true
                );

                // indent group contents
                EditorGUI.indentLevel++;
                continue;
            }

            if (isExit)
            {
                // exit current group
                if (grouping)
                {
                    EditorGUI.indentLevel--;
                    grouping = false;
                    currentHeader = null;
                }
                EditorGUILayout.PropertyField(prop, true);
                continue;
            }

            if (grouping)
            {
                // only draw if the fold is open
                if (_foldoutStates[currentHeader])
                    EditorGUILayout.PropertyField(prop, true);
            }
            else
            {
                // outside any group
                EditorGUILayout.PropertyField(prop, true);
            }
        }

        // close any dangling indent
        if (grouping)
            EditorGUI.indentLevel--;

        serializedObject.ApplyModifiedProperties();
    }

    /// <summary>
    /// Given a SerializedProperty, attempt to resolve its FieldInfo via reflection,
    /// handling arrays and nested types.
    /// </summary>
    private FieldInfo GetFieldInfo(SerializedProperty prop)
    {
        var path = prop.propertyPath.Replace(".Array.data[", "[");
        var elements = path.Split('.');
        System.Type type = target.GetType();
        FieldInfo fi = null;

        foreach (var element in elements)
        {
            var name = element;
            int bracket = element.IndexOf('[');
            if (bracket >= 0)
                name = element.Substring(0, bracket);

            fi = type.GetField(
                name,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
            );
            if (fi == null) return null;

            type = fi.FieldType;
            // unwrap array or List<>
            if (type.IsArray)
                type = type.GetElementType();
            else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
                type = type.GetGenericArguments()[0];
        }

        return fi;
    }
}
#endif

How it works

Fallback editor
The [CustomEditor(typeof(MonoBehaviour), true, true)] attribute makes this a fallback inspector for all MonoBehaviour-derived types—but only when you haven’t defined a more specific CustomEditor for that class. That way it won’t stomp on any other editor scripts you’ve written.
Scanning in declaration order
By iterating SerializedProperty via NextVisible, Unity gives you fields in the same order they normally appear.
Grouping logic
- Hitting a [Header("…")] starts (or switches to) a new foldout group.
- Seeing two [Space] attributes on a single field acts as a one-time “exit” marker: it closes the open group and draws that field (and all that follow) normally—until a new header re-opens a group.
- Fields outside any header or after an exit are drawn exactly as Unity would by default.

You can now organize your Inspector into as many collapsible header-groups as you like, simply by sprinkling in [Header] and—even if you need to break a group—two [Space] attributes.

Here’s the same HeaderGroupEditor, but at the very top of OnInspectorGUI it bails out for anything not in UnchartedLimbo—so all your other types get the normal inspector.

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System.Reflection;
using System.Collections.Generic;

[CustomEditor(typeof(MonoBehaviour), true, true)]  // fallback for all MonoBehaviours
[CanEditMultipleObjects]
public class HeaderGroupEditor : Editor
{
    private Dictionary<string, bool> _foldoutStates = new Dictionary<string, bool>();

    public override void OnInspectorGUI()
    {
        // Only apply grouping to types in UnchartedLimbo (or its sub-namespaces)
        var t = target.GetType();
        if (t.Namespace == null || !t.Namespace.StartsWith("UnchartedLimbo"))
        {
            // draw the normal inspector and exit
            DrawDefaultInspector();
            return;
        }

        serializedObject.Update();

        var prop = serializedObject.GetIterator();
        bool enterChildren = true;

        // Draw the script field first as usual
        if (prop.NextVisible(enterChildren))
            EditorGUILayout.PropertyField(prop, true);

        bool grouping = false;
        string currentHeader = null;

        while (prop.NextVisible(false))
        {
            var fi = GetFieldInfo(prop);
            var headerAttr = fi?.GetCustomAttribute<HeaderAttribute>(true);
            var spaces = fi?.GetCustomAttributes(typeof(SpaceAttribute), true);

            bool isHeader = headerAttr != null;
            bool isExit   = spaces != null && spaces.Length >= 2;

            if (isHeader)
            {
                if (grouping)
                    EditorGUI.indentLevel--;

                grouping = true;
                currentHeader = headerAttr.header;

                if (!_foldoutStates.ContainsKey(currentHeader))
                    _foldoutStates[currentHeader] = true;

                _foldoutStates[currentHeader] = EditorGUILayout.Foldout(
                    _foldoutStates[currentHeader],
                    currentHeader,
                    true
                );

                EditorGUI.indentLevel++;
                continue;
            }

            if (isExit)
            {
                if (grouping)
                {
                    EditorGUI.indentLevel--;
                    grouping = false;
                    currentHeader = null;
                }
                EditorGUILayout.PropertyField(prop, true);
                continue;
            }

            if (grouping)
            {
                if (_foldoutStates[currentHeader])
                    EditorGUILayout.PropertyField(prop, true);
            }
            else
            {
                EditorGUILayout.PropertyField(prop, true);
            }
        }

        if (grouping)
            EditorGUI.indentLevel--;

        serializedObject.ApplyModifiedProperties();
    }

    private FieldInfo GetFieldInfo(SerializedProperty prop)
    {
        var path = prop.propertyPath.Replace(".Array.data[", "[");
        var elements = path.Split('.');
        System.Type type = target.GetType();
        FieldInfo fi = null;

        foreach (var element in elements)
        {
            var name = element;
            int bracket = element.IndexOf('[');
            if (bracket >= 0)
                name = element.Substring(0, bracket);

            fi = type.GetField(
                name,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
            );
            if (fi == null) return null;

            type = fi.FieldType;
            if (type.IsArray)
                type = type.GetElementType();
            else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
                type = type.GetGenericArguments()[0];
        }

        return fi;
    }
}
#endif

What changed?

Namespace check
```
if (t.Namespace == null || !t.Namespace.StartsWith("UnchartedLimbo"))
{
    DrawDefaultInspector();
    return;
}
```
At runtime this ensures only types whose namespace begins with UnchartedLimbo get the fold-out behavior; everything else falls back to Unity’s default inspector.

Just drop this into an Editor/ folder; any MonoBehaviour under UnchartedLimbo (or UnchartedLimbo.Subspace…) will now group under headers with foldouts, exit on [Space][Space], etc., while all others remain untouched.

Below is the fully revised HeaderGroupEditor—drop it into an Editor/ folder. It now:

Only applies to types in UnchartedLimbo (and sub-namespaces).
Remembers each object’s foldout state across selections, by keying a static dictionary on target.GetInstanceID() + header name.
Draws the very first field that carries the [Header] (so nothing is skipped), but uses its normal label (fixing the “header repeated inside” problem).
Renders the header titles bold with Unity’s foldout arrow.

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System.Reflection;
using System.Collections.Generic;

/// <summary>
/// Fallback inspector for all MonoBehaviours, but only in the UnchartedLimbo namespace.
/// Groups fields under each [Header("…")] into a collapsible foldout, exits on [Space][Space],
/// and otherwise behaves exactly like Unity’s default inspector.
/// </summary>
[CustomEditor(typeof(MonoBehaviour), true, true)]  // the third ‘true’ makes it a fallback
[CanEditMultipleObjects]
public class HeaderGroupEditor : Editor
{
    //––– Persistent, shared state so foldouts “remember” per-object, even when you re-select –––
    // Keyed by $"{instanceID}_{headerString}"
    private static Dictionary<string,bool> s_FoldoutStates = new Dictionary<string,bool>();

    // Bold‐style foldout (arrow + bold text)
    private GUIStyle _boldFoldoutStyle;

    private void OnEnable()
    {
        // Clone Unity’s default foldout style and make it bold
        _boldFoldoutStyle = new GUIStyle(EditorStyles.foldout)
        {
            fontStyle = FontStyle.Bold
        };
    }

    public override void OnInspectorGUI()
    {
        // 1) Namespace guard: only UnchartedLimbo.*
        var t = target.GetType();
        if (t.Namespace == null || !t.Namespace.StartsWith("UnchartedLimbo"))
        {
            DrawDefaultInspector();
            return;
        }

        serializedObject.Update();

        // 2) Draw the “Script” field first (always present on MonoBehaviour)
        var prop = serializedObject.GetIterator();
        bool enterChildren = true;
        if (prop.NextVisible(enterChildren))
            EditorGUILayout.PropertyField(prop, true);

        // State for the current group
        bool grouping = false;
        string currentHeader = null;
        bool currentOpen    = true;

        // 3) Walk through every other visible property in declaration order
        while (prop.NextVisible(false))
        {
            // Use reflection to grab any Header or Space attributes on this field
            FieldInfo fi = GetFieldInfo(prop);
            var headerAttr = fi?.GetCustomAttribute<HeaderAttribute>(true);
            var spaceAttrs = fi?.GetCustomAttributes(typeof(SpaceAttribute), true);

            bool isHeader     = headerAttr != null;
            bool isExitMarker = (spaceAttrs != null && spaceAttrs.Length >= 2);

            // --- Start a new foldout on [Header] ---
            if (isHeader)
            {
                // If we were already in a group, close its indent
                if (grouping)
                    EditorGUI.indentLevel--;

                grouping      = true;
                currentHeader = headerAttr.header;

                // Build a per-object key so each instance “remembers” its state
                string key = $"{target.GetInstanceID()}_{currentHeader}";
                if (!s_FoldoutStates.TryGetValue(key, out currentOpen))
                {
                    currentOpen = true;
                    s_FoldoutStates[key] = currentOpen;
                }

                // Draw the foldout header (arrow + bold label)
                currentOpen = EditorGUILayout.Foldout(
                    currentOpen,
                    currentHeader,
                    true,               // toggle when clicking text
                    _boldFoldoutStyle   // our bold style
                );
                // Save back the new open/closed state
                s_FoldoutStates[key] = currentOpen;

                // Indent everything inside this group
                EditorGUI.indentLevel++;

                // ** Draw the very first field (the one that had [Header]) **
                // using its **normal** label (prop.displayName) so it isn’t repeated
                if (currentOpen)
                    EditorGUILayout.PropertyField(prop, true);

                // Continue to next prop
                continue;
            }

            // --- Exit the group if we see [Space][Space] on a single field ---
            if (isExitMarker)
            {
                if (grouping)
                {
                    EditorGUI.indentLevel--;
                    grouping      = false;
                    currentHeader = null;
                }
                // Always draw this field normally
                EditorGUILayout.PropertyField(prop, true);
                continue;
            }

            // --- Otherwise: draw inside the group only if it’s open; or outside if no group ---
            if (grouping)
            {
                if (currentOpen)
                    EditorGUILayout.PropertyField(prop, true);
            }
            else
            {
                EditorGUILayout.PropertyField(prop, true);
            }
        }

        // Unindent if we ended inside a group
        if (grouping)
            EditorGUI.indentLevel--;

        serializedObject.ApplyModifiedProperties();
    }

    /// <summary>
    /// Helper: given a SerializedProperty, finds the corresponding FieldInfo (handles arrays/lists/nesting).
    /// </summary>
    private FieldInfo GetFieldInfo(SerializedProperty prop)
    {
        // Turn “myList.Array.data[0].someField” → “myList[0].someField”
        string path = prop.propertyPath.Replace(".Array.data[", "[");
        var elements = path.Split('.');
        System.Type type = target.GetType();
        FieldInfo fi = null;

        foreach (var element in elements)
        {
            string name = element;
            int bracket = element.IndexOf('[');
            if (bracket >= 0)
                name = element.Substring(0, bracket);

            fi = type.GetField(name,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
            );
            if (fi == null)
                return null;

            // Drill down into the element type if it’s an array or List<T>
            type = fi.FieldType;
            if (type.IsArray)
                type = type.GetElementType();
            else if (type.IsGenericType
                     && type.GetGenericTypeDefinition() == typeof(List<>))
                type = type.GetGenericArguments()[0];
        }
        return fi;
    }
}
#endif

Key changes

Static dictionary (s_FoldoutStates) keyed by instanceID + header so foldouts persist when you switch objects.
In the [Header] block, we now also draw that first field inside the group (but only once, and using its real label), so nothing is skipped or doubly-drawn.
We clone EditorStyles.foldout and set fontStyle = FontStyle.Bold so your headers appear bold.

Drop this into Assets/Editor/ (or any Editor-only folder). Any MonoBehaviour under UnchartedLimbo will now have collapsible, remembered header groups, an exit via [Space][Space], and bold section titles—while everything else remains Unity’s default inspector.

Here’s a small tweak in your isHeader block so that the first field under the [Header] is drawn without its built-in decorator (i.e. the extra header label), and only your bold foldout title remains. You don’t have to rewrite the whole script—just replace the part marked below:

if (isHeader)
{
    if (grouping)
        EditorGUI.indentLevel--;

    grouping      = true;
    currentHeader = headerAttr.header;

    // … your existing foldout-state lookup …

    // draw the foldout arrow + bold title
    currentOpen = EditorGUILayout.Foldout(
        currentOpen,
        currentHeader,
        true,
        _boldFoldoutStyle
    );
    s_FoldoutStates[key] = currentOpen;

    EditorGUI.indentLevel++;

    // old: this re-draws the header decorator *and* the field, so header repeats
    if (currentOpen)
        EditorGUILayout.PropertyField(prop, true);
    // new: draw only the field itself, using its displayName label
    // (this bypasses the HeaderAttribute decorator)
    if (currentOpen)
    {
        // option A: simple override label
        EditorGUILayout.PropertyField(prop, new GUIContent(prop.displayName), true);

        // option B (more explicit, in case A still draws decorator):
        // float h = EditorGUI.GetPropertyHeight(prop, true);
        // Rect r = EditorGUILayout.GetControlRect(true, h);
        // EditorGUI.PropertyField(r, prop, new GUIContent(prop.displayName), true);
    }

    continue;
}

What changed?

We swap out your old
```
EditorGUILayout.PropertyField(prop, true);
```
which re-invokes Unity’s header decorator for that very field,
with
```
EditorGUILayout.PropertyField(prop, new GUIContent(prop.displayName), true);
```
– i.e. we supply our own label and let Unity skip its HeaderAttribute drawer on that pass.

If you find Unity still sneaking in the decorator, switch to the “Option B” (using GetControlRect + EditorGUI.PropertyField), which is guaranteed to draw only the field contents under your foldout.

Yes—you can have a single MonoBehaviour whose OnEnable() fires both in Edit-mode and Play-mode, but whose Update() only does work when you’re actually playing. The trick is:

Tell Unity to call your callbacks in Edit-mode by using

[ExecuteAlways]    // or [ExecuteInEditMode] in older Unity versions

In your Update() immediately bail out if you’re not in Play:

using UnityEngine;

[ExecuteAlways]  // makes Unity call OnEnable/OnDisable/Update/etc. even in Edit mode
public class MyBehaviour : MonoBehaviour
{
    void OnEnable()
    {
        // This will run both when you enable the component in the editor
        // AND when you enter Play-mode.
        Debug.Log($"OnEnable on {name}; playing? {Application.isPlaying}");
    }

    void Update()
    {
        // Always-called in both modes—so guard it:
        if (!Application.isPlaying)
            return;

        // From here on, you know you're in Play-mode.
        Debug.Log($"  ▶ Update at time {Time.time}");
    }
}

Why it works

[ExecuteAlways] (formerly [ExecuteInEditMode]) makes Unity invoke your component’s life-cycle methods in the Editor.
Application.isPlaying is false until you hit “Play.” By returning early, you effectively disable your Update() outside of Play-mode, while still getting the free “always-on” OnEnable().

You’ll get exactly what you asked for:

OnEnable() always runs.
Update() only actually does anything once the Editor is in Play.

I want to update these variables only if they are null. what’s the fanciest-looking way?

    m_applyImpulse = VoxelUtilsComputeResources.Instance.m_applyImpulse;
    m_applyAdvect = VoxelUtilsComputeResources.Instance.m_applyAdvect;
    m_computeVorticity = VoxelUtilsComputeResources.Instance.m_computeVorticity;

    m_computeDivergence = VoxelUtilsComputeResources.Instance.m_computeDivergence;
    m_computeJacobi = VoxelUtilsComputeResources.Instance.m_computeJacobi;
    m_computeProjection = VoxelUtilsComputeResources.Instance.m_computeProjection;

    m_computeConfinement = VoxelUtilsComputeResources.Instance.m_computeConfinement;
    m_computeObstacles = VoxelUtilsComputeResources.Instance.m_computeObstacles;
    m_applyBuoyancy = VoxelUtilsComputeResources.Instance.m_applyBuoyancy;

    m_applyVelocityField = VoxelUtilsComputeResources.Instance.m_applyVelocityField;
    m_applyDensityField = VoxelUtilsComputeResources.Instance.m_applyDensityField;
    m_applyCustomObstacles = VoxelUtilsComputeResources.Instance.m_applyCustomObstacles;

Here are a few “fancy” ways to say

“if my local m_… is null, grab it from VoxelUtilsComputeResources.Instance”

without repeating a full if(…==null) block every time.

1) C# 8+ null-coalescing assignment (`??=`)

var r = VoxelUtilsComputeResources.Instance;
m_applyImpulse          ??= r.m_applyImpulse;
m_applyAdvect           ??= r.m_applyAdvect;
m_computeVorticity      ??= r.m_computeVorticity;
m_computeDivergence     ??= r.m_computeDivergence;
m_computeJacobi         ??= r.m_computeJacobi;
m_computeProjection     ??= r.m_computeProjection;
m_computeConfinement    ??= r.m_computeConfinement;
m_computeObstacles      ??= r.m_computeObstacles;
m_applyBuoyancy         ??= r.m_applyBuoyancy;
m_applyVelocityField    ??= r.m_applyVelocityField;
m_applyDensityField     ??= r.m_applyDensityField;
m_applyCustomObstacles  ??= r.m_applyCustomObstacles;

Super concise: each line means “assign RHS only if LHS is currently null.”

2) Tuple deconstruction

Pack all your fields into a tuple and re-assign them in one go:

var r = VoxelUtilsComputeResources.Instance;
(
    m_applyImpulse,
    m_applyAdvect,
    m_computeVorticity,
    m_computeDivergence,
    m_computeJacobi,
    m_computeProjection,
    m_computeConfinement,
    m_computeObstacles,
    m_applyBuoyancy,
    m_applyVelocityField,
    m_applyDensityField,
    m_applyCustomObstacles
)
= (
    m_applyImpulse         ?? r.m_applyImpulse,
    m_applyAdvect          ?? r.m_applyAdvect,
    m_computeVorticity     ?? r.m_computeVorticity,
    m_computeDivergence    ?? r.m_computeDivergence,
    m_computeJacobi        ?? r.m_computeJacobi,
    m_computeProjection    ?? r.m_computeProjection,
    m_computeConfinement   ?? r.m_computeConfinement,
    m_computeObstacles     ?? r.m_computeObstacles,
    m_applyBuoyancy        ?? r.m_applyBuoyancy,
    m_applyVelocityField   ?? r.m_applyVelocityField,
    m_applyDensityField    ?? r.m_applyDensityField,
    m_applyCustomObstacles ?? r.m_applyCustomObstacles
);

Visually striking, but does exactly the same null-check on each element.

3) Reflective helper (overkill-but-dynamic)

void EnsureResources()
{
    var inst = VoxelUtilsComputeResources.Instance;
    var myType = GetType();
    var resType = inst.GetType();

    foreach (var fi in myType.GetFields(
             BindingFlags.Instance|BindingFlags.NonPublic|BindingFlags.Public))
    {
        if (!fi.Name.StartsWith("m_")) continue;
        if (fi.GetValue(this) != null)       continue;

        var other = resType.GetField(fi.Name,
            BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
        if (other != null)
            fi.SetValue(this, other.GetValue(inst));
    }
}

This one auto-syncs any m_… field you add in the future — but at the cost of reflection.

My vote: go with Option 1 (??=). It’s both terse and idiomatic in modern C#.

If you’re finding that

m_applyImpulse ??= VoxelUtilsComputeResources.Instance.m_applyImpulse;

isn’t actually populating your fields, it usually comes down to one of two things:

Your project isn’t on C# 8+, so the compiler silently ignores ??=.
Both sides really are null, so coalescing never “kicks in.”

1) The “defensive” one-liner that always works

Whether or not you have C# 8, you can always fall back to the plain old null-coalescing operator:

var r = VoxelUtilsComputeResources.Instance;
m_applyImpulse         = m_applyImpulse        ?? r.m_applyImpulse;
m_applyAdvect          = m_applyAdvect         ?? r.m_applyAdvect;
m_computeVorticity     = m_computeVorticity    ?? r.m_computeVorticity;
m_computeDivergence    = m_computeDivergence   ?? r.m_computeDivergence;
m_computeJacobi        = m_computeJacobi       ?? r.m_computeJacobi;
m_computeProjection    = m_computeProjection   ?? r.m_computeProjection;
m_computeConfinement   = m_computeConfinement  ?? r.m_computeConfinement;
m_computeObstacles     = m_computeObstacles    ?? r.m_computeObstacles;
m_applyBuoyancy        = m_applyBuoyancy       ?? r.m_applyBuoyancy;
m_applyVelocityField   = m_applyVelocityField  ?? r.m_applyVelocityField;
m_applyDensityField    = m_applyDensityField   ?? r.m_applyDensityField;
m_applyCustomObstacles = m_applyCustomObstacles?? r.m_applyCustomObstacles;

This compiles everywhere, reads “if the left is null, take the right,” and will populate your fields as long as VoxelUtilsComputeResources.Instance.* is non-null.

2) The C# 8+ “elegant” form

If you are on C# 8+ (check your Assembly-Definition’s LangVersion), the true null-coalescing assignment operator ??= is both shorter and idiomatic:

var r = VoxelUtilsComputeResources.Instance;
m_applyImpulse         ??= r.m_applyImpulse;
m_applyAdvect          ??= r.m_applyAdvect;
m_computeVorticity     ??= r.m_computeVorticity;
m_computeDivergence    ??= r.m_computeDivergence;
m_computeJacobi        ??= r.m_computeJacobi;
m_computeProjection    ??= r.m_computeProjection;
m_computeConfinement   ??= r.m_computeConfinement;
m_computeObstacles     ??= r.m_computeObstacles;
m_applyBuoyancy        ??= r.m_applyBuoyancy;
m_applyVelocityField   ??= r.m_applyVelocityField;
m_applyDensityField    ??= r.m_applyDensityField;
m_applyCustomObstacles ??= r.m_applyCustomObstacles;

If you still see “empty” fields afterward, inspect r.m_apply… at runtime—if they are null, there’s nothing to pull in.

3) A DRY helper if you hate repetition

static void Ensure<T>(ref T field, T fallback) where T : class
{
    if (field == null) field = fallback;
}

// usage
var r = VoxelUtilsComputeResources.Instance;
Ensure(ref m_applyImpulse,         r.m_applyImpulse);
Ensure(ref m_applyAdvect,          r.m_applyAdvect);
Ensure(ref m_computeVorticity,     r.m_computeVorticity);
// …etc…

Keeps you from typing the ??/??= each time, and the intent (“only fill if null”) is extremely explicit.

TL;DR

If ??= isn’t assigning, switch to the “always-valid” pattern
```
m = m ?? VoxelUtilsComputeResources.Instance.m;
```
Or wrap it in a tiny Ensure(ref, fallback) helper.
And finally, make sure your resource-instance fields are non-null at the point you read them!

I get Null reference exception exactly here:

NullReferenceException: Object reference not set to an instance of an object UnityEditor.EditorStyles.get_foldout () (at <4433099e545d41c7811d6234e87bfc95>:0) UnchartedLimbo.Core.Editor.UniversalEditor.OnEnable () (at ./Packages/com.ulc.core/Editor/UniversalEditor.cs:39)

  private void OnEnable()
    {
        // Clone Unity’s default foldout style and make it bold
        _boldFoldoutStyle = new GUIStyle(EditorStyles.foldout)
        {
            fontStyle = FontStyle.Bold
        };
    }

The problem here is that, in some Unity versions or contexts, EditorStyles.foldout isn’t yet initialized when your OnEnable runs—and so calling it there throws.

The simplest fix is to defer pulling in EditorStyles.foldout until you actually need it in OnInspectorGUI(), falling back to the built-in Inspector skin if necessary. That way you never hit the NRE, and you only create your bold style once.

Below is just the relevant snippet you can swap into your existing HeaderGroupEditor—no need to rewrite the whole thing. Remove your OnEnable(), and add this helper + lazy‐init inside your editor class:

// --- inside your HeaderGroupEditor class ---

private GUIStyle _boldFoldoutStyle;
private GUIStyle BoldFoldoutStyle
{
    get
    {
        if (_boldFoldoutStyle != null)
            return _boldFoldoutStyle;

        // Try the regular EditorStyles first…
        GUIStyle baseFoldout = EditorStyles.foldout;
        // If that's null (NRE culprit), fall back to the built-in Inspector skin
        if (baseFoldout == null)
            baseFoldout = EditorGUIUtility
                             .GetBuiltinSkin(EditorSkin.Inspector)
                             .FindStyle("Foldout");

        // Now clone-and-bold-ify
        _boldFoldoutStyle = new GUIStyle(baseFoldout)
        {
            fontStyle = FontStyle.Bold
        };
        return _boldFoldoutStyle;
    }
}

Then, wherever you were calling

currentOpen = EditorGUILayout.Foldout(
    currentOpen,
    currentHeader,
    true,
    _boldFoldoutStyle
);

just switch to

currentOpen = EditorGUILayout.Foldout(
    currentOpen,
    currentHeader,
    true,
    BoldFoldoutStyle
);

Why this works

No more OnEnable timing issue. You no longer touch EditorStyles.foldout until Unity’s UI system is fully up.
Single-instance caching. The property only builds the style once, then reuses it every frame.
Safe fallback. If EditorStyles.foldout is null, you grab the same style Unity uses under the hood.

Drop that into your existing editor script (removing your old OnEnable entirely) and the NRE will go away.

Here’s all you need to add/swap in your project:

1. Define the `FoldoutHeader` attribute

Create a new file in your runtime (or Scripts/) folder, e.g. FoldoutHeaderAttribute.cs:

using System;
using UnityEngine;

/// <summary>
/// Exactly like [Header], but marks the start of a foldout group in the Inspector.
/// </summary>
[AttributeUsage(AttributeTargets.Field, Inherited = true, AllowMultiple = false)]
public class FoldoutHeaderAttribute : PropertyAttribute
{
    public string header { get; }
    public FoldoutHeaderAttribute(string header)
    {
        this.header = header;
    }
}

2. Switch your Editor to look for `FoldoutHeaderAttribute`

In your existing HeaderGroupEditor (or wherever you scan for [Header]), replace only the bits that detect and use HeaderAttribute with FoldoutHeaderAttribute. For example:

// … inside your OnInspectorGUI() loop, where you reflect on each field …
var headerAttr   = fi?.GetCustomAttribute<HeaderAttribute>(true);
var headerAttr   = fi?.GetCustomAttribute<FoldoutHeaderAttribute>(true);

// was:
bool isHeader    = headerAttr != null;
bool isHeader    = headerAttr != null;

if (isHeader)
{
    currentHeader = headerAttr.header;
    currentHeader = headerAttr.header;

    // … your existing foldout-state lookup …

    // draw the foldout arrow + bold label
    currentOpen = EditorGUILayout.Foldout(currentOpen, currentHeader, true, BoldFoldoutStyle);
    currentOpen = EditorGUILayout.Foldout(currentOpen, currentHeader, true, BoldFoldoutStyle);

    // indent and then draw the *first* field under this header…
    if (currentOpen)
        EditorGUILayout.PropertyField(prop, new GUIContent(prop.displayName), true);
    if (currentOpen)
        EditorGUILayout.PropertyField(prop, new GUIContent(prop.displayName), true);

    continue;
}

What that does

Only fields marked [FoldoutHeader("My Section")] will start a collapsible group.
Everything else (including plain [Header]) behaves exactly as before.
You keep your bold‐foldout, remember‐state and exit-on-[Space][Space] logic intact.

Once you’ve saved those two changes—your attribute on any field will automatically turn it into a remembered, bold foldout-group header.

Here’s just the minimal patch in your OnInspectorGUI() loop—no need to rewrite everything, just replace the old [Space][Space] exit with a check for a regular HeaderAttribute:

// … inside your while(prop.NextVisible(false)) loop …

var headerAttr   = fi?.GetCustomAttribute<FoldoutHeaderAttribute>(true);
var spaceAttrs   = fi?.GetCustomAttributes(typeof(SpaceAttribute), true);

bool isHeader     = headerAttr != null;
bool isExitMarker = (spaceAttrs != null && spaceAttrs.Length >= 2);

// detect our custom foldout header vs. a normal Unity [Header]
var foldoutAttr       = fi?.GetCustomAttribute<FoldoutHeaderAttribute>(true);
var regularHeaderAttr = fi?.GetCustomAttribute<HeaderAttribute>(true);

bool isFoldoutHeader  = foldoutAttr   != null;
bool isRegularHeader  = regularHeaderAttr != null;

// ——— start a foldout on [FoldoutHeader] ———
if (isHeader)
if (isFoldoutHeader)
{
    // … your existing foldout-start code …
}

// ——— **exit** the current foldout when a **regular** [Header] shows up ———
if (isExitMarker)
if (isRegularHeader)
{
    if (grouping)
    {
        EditorGUI.indentLevel--;
        grouping     = false;
        currentHeader = null;
    }
    // draw the field (and let Unity’s HeaderAttributeDecorator handle the label)
    EditorGUILayout.PropertyField(prop, true);
    continue;
}

// ——— otherwise draw inside the fold if open, or normally if not grouping ———
if (grouping)
{
    if (currentOpen)
        EditorGUILayout.PropertyField(prop, true);
}
else
{
    EditorGUILayout.PropertyField(prop, true);
}

What this does

Starts a new foldout only when you hit [FoldoutHeader("…")].
Closes (and draws normally) whenever you hit a plain [Header("…")].
Completely drops the old double-[Space] logic.

With that in place, any ordinary HeaderAttribute will break out of your fold group, while your custom FoldoutHeaderAttribute still creates the collapsible sections.