Change Component Order via Script

One way to do this is by attaching a component, that references all the other components attached to the same gameObject, and then via some magical custom editor stuff, you could get something like this (an example of what I'm working on):

You could see those "U" and "D" buttons, which stand for Up/Down. You could use this object to sort the other components, and then when you want to render - you take the order of your components, from that component.

If this solutions works for you, let me know and I'll post the code I used to get this custom editor.

So, here's what I worked out for you:

Here's the sorter component, for which I will make a custom editor for - it just has a list of components:

 using UnityEngine;
 using System.Collections.Generic;

 public class ComponentSorter : MonoBehaviour
 {
     [HideInInspector]
     public List<Component> components;

     void OnGUI()
     {
         for (int i = 0; i < components.Count; i++) {
             GUI.Label(new Rect(Screen.width / 2, i * 25, 500, 50), components[i].ToString());
         }
     }
 }

And, here's where the magic happens:

ComponentSorterEditor.cs (put this in your Editor folder, if you don't have one, create it - "Assets/Editor")

 using UnityEngine;
 using UnityEditor;
 using System.Collections.Generic;
 
 [CustomEditor(typeof(ComponentSorter))]
 public class ComponentSorterEditor : Editor
 {
 private SerializedProperty components;
 private void OnEnable()
 {
     components = serializedObject.FindProperty("components");
 }
 public override void OnInspectorGUI()
 {
     DrawDefaultInspector();

     serializedObject.Update();
     PopulateComponents();
     GUILayout.Label(components.name, EditorStyles.boldLabel);

     for (int i = 0; i < components.arraySize; i++) {
         EditorGUILayout.BeginHorizontal();
         {
             EditorGUILayout.PropertyField(components.GetAt(i));

             if (GUILayout.Button("D", GUILayout.Width(20f))) {
                 components.MoveDown(i);
             }
             if (GUILayout.Button("U", GUILayout.Width(20f))) {
                 components.MoveUp(i);
             }
         }
         EditorGUILayout.EndHorizontal();
     }
     serializedObject.ApplyModifiedProperties();
 }
 private void PopulateComponents()
 {
     components.RemoveNullObjects();
     var targetGo = (serializedObject.targetObject as ComponentSorter).gameObject;
     var comps = targetGo.GetComponents<Component>();
     foreach (var comp in comps) {
         if (!components.Contains(comp)) {
             components.Add(comp);
         }
     }
 }

I think the code is pretty straight forward. One thing to note here, RemoveNullObjects is useful so that, if you remove a component, the components list will get populated accordingly in a way that you won't see nulls as the objects values.

See this video, to see what I'm talking about. (I solved it on the fly in a redundant way in the video, there was no need to clear out the whole array)

Here's the SerializedProperty extension methods. Don't be scared, they're just there to make your life easier. Feel free to modify.

One thing you'd probably wanna do is remove the ComponentSorter reference from the components themselves. That could be easily achieved by adding one more condition to the if that's adding the comps:

 if (!components.Contains(comp) && !(comp is ComponentSorter)) {
     components.Add(comp);
 }

When you want to render your stuff, you just do:

 var orderedComps = myStuffGo.GetComponent<ComponentSorter>().components;

Hope you like it :)

Answering your comment:

You'll get serializedObject for free when you inherit from Editor which is where its declared. As its name suggests, it's of type SerializedObject

If you don't want to use the custom editor, then you won't get a visual representation of what's going on.

If you insist, you could use the extension methods I have MoveUp and MoveDown methods 'inside' ComponentSorter:

They just need some modifications:

 public static List<T> Swap<T>(this List<T> list, int i, int j)
 {
     T temp = list[i];
     list[i] = list[j];
     list[j] = temp;
     return list;
 }

• Codes are not tested from this point on **

  public class ComponentSorter : MonoBehaviour { public List components; public void MoveUp(int fromIndex) { int previous = fromIndex - 1; if (previous < 0) previous = prop.arraySize - 1; components.Swap(fromIndex, previous); } public void MoveDown(int fromIndex) { int next = (fromIndex + 1) % prop.arraySize; components.Swap(fromIndex, next); } }

(You could actually make the MoveUp and MoveDown list extensions as well, I'd go for that...)

If you don't like moving them by index, you could do:

 public void Move(Component c, bool up)
 {
    int index = components.IndexOf(c);
    if (index == -1) return; // component not found;
    if (up) MoveUp(index);
    else MoveDown(index);
 }

So... wanna move the Transform component? you could do:

 Move(components.Find(c => c is Transform) as Transform, true); // don't forget System.Linq;

One more thing you could do, write a generic move method:

 public void Move<T>(bool up) where T : Component
 {
    int index = components.FindIndex(c => c.GetType() == typeof(T)); // if you want to get any children of 'T' do "c => c.GetType().IsSubclassOf(typeof(T))
    if (index == -1) return; // component not found;
    if (up) MoveUp(index);
    else MoveDown(index);
 }

Use it like:

 // for pure convenience
 private const bool UP = true;
 private const bool DOWN = false;
 
 Move<Transform>(UP);

I suggest you keep the custom editor - it's very useful. If you do remove it, then you have to move the population of the components array, to the sorter as well...