notid/play-clj
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename input methods for consistency

Browse Source
This commit is contained in:
oakes
2014-01-10 14:44:18 -05:00
parent 5ddc35ccc7
commit 8f18298fa5
2 changed files with 30 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/play_clj/core.clj
View File

@@ -71,8 +71,8 @@
:pause #(execute-fn! on-pause)
:resize #(execute-fn! on-resize)
:resume #(execute-fn! on-resume)
:input (input* options execute-fn!)
:gesture (gesture* options execute-fn!)}))
:input-processor (input-processor options execute-fn!)
:gesture-detector (gesture-detector options execute-fn!)}))
(defmacro defscreen
[n & {:keys [] :as options}]
@@ -97,8 +97,8 @@
(let [add-inputs! (fn []
(input! :setInputProcessor (InputMultiplexer.))
(doseq [screen screens]
(add-input! (:input screen))
(add-input! (:gesture screen))))
(add-input! (:input-processor screen))
(add-input! (:gesture-detector screen))))
run-fn! (fn [k & args]
(doseq [screen screens]
(apply (get screen k) args)))]

58
src/play_clj/core_global.clj
View File

@@ -43,80 +43,74 @@
[key]
`(.isKeyPressed ^Input (Gdx/input) (get-keycode ~key)))
(defn input*
[{:keys [key-down key-typed key-up mouse-moved
scrolled touch-down touch-dragged touch-up]
:or {key-down dummy key-typed dummy key-up dummy mouse-moved dummy
scrolled dummy touch-down dummy touch-dragged dummy touch-up dummy}}
(defn- input-processor
[{:keys [on-key-down on-key-typed on-key-up on-mouse-moved
on-scrolled on-touch-down on-touch-dragged on-touch-up]
:or {on-key-down dummy on-key-typed dummy
on-key-up dummy on-mouse-moved dummy
on-scrolled dummy on-touch-down dummy
on-touch-dragged dummy on-touch-up dummy}}
execute-fn!]
(reify InputProcessor
(keyDown [this k]
(execute-fn! key-down :keycode k)
(execute-fn! on-key-down :keycode k)
false)
(keyTyped [this c]
(execute-fn! key-typed :character c)
(execute-fn! on-key-typed :character c)
false)
(keyUp [this k]
(execute-fn! key-up :keycode k)
(execute-fn! on-key-up :keycode k)
false)
(mouseMoved [this sx sy]
(execute-fn! mouse-moved :screen-x sx :screen-y sy)
(execute-fn! on-mouse-moved :screen-x sx :screen-y sy)
false)
(scrolled [this a]
(execute-fn! scrolled :amount a)
(execute-fn! on-scrolled :amount a)
false)
(touchDown [this sx sy p b]
(execute-fn! touch-down :screen-x sx :screen-y sy :pointer p :button b)
(execute-fn! on-touch-down :screen-x sx :screen-y sy :pointer p :button b)
false)
(touchDragged [this sx sy p]
(execute-fn! touch-dragged :screen-x sx :screen-y sy :pointer p)
(execute-fn! on-touch-dragged :screen-x sx :screen-y sy :pointer p)
false)
(touchUp [this sx sy p b]
(execute-fn! touch-up :screen-x sx :screen-y sy :pointer p :button b)
(execute-fn! on-touch-up :screen-x sx :screen-y sy :pointer p :button b)
false)))
(defmacro input
[& args]
`(input* ~args (fn [func# & options#] (func# options#))))
(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}}
(defn- gesture-detector
[{:keys [on-fling on-long-press on-pan on-pan-stop on-pinch on-tap on-zoom]
:or {on-fling dummy on-long-press dummy on-pan dummy on-pan-stop dummy
on-pinch dummy on-tap dummy on-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)
(execute-fn! on-fling :velocity-x vx :velocity-y vy :button b)
false)
(longPress [this x y]
(execute-fn! long-press :x x :y y)
(execute-fn! on-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)
(execute-fn! on-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)
(execute-fn! on-pan-stop :x x :y y :pointer p :button b)
false)
(pinch [this ip1 ip2 p1 p2]
(execute-fn! pinch
(execute-fn! on-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)
(execute-fn! on-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)
(execute-fn! on-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]
(.addProcessor ^InputMultiplexer (.getInputProcessor (Gdx/input)) p))