lingua-engine/plugins/engine.editor/Engine.Editor/EditorPlugin.cs

using Engine.Editor.Contracts;
using Engine.Input.Contracts;
using Engine.Kernel.Diagnostics;
using Engine.Kernel.Plugins;
using Engine.Kernel.Scheduling;
using Engine.Kernel.World;
using Engine.Render.Contracts;
using Engine.Windowing.Contracts;
using ImGuiNET;
using Silk.NET.OpenGL;
using Silk.NET.OpenGL.Extensions.ImGui;

namespace Engine.Editor;

/// <summary>
/// M3's editor shell: an ImGui overlay drawn on top of the running scene.
/// Registers on Stage.Render, after engine.render's own Draw (per
/// project.json's plugin order) so it paints into the same back buffer the
/// scene just drew into — and before Stage.Present's SwapBuffers, so the
/// UI isn't delayed a frame. See Stage.Present's doc comment for why that
/// split exists at all.
///
/// Nothing here reads or writes a Component through GetComponent/Query —
/// HierarchyPanel walks IWorld.Roots/GameObject.Children directly, and the
/// not-yet-built Inspector will walk GameObject.Components the same way —
/// which is why this plugin never needs to declare Reads/Writes on its
/// system: those checks only guard the typed accessors, not plain property
/// reads. See GameObject.AddComponent's own doc comment on the same gap.
/// </summary>
public sealed class EditorPlugin : IPlugin
{
    private readonly EditorState _state = new();
    private readonly TranslateGizmo _gizmo = new();
    private GL? _gl;
    private ImGuiController? _controller;
    private ITime? _time;
    private PlayModeController? _playMode;
    private IEngineWindow? _window;
    private ICameraService? _camera;
    private bool _wasPlaying;

    public void Configure(IPluginContext ctx)
    {
        var window = ctx.Services.Require<IEngineWindow>();
        var input = ctx.Services.Require<IEngineInput>();
        _time = ctx.Time;
        _window = window;
        _camera = ctx.Services.Require<ICameraService>();

        window.Native.GLContext!.MakeCurrent();
        _gl = window.Native.CreateOpenGL();
        _controller = new ImGuiController(_gl, window.Native, input.Native);

        _playMode = new PlayModeController(ctx.World, ctx.Log);
        ctx.Services.Provide<IPlayModeController>(_playMode);

        ctx.Schedule.Add(Stage.Render, DrawUi);
        ctx.Log.Info("editor UI ready (ImGui)");
    }

    public void Shutdown(IPluginContext ctx)
    {
        ctx.Schedule.RemoveAllFrom("engine.editor");
        ctx.Services.Revoke<IPlayModeController>();
        _controller?.Dispose();
        _gl?.Dispose();
        _controller = null;
        _gl = null;
        _time = null;
        _playMode = null;
        _window = null;
        _camera = null;
    }

    private void DrawUi(IWorld world)
    {
        _controller!.Update(_time!.DeltaTime);

        // Nothing selected yet and there's something to select: default to
        // the first root rather than opening on an empty, useless
        // Inspector. Only fires once — any real click overwrites it, and
        // it never fights a deliberate deselect because there's no way to
        // deselect yet.
        if (_state.Selected is null && world.Roots.Count > 0)
            _state.Selected = world.Roots[0];

        // FirstUseEver, not every frame: a real editor session lets the
        // user drag panels wherever they want, and re-forcing a position
        // every frame would fight that the moment they did. This only
        // picks a sane, non-overlapping default before ImGui has ever
        // seen these windows (or after Reset Layout, once that exists).
        ImGui.SetNextWindowPos(new(10, 10), ImGuiCond.FirstUseEver);
        ImGui.SetNextWindowSize(new(220, 90), ImGuiCond.FirstUseEver);
        ImGui.Begin("Lingua Editor");
        ImGui.Text($"FPS: {1f / MathF.Max(_time.DeltaTime, 0.0001f):F0}");
        ImGui.Text($"Frame: {_time.FrameCount}");
        ImGui.Separator();

        if (ImGui.Button(_playMode!.IsPlaying ? "Stop" : "Play"))
        {
            if (_playMode.IsPlaying)
                _playMode.ExitPlay();
            else
                _playMode.EnterPlay();
        }

        ImGui.SameLine();
        ImGui.Text(_playMode.IsPlaying ? "(Playing)" : "(Edit mode)");
        ImGui.End();

        // Found by independent review: ExitPlay's Restore destroys every
        // GameObject and rebuilds fresh instances from the snapshot, but
        // EditorState.Selected kept pointing at the old, now-detached one
        // — Inspector and the gizmo would silently keep editing an object
        // no longer in the world. Comparing against last frame's own
        // IsPlaying (not just reacting to the button above) catches this
        // uniformly regardless of *how* Play exited — the Stop button
        // here, or the "stop" stdin command Engine.Host already processed
        // before this Render-stage system ran this frame; the button
        // alone would miss the second path entirely, the same
        // stdin-vs-real-control gap already hit once this session.
        if (_wasPlaying && !_playMode.IsPlaying)
        {
            var previousName = _state.Selected?.Name;
            _state.Selected = previousName is null ? null : FindByName(world.Roots, previousName);
        }
        _wasPlaying = _playMode.IsPlaying;

        HierarchyPanel.Draw(world, _state);
        InspectorPanel.Draw(_state);
        _gizmo.Draw(_state, _camera!, _window!);

        _controller.Render();
    }

    // Best-effort by name, not identity — Restore rebuilds fresh
    // GameObject instances, so there's no identity to match against
    // anymore. Two siblings sharing a name (nothing stops it, same caveat
    // HierarchyPanel's own PushID-by-hashcode already documents) means
    // this picks the first match, not necessarily "the same one" — an
    // acceptable approximation for reselecting after Play, not a
    // guarantee.
    private static GameObject? FindByName(IReadOnlyList<GameObject> roots, string name)
    {
        foreach (var go in roots)
        {
            if (go.Name == name)
                return go;

            var found = FindByName(go.Children, name);
            if (found is not null)
                return found;
        }

        return null;
    }
}