Unityのエディタ拡張｜一括リネーム・Undo・グループ化と共有方法

using System;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.UI;

// Assets/Editor/CgmRemoveOutline.cs
public static class CgmSceneSelection
{
    public static GameObject[] Get()
    {
        if (EditorApplication.isPlayingOrWillChangePlaymode)
            throw new InvalidOperationException("Exit Play Mode first.");
        GameObject[] objects = Selection.gameObjects;
        if (objects.Length == 0)
            throw new InvalidOperationException("Select Scene GameObjects in Hierarchy.");
        var stage = PrefabStageUtility.GetCurrentPrefabStage();
        foreach (GameObject obj in objects)
        {
            if (EditorUtility.IsPersistent(obj) || !obj.scene.IsValid() || !obj.scene.isLoaded ||
                EditorSceneManager.IsPreviewSceneObject(obj) ||
                (stage != null && obj.scene == stage.scene) || PrefabUtility.IsPartOfAnyPrefab(obj))
                throw new InvalidOperationException("Only ordinary Scene objects are supported: " + obj.name);
        }
        return objects;
    }

    public static void Change(string name, Action action)
    {
        Undo.IncrementCurrentGroup();
        int group = Undo.GetCurrentGroup();
        Undo.SetCurrentGroupName(name);
        try { action(); Undo.CollapseUndoOperations(group); }
        catch { Undo.RevertAllDownToGroup(group); throw; }
    }
}

public static class CgmRemoveOutline
{
    [MenuItem("Tools/CG Method/Remove Selected UI Outlines")]
    private static void Remove()
    {
        try
        {
            GameObject[] objects = CgmSceneSelection.Get();
            int removed = 0;
            CgmSceneSelection.Change("Remove UI Outlines", () =>
            {
                foreach (GameObject obj in objects)
                    foreach (Outline outline in obj.GetComponents<Outline>())
                    { Undo.DestroyObjectImmediate(outline); removed++; }
            });
            Debug.Log("Removed UI Outline components: " + removed);
        }
        catch (Exception e) { Debug.LogException(e); }
    }
}

using System;
using UnityEditor;
using UnityEngine;

// Also requires CgmSceneSelection from CgmRemoveOutline.cs.
public class CgmAssignMaterial : EditorWindow
{
    private Material material;

    [MenuItem("Tools/CG Method/Assign First Renderer Material")]
    private static void Open() { GetWindow<CgmAssignMaterial>("Assign Material"); }

    private void OnGUI()
    {
        EditorGUILayout.HelpBox("Select ordinary Scene objects. Only material slot 0 changes.", MessageType.Info);
        material = (Material)EditorGUILayout.ObjectField("Material Asset", material, typeof(Material), false);
        if (GUILayout.Button("Assign To Selected Renderers")) Assign();
    }

    private void Assign()
    {
        try
        {
            if (material == null || !EditorUtility.IsPersistent(material))
                throw new InvalidOperationException("Choose a saved Material asset.");
            GameObject[] objects = CgmSceneSelection.Get();
            foreach (GameObject obj in objects)
            {
                Renderer renderer = obj.GetComponent<Renderer>();
                if (renderer == null || renderer.sharedMaterials.Length == 0)
                    throw new InvalidOperationException("Renderer with a material slot is required: " + obj.name);
            }
            CgmSceneSelection.Change("Assign Material", () =>
            {
                foreach (GameObject obj in objects)
                {
                    Renderer renderer = obj.GetComponent<Renderer>();
                    Undo.RecordObject(renderer, "Assign Material");
                    Material[] slots = renderer.sharedMaterials;
                    slots[0] = material;
                    renderer.sharedMaterials = slots;
                }
            });
            Debug.Log("Updated Renderer slot 0: " + objects.Length);
        }
        catch (Exception e) { Debug.LogException(e); }
    }
}

using System;
using System.IO;
using UnityEditor;
using UnityEngine;

public static class CgmScreenshotPath
{
    public static string Validate(string path)
    {
        if (string.IsNullOrWhiteSpace(path) || !Path.IsPathRooted(path))
            throw new ArgumentException("An absolute PNG path is required.");
        string full = Path.GetFullPath(path);
        if (!string.Equals(Path.GetExtension(full), ".png", StringComparison.OrdinalIgnoreCase))
            throw new ArgumentException("Use the .png extension.");
        if (!Directory.Exists(Path.GetDirectoryName(full)))
            throw new DirectoryNotFoundException("Choose an existing output directory.");
        if (File.Exists(full) || Directory.Exists(full))
            throw new IOException("Choose a new output filename.");
        return full;
    }
}

// Assets/Editor/CgmCaptureGameView.cs
public static class CgmCaptureGameView
{
    [MenuItem("Tools/CG Method/Request Game View PNG")]
    private static void Capture()
    {
        if (!EditorApplication.isPlaying || EditorApplication.isPaused)
        { Debug.LogWarning("Run Play Mode, unpause, and render the Game view first."); return; }
        string path = EditorUtility.SaveFilePanel("New Game View PNG", "",
            DateTime.Now.ToString("yyyyMMdd-HHmmss-fff"), "png");
        if (string.IsNullOrEmpty(path)) return;
        try
        {
            path = CgmScreenshotPath.Validate(path);
            ScreenCapture.CaptureScreenshot(path, 1);
            Debug.Log("PNG capture requested. Check the file after rendering: " + path);
        }
        catch (Exception e) { Debug.LogException(e); }
    }
}

using System;
using System.Linq;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;

// Also requires CgmSceneSelection from CgmRemoveOutline.cs.
public static class CgmGroupSelected
{
    [MenuItem("Tools/CG Method/Group Selected Siblings")]
    private static void Group()
    {
        try
        {
            GameObject[] objects = CgmSceneSelection.Get();
            Transform[] selected = objects.Select(o => o.transform).OrderBy(t => t.GetSiblingIndex()).ToArray();
            Transform parent = selected[0].parent;
            Scene scene = selected[0].gameObject.scene;
            foreach (Transform t in selected)
            {
                if (t is RectTransform || t.parent != parent || t.gameObject.scene != scene)
                    throw new InvalidOperationException("Select non-UI siblings in the same Scene.");
            }
            for (Transform t = parent; t != null; t = t.parent)
                if (t.localScale != Vector3.one)
                    throw new InvalidOperationException("Scaled ancestors are outside this example's scope.");
            int firstIndex = selected[0].GetSiblingIndex();
            CgmSceneSelection.Change("Group Selected Siblings", () =>
            {
                GameObject group = new GameObject("Group");
                SceneManager.MoveGameObjectToScene(group, scene);
                Undo.RegisterCreatedObjectUndo(group, "Group Selected Siblings");
                Undo.SetTransformParent(group.transform, parent, "Group Selected Siblings");
                Undo.RecordObject(group.transform, "Group Selected Siblings");
                group.transform.localPosition = Vector3.zero;
                group.transform.localRotation = Quaternion.identity;
                group.transform.localScale = Vector3.one;
                Undo.SetSiblingIndex(group.transform, firstIndex, "Group Selected Siblings");
                for (int i = 0; i < selected.Length; i++)
                {
                    Undo.SetTransformParent(selected[i], group.transform, "Group Selected Siblings");
                    Undo.SetSiblingIndex(selected[i], i, "Group Selected Siblings");
                }
                Selection.activeGameObject = group;
            });
        }
        catch (Exception e) { Debug.LogException(e); }
    }
}

{
  "name": "com.cgmethod.editor-tools",
  "version": "0.1.0",
  "displayName": "CG Method Editor Tools",
  "unity": "6000.3",
  "description": "Scene selection examples; Unity Editor runtime validation pending.",
  "dependencies": {
    "com.unity.ugui": "2.0.0"
  }
}

{
  "name": "CGMethod.EditorTools",
  "references": ["Unity.ugui"],
  "includePlatforms": ["Editor"],
  "autoReferenced": true
}