90 lines
4.4 KiB
C#
90 lines
4.4 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Unity.Pipeline.Config;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace Unity.Pipeline.Editor
|
|
{
|
|
/// <summary>
|
|
/// Project Settings UI for the runtime Pipeline configuration (Project Settings > Pipeline >
|
|
/// Runtime). This is the only editing surface for RuntimePipelineConfig — the config is never
|
|
/// a saved asset, so there's nothing to click on in the Project window. This is the primary,
|
|
/// discoverable UI for what used to require manually adding a RuntimePipelineManager
|
|
/// component to a scene.
|
|
/// </summary>
|
|
static class RuntimePipelineSettingsProvider
|
|
{
|
|
/// <summary>
|
|
/// Load the current settings, or a fresh in-memory default instance if none have been
|
|
/// authored yet. Deliberately does NOT persist that default: merely viewing this page, or
|
|
/// reading via get_runtime_pipeline_settings, must never have the side effect of writing to
|
|
/// disk. The caller owns the returned instance and must DestroyImmediate it when done, same
|
|
/// as RuntimePipelineConfig.Load().
|
|
/// </summary>
|
|
public static RuntimePipelineConfig LoadOrCreateConfig() =>
|
|
RuntimePipelineConfig.Load() ?? ScriptableObject.CreateInstance<RuntimePipelineConfig>();
|
|
|
|
[SettingsProvider]
|
|
public static SettingsProvider CreateSettingsProvider()
|
|
{
|
|
RuntimePipelineConfig config = null;
|
|
UnityEditor.Editor editor = null;
|
|
DateTime loadedWriteTimeUtc = default;
|
|
|
|
void Reload()
|
|
{
|
|
if (editor != null)
|
|
UnityEngine.Object.DestroyImmediate(editor);
|
|
if (config != null)
|
|
UnityEngine.Object.DestroyImmediate(config);
|
|
config = LoadOrCreateConfig();
|
|
editor = UnityEditor.Editor.CreateEditor(config, typeof(RuntimePipelineConfigEditor));
|
|
// DateTime.MinValue (no settings file yet) is a stable value here, not a moving
|
|
// target: GetSettingsFileWriteTimeUtc() keeps returning MinValue on every repaint
|
|
// until an actual edit below calls config.Save(), so LoadOrCreateConfig() no longer
|
|
// persisting a default does not cause a reload loop.
|
|
loadedWriteTimeUtc = RuntimePipelineConfig.GetSettingsFileWriteTimeUtc();
|
|
}
|
|
|
|
return new SettingsProvider("Project/Pipeline/Runtime", SettingsScope.Project)
|
|
{
|
|
label = "Runtime",
|
|
activateHandler = (_, __) => Reload(),
|
|
deactivateHandler = () =>
|
|
{
|
|
if (editor != null)
|
|
UnityEngine.Object.DestroyImmediate(editor);
|
|
if (config != null)
|
|
UnityEngine.Object.DestroyImmediate(config);
|
|
editor = null;
|
|
config = null;
|
|
},
|
|
guiHandler = _ =>
|
|
{
|
|
// Reload whenever our cached state can no longer be trusted:
|
|
// - config == null: entering/exiting Play Mode destroyed it out from under the
|
|
// cached Editor without deactivateHandler running first (Unity purges loose,
|
|
// non-persisted ScriptableObjects around the Play Mode transition). Unity's
|
|
// Object == overload treats a destroyed native object as null even though the
|
|
// C# reference is not.
|
|
// - the file's write-time moved since we last loaded/saved it: something else
|
|
// wrote to it directly — a build's "Disable Pipeline" security-dialog choice,
|
|
// or a set_runtime_pipeline_settings CLI call — so our in-memory copy is stale.
|
|
if (config == null || RuntimePipelineConfig.GetSettingsFileWriteTimeUtc() != loadedWriteTimeUtc)
|
|
Reload();
|
|
|
|
EditorGUI.BeginChangeCheck();
|
|
editor.OnInspectorGUI();
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
config.Save();
|
|
loadedWriteTimeUtc = RuntimePipelineConfig.GetSettingsFileWriteTimeUtc();
|
|
}
|
|
},
|
|
keywords = new HashSet<string>(new[] { "Pipeline", "Runtime", "Code Reload", "Server", "CLI" })
|
|
};
|
|
}
|
|
}
|
|
}
|