Try to fix imgui

.github/workflows/nuint-integration-tests.yml

@@ -2,15 +2,18 @@ name: NUnit integration test
 
 on:
   push:
+    branches: [ master ]
   pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+    branches: [ master ]
   workflow_dispatch:
 
 env:
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
 
 jobs:
-  build-windows:
+  build:
     name: Windows Build
     runs-on: windows-latest
 
@@ -20,22 +23,19 @@ jobs:
       with:
         fetch-depth: 0
 
-    - name: 🛠️ Setup Submodules
+    - name: ⚙️ Setup Submodules
       run: git submodule update --init --recursive
 
-    - name: 🛠️ Setup .NET
+    - name: ⚙️ Setup .NET
       uses: actions/setup-dotnet@v4
       with:
         dotnet-version: 8.0.x
 
-    - name: 🛠️ Install dotnet dependencies
+    - name: 📦 Install dotnet dependencies
       run: dotnet restore
 
-    - name: 🛠️ Install dotnet tools
+    - name: 📦 Install dotnet tools
       run: dotnet tool restore
 
-    - name: 🔨 Build and Test (Release)
-      run: dotnet test --configuration=Release Hypercube.UnitTests/Hypercube.UnitTests.csproj
-
-    - name: 🔨 Build and Test (Debug)
+    - name: 🛠️ Build and Test (Debug)
       run: dotnet test --configuration=Debug Hypercube.UnitTests/Hypercube.UnitTests.csproj

Hypercube.Client/Dependencies.cs

@@ -12,6 +12,7 @@
 using Hypercube.Client.Runtimes;
 using Hypercube.Client.Runtimes.Loop;
 using Hypercube.Dependencies;
+using Hypercube.ImGui;
 using Hypercube.Shared;
 using Hypercube.Shared.Runtimes;
 using Hypercube.Shared.Runtimes.Loop;

Hypercube.Client/Graphics/ImGui/Events/ImGuiRenderEvent.cs

@@ -1,4 +1,5 @@
 using Hypercube.EventBus.Events;
+using Hypercube.ImGui;
 
 namespace Hypercube.Client.Graphics.ImGui.Events;
 

Hypercube.Client/Graphics/ImGui/ImGui.cs

@@ -1,9 +1,11 @@
 using Hypercube.Client.Graphics.Events;
 using Hypercube.Client.Graphics.ImGui.Events;
 using Hypercube.Client.Graphics.Rendering;
+using Hypercube.Client.Input.Events;
 using Hypercube.Dependencies;
 using Hypercube.EventBus;
 using Hypercube.ImGui;
+using Hypercube.Input;
 using Hypercube.Shared.Logging;
 using Hypercube.Shared.Runtimes.Loop.Event;
 using JetBrains.Annotations;
@@ -23,48 +25,55 @@ public sealed class ImGui : IImGui, IEventSubscriber, IPostInject
     public void PostInject()
     {
         _eventBus.Subscribe<GraphicsLibraryInitializedEvent>(this, OnGraphicsInitialized);
+
+        _eventBus.Subscribe<InputFrameEvent>(this, OnInputFrame);
         _eventBus.Subscribe<UpdateFrameEvent>(this, OnUpdateFrame);
-        _eventBus.Subscribe<RenderDrawingEvent>(this, OnRenderDrawing);
+        _eventBus.Subscribe<RenderFrameEvent>(this, OnRenderFrame);
+
+        _eventBus.Subscribe<MouseButtonHandledEvent>(this, OnMouseButton);
+        _eventBus.Subscribe<MousePositionHandledEvent>(this, OnMousePosition);
+        _eventBus.Subscribe<ScrollHandledEvent>(this, OnInputScroll);
     }
 
+
     private void OnGraphicsInitialized(ref GraphicsLibraryInitializedEvent args)
     {
         _controller = ImGuiFactory.Create(_renderer.MainWindow);
         _controller.OnErrorHandled += message => _logger.Error(message);
 
         _controller.Initialize();
+    }    
+
+    private void OnInputFrame(ref InputFrameEvent args)
+    {
+        _controller.InputFrame();
     }
 
     private void OnUpdateFrame(ref UpdateFrameEvent args)
     {
         _controller.Update(args.DeltaSeconds);
     }
 
-    private void OnRenderDrawing(ref RenderDrawingEvent args)
+    private void OnRenderFrame(ref RenderFrameEvent args)
     {
         var ev = new ImGuiRenderEvent(this);
         _eventBus.Raise(ev);
 
         _controller.Render();
     }
-
-    public void Begin(string name)
-    {
-        _controller.Begin(name);
-    }
-
-    public void Text(string label)
+
+    private void OnMouseButton(ref MouseButtonHandledEvent args)
     {
-        _controller.Text(label);
+        _controller.UpdateMouseButtons(args.Button, args.State is KeyState.Pressed or KeyState.Held);
     }
-
-    public bool Button(string label)
+    
+    private void OnMousePosition(ref MousePositionHandledEvent args)
     {
-        return _controller.Button(label);
+        _controller.UpdateMousePosition(args.Position);
     }
 
-    public void End()
+    private void OnInputScroll(ref ScrollHandledEvent args)
     {
-        _controller.End();
+        _controller.UpdateMouseScroll(args.Offset);
     }
 }

Hypercube.Client/Graphics/Realisation/OpenGL/Rendering/Renderer.OpenGL.cs

@@ -39,13 +39,9 @@ private unsafe void InitOpenGL()
 
         GL.DebugMessageCallback(_debugProc, nint.Zero);
 
-        GL.Enable(EnableCap.Blend);
         GL.Enable(EnableCap.DebugOutput);
         GL.Enable(EnableCap.DebugOutputSynchronous);
 
-        GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
-        GL.ClearColor(0, 0, 0, 0);
-
         _loggerOpenGL.EngineInfo("Initialized");
         _eventBus.Raise(new GraphicsLibraryInitializedEvent());
     }

Hypercube.Client/Graphics/Realisation/OpenGL/Rendering/Renderer.Render.cs

@@ -26,7 +26,7 @@ public sealed partial class Renderer
 
     private int _batchVertexIndex;
     private int _batchIndexIndex; // Haha name it's fun
-    
+
     /// <summary>
     /// Contains info about currently running batch.
     /// </summary>
@@ -89,19 +89,36 @@ private void OnFrameRender(ref RenderFrameEvent args)
         Render(MainWindow);
     }
 
+    public void SetupRender()
+    {
+        GL.Enable(EnableCap.Blend);
+
+        GL.BlendEquation(BlendEquationMode.FuncAdd);
+        GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
+
+        GL.Disable(EnableCap.CullFace);
+        GL.Disable(EnableCap.ScissorTest);
+        GL.Disable(EnableCap.StencilTest);
+        GL.Disable(EnableCap.PrimitiveRestart);
+
+        GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
+
+        GL.ClearColor(0, 0, 0, 0);
+    }
+
     public void Render(WindowHandle window)
     {
         Clear();
 
         GL.Viewport(window.Size);
-        GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
 
         var args = new RenderDrawingEvent();
         _eventBus.Raise(ref args);
 
         // break batch so we get all batches
         BreakCurrentBatch();
-
+        SetupRender();
+
         _vao.Bind();
         _vbo.SetData(_batchVertices);
         _ebo.SetData(_batchIndices);
@@ -116,6 +133,8 @@ public void Render(WindowHandle window)
         _ebo.Unbind();
 
         _windowManager.WindowSwapBuffers(window);
+
+        GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
     }
 
     public void Clear()

Hypercube.Client/Graphics/Windows/Realisation/GLFW/GlfwWindowManager.Callbacks.cs

@@ -23,6 +23,7 @@ public sealed unsafe partial class GlfwWindowManager
     private ScrollCallback? _scrollCallback;
     private KeyCallback? _keyCallback;
     private MouseButtonCallback? _mouseButtonCallback;
+    private CursorPosCallback? _cursorPosCallback;
 
     private WindowCloseCallback? _windowCloseCallback;
     private WindowSizeCallback? _windowSizeCallback;
@@ -41,7 +42,8 @@ private void HandleCallbacks()
         _scrollCallback = OnWindowScrollHandled;
         _keyCallback = OnWindowKeyHandled;
         _mouseButtonCallback = OnMouseButtonHandled;
-
+        _cursorPosCallback = OnCursorPositionHandled;
+
         _windowCloseCallback = OnWindowClosed;
         _windowSizeCallback = OnWindowResized;
         _windowFocusCallback = OnWindowFocusChanged;
@@ -83,6 +85,11 @@ private void OnMouseButtonHandled(Window* window, GlfwMouseButton button, InputA
         ));
     }
 
+    private void OnCursorPositionHandled(Window* window, double x, double y)
+    {
+        RaiseInput(new WindowingCursorPositionHandledEvent(x, y));
+    }
+
     private void RaiseInput<T>(T args) where T : IEventArgs
     {
         _eventBus.Raise(_inputHandler, ref args);

Hypercube.Client/Graphics/Windows/Realisation/GLFW/GlfwWindowManager.Window.cs

@@ -134,11 +134,16 @@ private WindowRegistration WindowSetup(Window* window, WindowCreateSettings sett
             WindowSetIcons(handle, settings.WindowImages.ToList());
 
         // Setting callbacks
-        GLFW.SetKeyCallback(window, _keyCallback);
         GLFW.SetWindowCloseCallback(window, _windowCloseCallback);
         GLFW.SetWindowSizeCallback(window, _windowSizeCallback);
         GLFW.SetWindowFocusCallback(window, _windowFocusCallback);
 
+        GLFW.SetCharCallback(window, _charCallback);
+        GLFW.SetScrollCallback(window, _scrollCallback);
+        GLFW.SetKeyCallback(window, _keyCallback);
+        GLFW.SetMouseButtonCallback(window, _mouseButtonCallback);
+        GLFW.SetCursorPosCallback(window, _cursorPosCallback);
+
         return registration;
     }
 

Hypercube.Client/Input/Events/MousePositionHandledEvent.cs

@@ -0,0 +1,14 @@
+using Hypercube.EventBus.Events;
+using Hypercube.Mathematics.Vectors;
+
+namespace Hypercube.Client.Input.Events;
+
+public sealed class MousePositionHandledEvent : IEventArgs
+{
+    public readonly Vector2 Position;
+
+    public MousePositionHandledEvent(Vector2 position)
+    {
+        Position = position;
+    }
+}

Hypercube.Client/Input/Events/Windowing/WindowingCursorPositionHandledEvent.cs

@@ -0,0 +1,20 @@
+using Hypercube.EventBus.Events;
+using Hypercube.Mathematics.Vectors;
+using JetBrains.Annotations;
+
+namespace Hypercube.Client.Input.Events.Windowing;
+
+[PublicAPI]
+public sealed class WindowingCursorPositionHandledEvent : IEventArgs
+{
+    public readonly double X;
+    public readonly double Y;
+
+    public Vector2 Position => new(X, Y);
+
+    public WindowingCursorPositionHandledEvent(double x, double y)
+    {
+        X = x;
+        Y = y;
+    }
+}

Hypercube.Client/Input/Handler/IInputHandler.cs

@@ -2,6 +2,7 @@
 using Hypercube.Client.Input.Events;
 using Hypercube.EventBus;
 using Hypercube.Input;
+using Hypercube.Mathematics.Vectors;
 using JetBrains.Annotations;
 
 namespace Hypercube.Client.Input.Handler;
@@ -13,6 +14,8 @@ namespace Hypercube.Client.Input.Handler;
 [PublicAPI]
 public interface IInputHandler : IEventSubscriber
 {
+    Vector2 MousePosition { get; }
+
     bool IsKeyState(Key key, KeyState state);
 
     /// <summary>

Hypercube.Client/Input/Handler/InputHandler.cs

@@ -4,6 +4,7 @@
 using Hypercube.Dependencies;
 using Hypercube.EventBus;
 using Hypercube.Input;
+using Hypercube.Mathematics.Vectors;
 using Hypercube.Shared.Logging;
 using Hypercube.Shared.Runtimes.Loop.Event;
 using JetBrains.Annotations;
@@ -36,12 +37,15 @@ public sealed class InputHandler : IInputHandler, IPostInject
     }.ToFrozenDictionary();
 
     private readonly Logger _logger = LoggingManager.GetLogger("input_handler");
-
+
+    public Vector2 MousePosition { get; private set; }
+
     public void PostInject()
     {
         _eventBus.Subscribe<InputFrameEvent>(this, OnInputFrameUpdate);
 
         _eventBus.Subscribe<WindowingCharHandledEvent>(this, OnCharHandled);
+        _eventBus.Subscribe<WindowingCursorPositionHandledEvent>(this, OnCursorPositionHandled);
         _eventBus.Subscribe<WindowingKeyHandledEvent>(this, OnKeyHandled);
         _eventBus.Subscribe<WindowingMouseButtonHandledEvent>(this, OnMouseButtonHandled);
         _eventBus.Subscribe<WindowingScrollHandledEvent>(this, OnScrollHandled);
@@ -74,6 +78,14 @@ private void OnCharHandled(ref WindowingCharHandledEvent args)
         _eventBus.Raise(ev);
     }
 
+    private void OnCursorPositionHandled(ref WindowingCursorPositionHandledEvent args)
+    {
+        MousePosition = args.Position;
+
+        var ev = new MousePositionHandledEvent(args.Position);
+        _eventBus.Raise(ev);
+    }
+
     private void OnKeyHandled(ref WindowingKeyHandledEvent args)
     {
 #if DEBUG
@@ -100,7 +112,7 @@ private void OnKeyHandled(ref WindowingKeyHandledEvent args)
 
             case KeyState.Released:
                 _keys[KeyState.Held].Remove(args.Key);
-                _keys[KeyState.Pressed].Add(args.Key);
+                _keys[KeyState.Released].Add(args.Key);
                 break;
 
             default:
@@ -134,7 +146,7 @@ private void OnMouseButtonHandled(ref WindowingMouseButtonHandledEvent args)
 
             case KeyState.Released:
                 _mouseButtons[KeyState.Held].Remove(args.Button);
-                _mouseButtons[KeyState.Pressed].Add(args.Button);
+                _mouseButtons[KeyState.Released].Add(args.Button);
                 break;
 
             default:
@@ -149,7 +161,7 @@ private void OnScrollHandled(ref WindowingScrollHandledEvent args)
         var ev = new ScrollHandledEvent(args.Offset);
         _eventBus.Raise(ev);
     }
-
+    
     public bool IsKeyState(Key key, KeyState state)
     {
         return _keys[state].Contains(key);