Merge remote-tracking branch 'origin/egui-input' into egui_with_backend_temp

Author: Kryptos-FR

src/gfx/egui/CMakeLists.txt

@@ -9,6 +9,7 @@ endif()
 add_library(gfx_egui
   egui_types.cpp
   renderer.cpp
+  input.cpp
 )
 target_link_libraries(gfx_egui gfx)
 

src/gfx/egui/build.rs

@@ -11,6 +11,7 @@ fn main() {
 
     let bindings = builder
         .header("rust_interop.hpp")
+        .allowlist_type("egui::.*")
         .size_t_is_usize(true)
         .layout_tests(false)
         .generate()

src/gfx/egui/egui_types.hpp

@@ -32,9 +32,143 @@ struct Vertex {
 #endif
 };
 
+struct TouchDeviceId {
+  uint64_t id;
+  operator uint64_t() const { return id; }
+};
+
+struct TouchId {
+  uint64_t id;
+  operator uint64_t() const { return id; }
+};
+
+enum class InputEventType : uint8_t {
+  Copy,
+  Cut,
+  Paste,
+  Text,
+  Key,
+  PointerMoved,
+  PointerButton,
+  PointerGone,
+  Scroll,
+  Zoom,
+  CompositionStart,
+  CompositionUpdate,
+  CompositionEnd,
+  Touch
+};
+
+enum class TouchPhase : uint8_t {
+  Start,
+  Move,
+  End,
+  Cancel,
+};
+
+enum class PointerButton : uint8_t {
+  Primary = 0,
+  Secondary = 1,
+  Middle = 2,
+};
+
+struct ModifierKeys {
+  bool alt;
+  bool ctrl;
+  bool shift;
+  bool macCmd;
+  bool command;
+};
+
+union InputEvent {
+  struct {
+    InputEventType type;
+  } common;
+  struct {
+    InputEventType type;
+  } copy;
+  struct {
+    InputEventType type;
+  } cut;
+  struct {
+    InputEventType type;
+    const char *str;
+  } paste;
+  struct {
+    InputEventType type;
+    const char *str;
+  } text;
+  struct {
+    InputEventType type;
+    Pos2 pos;
+  } pointerMoved;
+  struct {
+    InputEventType type;
+    Pos2 pos;
+    PointerButton button;
+    bool pressed;
+    ModifierKeys modifiers;
+  } pointerButton;
+  struct {
+    InputEventType type;
+  } pointerGone;
+  struct {
+    InputEventType type;
+    Pos2 delta;
+  } scroll;
+  struct {
+    InputEventType type;
+    float delta;
+  } zoom;
+  struct {
+    InputEventType type;
+  } compositionStart;
+  struct {
+    InputEventType type;
+    const char *text;
+  } compositionUpdate;
+  struct {
+    InputEventType type;
+    const char *text;
+  } compositionEnd;
+  struct {
+    InputEventType type;
+    TouchDeviceId deviceId;
+    TouchId id;
+    TouchPhase phase;
+    Pos2 pos;
+    float force;
+  } touch;
+};
+
+struct HoveredFile {
+  const char *path;
+  const char *mime;
+};
+
+struct DroppedFile {
+  const char *path;
+  const char *name;
+  const char *lastModified; // ISO 8601 timestamp / strftime("%FT%TZ")
+  const uint8_t *data;
+  size_t dataLength;
+};
+
 struct Input {
-  int cursorPosition[2];
-  bool mouseButton{};
+  Rect screenRect;
+  float pixelsPerPoint;
+  double time;
+  float predictedDeltaTime;
+  ModifierKeys modifierKeys;
+
+  const InputEvent *inputEvents;
+  size_t numInputEvents;
+
+  const HoveredFile *hoveredFiles;
+  size_t numHoveredFiles;
+
+  const DroppedFile *droppedFiles;
+  size_t numDroppedFiles;
 };
 
 struct TextureId {

src/gfx/egui/input.cpp

@@ -0,0 +1,99 @@
+#include "input.hpp"
+#include "../linalg.hpp"
+#include <SDL_events.h>
+#include <gfx/window.hpp>
+#include "renderer.hpp"
+
+namespace gfx {
+const egui::Input *EguiInputTranslator::translateFromInputEvents(const std::vector<SDL_Event>& sdlEvents, Window &window, double time,
+                                                                 float deltaTime) {
+  using egui::InputEvent;
+  using egui::InputEventType;
+
+  float drawScale = EguiRenderer::getDrawScale(window);
+  float2 screenSize = window.getDrawableSize() / drawScale;
+
+  input.screenRect = egui::Rect{
+      .min = egui::Pos2{0, 0},
+      .max = egui::Pos2{screenSize.x, screenSize.y},
+  };
+  input.pixelsPerPoint = drawScale;
+
+  events.clear();
+  auto newEvent = [&](egui::InputEventType type) -> InputEvent & {
+    InputEvent &event = events.emplace_back();
+    event.common.type = type;
+    return event;
+  };
+
+  SDL_Keymod sdlModifierKeys = SDL_GetModState();
+  egui::ModifierKeys modifierKeys{
+      .alt = (sdlModifierKeys & KMOD_ALT) != 0,
+      .ctrl = (sdlModifierKeys & KMOD_CTRL) != 0,
+      .shift = (sdlModifierKeys & KMOD_SHIFT) != 0,
+      .macCmd = (sdlModifierKeys & KMOD_GUI) != 0,
+      .command = (sdlModifierKeys & KMOD_GUI) != 0,
+  };
+
+  auto updateCursorPosition = [&](int32_t x, int32_t y) -> const egui::Pos2 & {
+    float2 virtualCursorPosition = float2(x, y) / drawScale;
+    return lastCursorPosition = egui::Pos2{.x = virtualCursorPosition.x, .y = virtualCursorPosition.y};
+  };
+
+  for (auto &sdlEvent : sdlEvents) {
+    switch (sdlEvent.type) {
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEBUTTONUP: {
+      auto &ievent = sdlEvent.button;
+      auto &oevent = newEvent(InputEventType::PointerButton).pointerButton;
+      switch (ievent.button) {
+      case SDL_BUTTON_LEFT:
+        oevent.button = egui::PointerButton::Primary;
+        break;
+      case SDL_BUTTON_MIDDLE:
+        oevent.button = egui::PointerButton::Middle;
+        break;
+      case SDL_BUTTON_RIGHT:
+        oevent.button = egui::PointerButton::Secondary;
+        break;
+      default:
+        // ignore this button
+        events.pop_back();
+        continue;
+        break;
+      }
+      oevent.pressed = ievent.type == SDL_MOUSEBUTTONDOWN;
+      oevent.modifiers = modifierKeys;
+      oevent.pos = updateCursorPosition(ievent.x, ievent.y);
+    }
+    case SDL_MOUSEMOTION: {
+      auto &ievent = sdlEvent.motion;
+      auto &oevent = newEvent(InputEventType::PointerMoved).pointerMoved;
+      oevent.pos = updateCursorPosition(ievent.x, ievent.y);
+      break;
+    }
+    case SDL_MOUSEWHEEL: {
+      auto &ievent = sdlEvent.wheel;
+      auto &oevent = newEvent(InputEventType::Scroll).scroll;
+      oevent.delta = egui::Pos2{
+          .x = float(ievent.preciseX),
+          .y = float(ievent.preciseY),
+      };
+      break;
+    }
+    }
+  }
+
+  input.inputEvents = events.data();
+  input.numInputEvents = events.size();
+
+  input.numDroppedFiles = 0;
+  input.numHoveredFiles = 0;
+
+  input.time = time;
+  input.predictedDeltaTime = deltaTime;
+  input.modifierKeys = modifierKeys;
+
+  return &input;
+}
+} // namespace gfx

src/gfx/egui/input.hpp

@@ -0,0 +1,22 @@
+#ifndef CA4EC896_C746_4AC6_A229_560CF01EEFEA
+#define CA4EC896_C746_4AC6_A229_560CF01EEFEA
+
+#include "egui_types.hpp"
+#include <vector>
+
+namespace gfx {
+struct Window;
+/// <div rustbindgen opaque></div>
+struct EguiInputTranslator {
+private:
+  egui::Input input;
+  std::vector<std::string> strings;
+  std::vector<egui::InputEvent> events;
+  egui::Pos2 lastCursorPosition;
+
+public:
+  const egui::Input* translateFromInputEvents(const std::vector<SDL_Event>& sdlEvents, Window& window, double time, float deltaTime);
+};
+} // namespace gfx
+
+#endif /* CA4EC896_C746_4AC6_A229_560CF01EEFEA */

src/gfx/egui/renderer.cpp

@@ -193,4 +193,8 @@ void EguiRenderer::render(const egui::FullOutput &output, const gfx::DrawQueuePt
 
 EguiRenderer *EguiRenderer::create() { return new EguiRenderer(); }
 void EguiRenderer::destroy(EguiRenderer *renderer) { delete renderer; }
+float EguiRenderer::getDrawScale(Window &window) {
+  float2 drawScaleVec = window.getDrawScale();
+  return std::max<float>(drawScaleVec.x, drawScaleVec.y);
+}
 } // namespace gfx

src/gfx/egui/renderer.hpp

@@ -6,6 +6,7 @@
 #include <memory>
 
 namespace gfx {
+struct Window;
 struct EguiRendererImpl;
 
 /// <div rustbindgen opaque></div>
@@ -18,6 +19,8 @@ struct EguiRenderer {
 
   static EguiRenderer *create();
   static void destroy(EguiRenderer *renderer);
+
+  static float getDrawScale(Window& window);
 };
 
 } // namespace gfx

src/gfx/egui/rust_interop.hpp

@@ -4,5 +4,6 @@
 #include "../rust_interop.hpp"
 #include "egui_types.hpp"
 #include "renderer.hpp"
+#include "input.hpp"
 
 #endif /* D51F59C5_BA16_47C5_B59B_0C4D8273CADB */

src/gfx/egui/src/color_test.rs

@@ -107,7 +107,7 @@ impl ColorTest {
         }
 
         ui.separator();
-        /*
+
         self.show_gradients(ui, BLACK, (BLACK, WHITE));
         ui.separator();
         self.show_gradients(ui, WHITE, (BLACK, TRANSPARENT));
@@ -128,7 +128,7 @@ impl ColorTest {
 
         ui.separator();
 
-        blending_and_feathering_test(ui); */
+        blending_and_feathering_test(ui);
     }
 
     fn show_gradients(&mut self, ui: &mut Ui, bg_fill: Color32, (left, right): (Color32, Color32)) {