Add gesture detection

src/play_clj/core.clj

@@ -7,6 +7,8 @@
             PerspectiveCamera Texture]
            [com.badlogic.gdx.graphics.g2d Animation BitmapFont SpriteBatch
             TextureRegion]
+           [com.badlogic.gdx.input GestureDetector
+            GestureDetector$GestureListener]
            [com.badlogic.gdx.maps MapLayer MapLayers]
            [com.badlogic.gdx.maps.tiled TiledMap TiledMapTileLayer TmxMapLoader]
            [com.badlogic.gdx.maps.tiled.renderers
@@ -80,7 +82,8 @@
      :pause #(execute-fn! on-pause @screen)
      :resize #(execute-fn! on-resize @screen)
      :resume #(execute-fn! on-resume @screen)
-     :input (input* options execute-priority-fn!)}))
+     :input (input* options execute-priority-fn!)
+     :gesture (gesture* options execute-priority-fn!)}))
 
 (defmacro defscreen
   [n & {:keys [] :as options}]
@@ -94,7 +97,7 @@
   [{:keys [on-create] :or {on-create dummy}}]
   (proxy [Game] []
     (create []
-      (set-input! (InputMultiplexer.))
+      (input! :setInputProcessor (InputMultiplexer.))
       (on-create this))))
 
 (defmacro defgame
@@ -105,7 +108,8 @@
   [^Game game & screens]
   (let [add-inputs! (fn []
                       (doseq [screen screens]
-                        (add-input! (:input screen))))
+                        (add-input! (:input screen))
+                        (add-input! (:gesture screen))))
         run-fn! (fn [k & args]
                   (doseq [screen screens]
                     (apply (get screen k) args)))]

src/play_clj/core_global.clj

@@ -50,41 +50,71 @@
          scrolled dummy touch-down dummy touch-dragged dummy touch-up dummy}}
    execute-fn!]
   (reify InputProcessor
-    (keyDown [this keycode]
-      (execute-fn! key-down {:keycode keycode})
+    (keyDown [this k]
+      (execute-fn! key-down {:keycode k})
       false)
-    (keyTyped [this character]
-      (execute-fn! key-typed {:character character})
+    (keyTyped [this c]
+      (execute-fn! key-typed {:character c})
       false)
-    (keyUp [this keycode]
-      (execute-fn! key-up {:keycode keycode})
+    (keyUp [this k]
+      (execute-fn! key-up {:keycode k})
       false)
-    (mouseMoved [this screen-x screen-y]
-      (execute-fn! mouse-moved {:screen-x screen-x :screen-y screen-y})
+    (mouseMoved [this sx sy]
+      (execute-fn! mouse-moved {:screen-x sx :screen-y sy})
       false)
-    (scrolled [this amount]
-      (execute-fn! scrolled {:amount amount})
+    (scrolled [this a]
+      (execute-fn! scrolled {:amount a})
       false)
-    (touchDown [this screen-x screen-y pointer button]
-      (execute-fn! touch-down {:screen-x screen-x :screen-y screen-y
-                               :pointer pointer :button button})
+    (touchDown [this sx sy p b]
+      (execute-fn! touch-down {:screen-x sx :screen-y sy :pointer p :button b})
       false)
-    (touchDragged [this screen-x screen-y pointer]
-      (execute-fn! touch-dragged
-                   {:screen-x screen-x :screen-y screen-y :pointer pointer})
+    (touchDragged [this sx sy p]
+      (execute-fn! touch-dragged {:screen-x sx :screen-y sy :pointer p})
       false)
-    (touchUp [this screen-x screen-y pointer button]
-      (execute-fn! touch-up {:screen-x screen-x :screen-y screen-y
-                             :pointer pointer :button button})
+    (touchUp [this sx sy p b]
+      (execute-fn! touch-up {:screen-x sx :screen-y sy :pointer p :button b})
       false)))
 
 (defmacro input
   [& args]
   `(input* ~args (fn [func# options#] (func# options#))))
 
-(defn set-input!
-  [^InputProcessor p]
-  (.setInputProcessor ^Input (Gdx/input) p))
+(defn gesture*
+  [{:keys [fling long-press pan pan-stop pinch tap zoom]
+    :or {fling dummy long-press dummy pan dummy pan-stop dummy
+         pinch dummy tap dummy zoom dummy}}
+   execute-fn!]
+  (let [listener
+        (reify GestureDetector$GestureListener
+          (fling [this vx vy b]
+            (execute-fn! fling {:velocity-x vx :velocity-y vy :button b})
+            false)
+          (longPress [this x y]
+            (execute-fn! long-press {:x x :y y})
+            false)
+          (pan [this x y dx dy]
+            (execute-fn! pan {:x x :y y :delta-x dx :delta-y dy})
+            false)
+          (panStop [this x y p b]
+            (execute-fn! pan-stop {:x x :y y :pointer p :button b})
+            false)
+          (pinch [this ip1 ip2 p1 p2]
+            (execute-fn! pinch {:initial-pointer-1 ip1 :initial-pointer-2 ip2
+                                :pointer1 p1 :pointer2 p2})
+            false)
+          (tap [this x y c b]
+            (execute-fn! tap {:x x :y y :count c :button b})
+            false)
+          (touchDown [this x y p b]
+            false)
+          (zoom [this id d]
+            (execute-fn! zoom {:initial-distance id :distance d})
+            false))]
+    (proxy [GestureDetector] [listener])))
+
+(defmacro gesture
+  [& args]
+  `(gesture* ~args (fn [func# options#] (func# options#))))
 
 (defn add-input!
   [^InputProcessor p]
@@ -93,7 +123,3 @@
 (defn remove-input!
   [^InputProcessor p]
   (.removeProcessor ^InputMultiplexer (.getInputProcessor (Gdx/input)) p))
-
-(defn clear-inputs!
-  []
-  (.clear ^InputMultiplexer (.getInputProcessor (Gdx/input))))