Unity object placement tool

using System.IO;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

public class SceneToolWindow : EditorWindow
{
    bool changeScale;
    FloatMinMax scale = FloatMinMax.One;

    bool changeRotation;
    FloatMinMax rotation = new FloatMinMax(-360, 360);

    float positionOffset;

    GameObject[] prefabs = new GameObject[1];

    [MenuItem("Tools/Show Scene Tool")]
    public static void ShowBuildWindow()
    {
        var window = CreateInstance(typeof(SceneToolWindow)) as SceneToolWindow;
        window.Show();
    }

    void OnGUI()
    {
        if (prefabs == null || prefabs.Length < 1)
        {
            prefabs = new GameObject[1];
        }
        using (new EditorGUILayout.HorizontalScope())
        {
            using (new EditorGUILayout.HorizontalScope(GUILayout.MaxWidth(20)))
            {
                changeScale = EditorGUILayout.Toggle(changeScale);
            }
            GUI.enabled = changeScale;
            EditorGUILayout.MinMaxSlider("Scale", ref scale.min, ref scale.max, 0, 10);
            scale = EditorGUILayout.Vector2Field("", new Vector2(scale.min, scale.max));
            GUI.enabled = true;
        }

        using (new EditorGUILayout.HorizontalScope())
        {
            using (new EditorGUILayout.HorizontalScope(GUILayout.MaxWidth(20)))
            {
                changeRotation = EditorGUILayout.Toggle(changeRotation);
            }
            GUI.enabled = changeRotation;
            EditorGUILayout.MinMaxSlider("Rotation", ref rotation.min, ref rotation.max, -360, 360);
            rotation = EditorGUILayout.Vector2Field("", new Vector2(rotation.min, rotation.max));
            GUI.enabled = true;
        }

        if (GUILayout.Button("Randomize"))
        {
            foreach (var go in Selection.gameObjects)
            {
                if (changeScale)
                {
                    var scaleValue = scale.Lerp(Random.value);
                    go.transform.localScale = Vector3.one * scaleValue;
                }
                if (changeRotation)
                {
                    go.transform.localRotation = Math2D.AngleToRotation(rotation.Lerp(Random.value));
                }
                Undo.RegisterFullObjectHierarchyUndo(go, "Randomize Values");

            }

        }

        EditorGUILayout.LabelField("Replace Selected Objects:");
        for (int i = 0; i < prefabs.Length; i++)
        {
            using (new EditorGUILayout.HorizontalScope())
            {
                prefabs[i] = EditorGUILayout.ObjectField(prefabs[i], typeof(GameObject), false) as GameObject;

                using (new EditorGUILayout.HorizontalScope(GUILayout.MaxWidth(64)))
                {
                    if (GUILayout.Button("+"))
                    {
                        ArrayUtility.Insert(ref prefabs, i, prefabs[i]);
                    }
                    if (i > 0)
                    {
                        if (GUILayout.Button("-"))
                        {
                            ArrayUtility.RemoveAt(ref prefabs, i);
                            break;
                        }
                    }
                }
            }
        }
        GUI.enabled = prefabs[0];
        if (GUILayout.Button("Replace"))
        {
            ReplaceSelectedObjects();
        }
        GUI.enabled = true;

    }

    void ReplaceSelectedObjects()
    {
        var newGos = new List<GameObject>();
        foreach (var go in Selection.gameObjects)
        {
            var prefab = prefabs[Random.Range(0, prefabs.Length)];
            if (prefab != null)
            {
                var newGo = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
                newGo.transform.SetParent(go.transform.parent, false);
                newGo.transform.position = go.transform.localPosition;
                newGo.transform.rotation = go.transform.localRotation;
                newGo.transform.localScale = go.transform.localScale;
                Undo.RegisterCreatedObjectUndo(newGo, "Create Object");
                newGos.Add(newGo);
            }
            Undo.DestroyObjectImmediate(go);
        }
        Selection.objects = newGos.ToArray();
    }
}


//Optional struct for easy lerps
[System.Serializable]
public struct FloatMinMax {

    public float min;
    public float max;

    public FloatMinMax(float min, float max)
    {
        this.min = min;
        this.max = max;
    }

    public float Lerp(float t)
    {
        return Mathf.Lerp(min, max, t);
    }

    public float InverseLerp(float t)
    {
        return Mathf.InverseLerp(min, max, t);
    }

    public bool Includes(float value)
    {
        return value > min && value < max;
    }

    public static FloatMinMax One
    {
        get
        {
            FloatMinMax value;
            value.min = value.max = 1f;
            return value;
        }
    }

    public static implicit operator FloatMinMax (Vector2 v)
    {
        return new FloatMinMax(v.x, v.y);
    }
}