add queueing system to fix AI generated control slop. works for movement. need to replace hotkeys and such

Author: collinalexbell

include/WindowManager/WindowManager.h

@@ -59,6 +59,7 @@ class WindowManagerInterface
   virtual void createAndRegisterApps(char** envp) = 0;
   virtual optional<entt::entity> getCurrentlyFocusedApp() = 0;
   virtual optional<entt::entity> getPendingFocusedApp() = 0;
+  virtual bool hasCurrentOrPendingFocus() = 0;
   virtual void focusApp(entt::entity) = 0;
   virtual void wire(shared_ptr<WindowManagerInterface>, Camera* camera, Renderer* renderer) = 0;
   virtual void handleSubstructure() = 0;
@@ -179,6 +180,7 @@ class WindowManager : public WindowManagerInterface
   ~WindowManager();
   optional<entt::entity> getCurrentlyFocusedApp() override;
   optional<entt::entity> getPendingFocusedApp() override { return pendingFocusedApp; }
+  bool hasCurrentOrPendingFocus() override; 
   void focusApp(entt::entity) override;
   void wire(WindowManagerPtr sharedThis, Camera* camera, Renderer* renderer) override;
   void handleSubstructure() override;

include/controls.h

@@ -1,13 +1,15 @@
 #pragma once
 
-#include "blocks.h"
-#include "camera.h"
 #include <functional>
 #include <mutex>
+#include <queue>
+#include <unordered_set>
 #include <glad/glad.h>
 #include <GLFW/glfw3.h>
 #include <xkbcommon/xkbcommon.h>
 #include <memory>
+#include "blocks.h"
+#include "camera.h"
 #include "app.h"
 #include "world.h"
 #include "WindowManager/WindowManager.h"
@@ -54,7 +56,16 @@ class Controls
   shared_ptr<WindowManager::Space> windowManagerSpace;
   bool keysEnabled = true;
 
-  void handleControls(GLFWwindow* window, Camera* camera);
+  std::unordered_set<xkb_keysym_t> pressed;
+
+  struct KeysymEvent {
+    xkb_keysym_t sym;
+    bool pressed;
+  };
+  std::queue<KeysymEvent> keysymQueue;
+  std::mutex keysymMutex;
+
+  void handleMovement();
   void handleQuit(GLFWwindow* window);
   void handleModEscape(GLFWwindow* window);
   void handleToggleCursor(GLFWwindow* window);
@@ -75,6 +86,7 @@ class Controls
   void handleMakeWindowBootable(GLFWwindow* window);
 
   void handleKeys(GLFWwindow* window, Camera* camera, World* world);
+  void handleKeys();
   void handleClicks(GLFWwindow* window, World* world);
   void doAfter(shared_ptr<bool> isDone, function<void()> actionFn);
   void doDeferedActions();
@@ -95,6 +107,8 @@ class Controls
     lastWaylandFocusActive = false;
   }
   void poll(GLFWwindow* window, Camera* camera, World* world);
+  void poll();
+  void pollPressedKeys();
   void mouseCallback(GLFWwindow* window, double xpos, double ypos);
   void goToApp(entt::entity);
   void moveTo(glm::vec3 pos,

src/WindowManager/WindowManager.cpp

@@ -339,6 +339,20 @@ WindowManager::wire(WindowManagerPtr sharedThis,
   this->camera = camera;
 }
 
+bool
+WindowManager::hasCurrentOrPendingFocus()
+{
+  auto rv = false;
+  std::optional<entt::entity> focusCandidate = getPendingFocusedApp();
+  if (!focusCandidate) {
+    focusCandidate = getCurrentlyFocusedApp();
+  }
+  if (focusCandidate) {
+    rv = true;
+  }
+  return rv;
+}
+
 optional<entt::entity> WindowManager::getCurrentlyFocusedApp() {
     return currentlyFocusedApp;
  }

src/controls.cpp

@@ -57,6 +57,13 @@ Controls::mouseCallback(GLFWwindow* window, double xpos, double ypos)
   }
 }
 
+void
+Controls::poll() {
+  runQueuedActions();
+  pollPressedKeys();
+  handleKeys();
+}
+
 void
 Controls::poll(GLFWwindow* window, Camera* camera, World* world)
 {
@@ -66,13 +73,19 @@ Controls::poll(GLFWwindow* window, Camera* camera, World* world)
   doDeferedActions();
 }
 
+void Controls::handleKeys() {
+  auto appFocused = wm->hasCurrentOrPendingFocus();
+  if(!appFocused){
+    handleMovement();
+  }
+}
+
 void
 Controls::handleKeys(GLFWwindow* window, Camera* camera, World* world)
 {
   handleQuit(window);
   if (keysEnabled) {
     handleModEscape(window);
-    handleControls(window, camera);
     handleToggleCursor(window);
     handleToggleApp(window, world, camera);
     handleScreenshot(window);
@@ -254,13 +267,13 @@ Controls::handleClicks(GLFWwindow* window, World* world)
 }
 
 void
-Controls::handleControls(GLFWwindow* window, Camera* camera)
+Controls::handleMovement()
 {
 
-  bool up = glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS;
-  bool down = glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS;
-  bool left = glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS;
-  bool right = glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS;
+  bool up = pressed.count(XKB_KEY_w) > 0;
+  bool down = pressed.count(XKB_KEY_s) > 0;
+  bool left = pressed.count(XKB_KEY_a) > 0;
+  bool right = pressed.count(XKB_KEY_d) > 0;
   camera->handleTranslateForce(up, down, left, right);
 }
 
@@ -471,19 +484,42 @@ Controls::handlePointerButton(uint32_t button, bool pressed)
   return false;
 }
 
+void Controls::pollPressedKeys() {
+  std::lock_guard<std::mutex> lock(keysymMutex);
+  KeysymEvent keysymEvent;
+  while(keysymQueue.size() > 0) {
+    keysymEvent = keysymQueue.front();
+    if(keysymEvent.pressed) {
+      pressed.insert(keysymEvent.sym); 
+    } else {
+      pressed.erase(keysymEvent.sym);
+    }
+    keysymQueue.pop();
+  }
+}
+
 ControlResponse
 Controls::handleKeySym(xkb_keysym_t sym,
-                       bool pressed,
+                       bool is_pressed,
                        bool modifierHeld,
                        bool shiftHeld,
                        bool waylandFocusActive)
 {
-  ControlResponse resp;
+
+  {
+    std::lock_guard<std::mutex> lock(keysymMutex);
+    keysymQueue.push(KeysymEvent{sym, is_pressed});
+  }
+
+
   lastWaylandFocusActive = waylandFocusActive;
-  if (!pressed) {
+  ControlResponse resp;
+  if (!is_pressed) {
     return resp;
   }
 
+  //handleControls(sym);
+
   if (sym == XKB_KEY_Shift_L || sym == XKB_KEY_Shift_R) {
     lastShiftPressTime = nowSeconds();
     log_controls("controls: shift pressed\n");
@@ -497,7 +533,7 @@ Controls::handleKeySym(xkb_keysym_t sym,
       sym == XKB_KEY_underscore || sym == XKB_KEY_0 || sym == XKB_KEY_9) {
     log_controls("controls: debug sym=%u pressed=%d modifier=%d shift=%d focus=%d\n",
                  sym,
-                 pressed ? 1 : 0,
+                 is_pressed ? 1 : 0,
                  modifierHeld ? 1 : 0,
                  shiftHeld ? 1 : 0,
                  waylandFocusActive ? 1 : 0);

src/engine.cpp

@@ -267,8 +267,7 @@ Engine::frame(double frameStart)
     api->mutateEntities();
   }
 
-
-
+  controls->pollPressedKeys();
   renderer->render();
 
   if (engineGui) {
@@ -310,10 +309,7 @@ Engine::frame(double frameStart)
     disableKeysIfImguiActive();
   }
   if (controls) {
-    controls->runQueuedActions();
-    if (window != nullptr) {
-      controls->poll(window, camera, world);
-    }
+    controls->poll();
   }
   multiplayerClientIteration(frameStart);
 

src/wayland/wlr_compositor.cpp

@@ -854,20 +854,10 @@ process_key_sym(WlrServer* server,
   bool waylandFocusActive = false;
   if (server->engine) {
     if (auto wm = server->engine->getWindowManager()) {
-      std::optional<entt::entity> focusCandidate = wm->getPendingFocusedApp();
-      if (!focusCandidate) {
-        focusCandidate = wm->getCurrentlyFocusedApp();
-      }
-      if (focusCandidate) {
-        if (server->registry &&
-            server->registry->all_of<WaylandApp::Component>(*focusCandidate)) {
-          waylandFocusActive = true;
-        }
-      }
+      waylandFocusActive = wm->hasCurrentOrPendingFocus(); 
     }
   }
-
-  if (pressed && server->engine) {
+  if (server->engine) {
     Controls* controls = server->engine->getControls();
     uint32_t mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
     bool modifierHeld =
@@ -897,6 +887,7 @@ process_key_sym(WlrServer* server,
       }
     }
   }
+  /*
   switch (sym) {
     case XKB_KEY_w:
     case XKB_KEY_W:
@@ -933,6 +924,8 @@ process_key_sym(WlrServer* server,
     default:
       break;
   }
+  */
+  
   if constexpr (kWlrootsDebugLogs) {
     FILE* f = std::fopen("/tmp/matrix-wlroots-wm.log", "a");
     if (f) {