编辑模式下基于预制体生成GameObject并初始化Node对象的实现方法问询

Absolutely, your goal is totally achievable in Unity—let me walk you through exactly how to pull this off, including whether ScriptableObjects are a good fit here.

First things first: this is 100% doable in Unity's edit mode. You don't have to limit yourself to runtime instantiation—Unity's Editor API gives you full control to build tools that modify scenes, generate objects, and link data while you're working in the editor.

Step 1: Set Up Edit-Mode Tooling #

To build edit-mode functionality, you'll work with Unity's Editor namespace. Start by creating a custom editor window or menu item to trigger your node generation logic. All edit-mode code should live in an Editor folder (or be wrapped in #if UNITY_EDITOR directives) to avoid being included in builds.

Here's a basic example of an editor window for your node tools:

using UnityEditor;
using UnityEngine;
using UnityEditor.SceneManagement;

public class NodeGraphToolWindow : EditorWindow
{
    [MenuItem("Tools/Node Graph Generator")]
    public static void OpenToolWindow()
    {
        GetWindow<NodeGraphToolWindow>("Node Graph Generator");
    }

    private GameObject _nodePrefab;
    // Assume you have a reference to your existing Node graph data
    private YourNodeGraphType _nodeGraph;

    private void OnGUI()
    {
        // Let the user select a prefab to use for nodes
        _nodePrefab = (GameObject)EditorGUILayout.ObjectField(
            "Node Prefab", 
            _nodePrefab, 
            typeof(GameObject), 
            false
        );

        // Assign your existing Node graph (could also load from a ScriptableObject)
        _nodeGraph = (YourNodeGraphType)EditorGUILayout.ObjectField(
            "Node Graph Data", 
            _nodeGraph, 
            typeof(YourNodeGraphType), 
            false
        );

        if (GUILayout.Button("Generate Nodes"))
        {
            if (_nodePrefab == null || _nodeGraph == null) return;
            GenerateNodesFromGraph();
        }
    }

    private void GenerateNodesFromGraph()
    {
        // We'll fill this in next
    }
}

Step 2: Generate GameObjects & Link Node Data #

In edit mode, use PrefabUtility.InstantiatePrefab() instead of the runtime Instantiate() method—this preserves prefab links and ensures proper edit-mode behavior. You'll also want a component on each generated GameObject to store a reference to its associated Node.

First, create a runtime component to link GameObjects and Nodes:

using UnityEngine;

[Serializable]
public class NodeLinkComponent : MonoBehaviour
{
    public YourNodeType LinkedNode;
    // Add any other fields needed to initialize the GameObject from Node data
}

Then update the GenerateNodesFromGraph method in your editor window:

private void GenerateNodesFromGraph()
{
    foreach (var node in _nodeGraph.Nodes)
    {
        // Instantiate prefab in edit mode
        GameObject nodeObj = PrefabUtility.InstantiatePrefab(_nodePrefab) as GameObject;
        if (nodeObj == null) continue;

        // Configure GameObject from Node data
        nodeObj.name = $"Node_{node.ID}";
        nodeObj.transform.position = node.WorldPosition; // Use your Node's position data

        // Add/link the Node reference
        NodeLinkComponent linkComp = nodeObj.GetComponent<NodeLinkComponent>();
        if (linkComp == null) linkComp = nodeObj.AddComponent<NodeLinkComponent>();
        linkComp.LinkedNode = node;

        // Mark the object as modified so changes save
        EditorUtility.SetDirty(nodeObj);
    }

    // Mark the scene as dirty to ensure all changes are saved
    EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
}

Step 3: Support Edit-Mode Node Expansion #

To let users add/modify nodes while in edit mode, you have two great options:

1. Extend your editor window: Add buttons to create new Nodes in your graph, then auto-generate their corresponding GameObjects.
2. Build a custom inspector for NodeLinkComponent: Let users modify linked Node data or spawn new connected nodes directly from the Inspector.

Example of a custom inspector for NodeLinkComponent:

using UnityEditor;

[CustomEditor(typeof(NodeLinkComponent))]
public class NodeLinkComponentEditor : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        NodeLinkComponent linkComp = (NodeLinkComponent)target;

        if (GUILayout.Button("Spawn Connected Node"))
        {
            // Create a new Node instance
            YourNodeType newNode = new YourNodeType();
            newNode.ID = System.Guid.NewGuid().ToString();
            newNode.WorldPosition = linkComp.transform.position + Vector3.right; // Offset position

            // Add it to your graph (adjust based on how you store your Node data)
            YourNodeGraphType graph = FindObjectOfType<YourNodeGraphType>();
            graph.Nodes.Add(newNode);

            // Generate the corresponding GameObject
            GameObject newNodeObj = PrefabUtility.InstantiatePrefab(linkComp.gameObject) as GameObject;
            newNodeObj.transform.position = newNode.WorldPosition;
            NodeLinkComponent newLink = newNodeObj.GetComponent<NodeLinkComponent>();
            newLink.LinkedNode = newNode;

            // Save changes
            EditorUtility.SetDirty(graph);
            EditorUtility.SetDirty(newNodeObj);
            EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
        }
    }
}

Step 4: Are ScriptableObjects a Good Fit? #

Absolutely—they're perfect for this use case. Here's why:

• Persistent, scene-agnostic storage: Store your entire Node graph as a ScriptableObject asset, so you can reuse it across multiple scenes and keep it decoupled from scene objects.
• Easy editing & version control: ScriptableObjects are saved as assets, so you can edit Node data directly in the Inspector (with a custom editor if needed) and track changes in version control.
• Clean data separation: Keep your Node logic and data in a ScriptableObject, while GameObjects handle the visual/physical representation.

Example of a Node Graph ScriptableObject:

using UnityEngine;
using System.Collections.Generic;

[CreateAssetMenu(fileName = "New Node Graph", menuName = "Node Graph/Create Node Graph")]
public class NodeGraphSO : ScriptableObject
{
    public List<YourNodeType> Nodes = new List<YourNodeType>();
    public List<NodeConnection> Connections = new List<NodeConnection>(); // For node links
}

[Serializable]
public class NodeConnection
{
    public YourNodeType FromNode;
    public YourNodeType ToNode;
}

You can then modify your editor window to load the Node graph from this ScriptableObject instead of a scene-based component.

Key Notes #

• Ensure your YourNodeType is marked with [Serializable] so Unity can save and display it in the Inspector.
• Always use EditorUtility.SetDirty() and EditorSceneManager.MarkSceneDirty() to ensure edit-mode changes are saved.
• Keep edit-mode code separate from runtime code to avoid build errors.

内容的提问来源于stack exchange，提问作者AskingForAFriend