other various changes

project.clj

@@ -1,11 +1,11 @@
-(defproject play-clj "0.4.5-BRYCE"
+(defproject play-clj "0.4.6-BRYCE"
   :description "A libGDX wrapper for easy cross-platform game development"
   :url "https://github.com/oakes/play-clj"
   :license {:name "Public Domain"
             :url "http://unlicense.org/UNLICENSE"}
-  :dependencies [[com.badlogicgames.gdx/gdx "1.5.3"]
+  :dependencies [[com.badlogicgames.gdx/gdx "1.9.5"]
-                 [com.badlogicgames.gdx/gdx-box2d "1.5.3"]
+                 [com.badlogicgames.gdx/gdx-box2d "1.9.5"]
-                 [com.badlogicgames.gdx/gdx-bullet "1.5.3"]
+                 [com.badlogicgames.gdx/gdx-bullet "1.9.5"]
                  [org.clojure/clojure "1.6.0"]]
   :repositories [["sonatype"
                   "https://oss.sonatype.org/content/repositories/releases/"]]

src-java/play_clj/Animation2.java

@@ -0,0 +1,45 @@
+package play_clj;
+import com.badlogic.gdx.graphics.g2d.Animation;
+import java.util.Arrays;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.utils.Array;
+
+public class Animation2 extends Animation<TextureRegion> {
+   public Animation2(float x ,TextureRegion[] y) {
+     super(x, y);
+   }
+
+
+   public Animation2(float x ,  Array<? extends TextureRegion> y, Animation.PlayMode z) {
+     super(x, y, z);
+   }
+
+   public TextureRegion getKeyFrame(float stateTime) {
+   return super.getKeyFrame(stateTime);
+   }
+
+   public TextureRegion getKeyFrame(float stateTime, boolean looping) {
+   return super.getKeyFrame(stateTime, looping);
+   }
+
+
+   public TextureRegion getKeyFrame(double stateTime) {
+   return super.getKeyFrame((float) stateTime);
+   }
+
+   public TextureRegion getKeyFrame(double stateTime, boolean looping) {
+   return super.getKeyFrame((float)stateTime, looping);
+   }
+
+   public TextureRegion getKeyFrame(int stateTime) {
+   return super.getKeyFrame((float)stateTime);
+   }
+
+   public TextureRegion getKeyFrame(int stateTime, boolean looping) {
+   return super.getKeyFrame((float)stateTime, looping);
+   }
+
+   public Object[] getRawKeyFrames() {
+   return super.getKeyFrames();
+   }
+}

src/play_clj/core.clj

@@ -46,11 +46,7 @@
 
 (defn ^:private normalize
   [entities]
-  (some->> entities
+  entities)
-           list
-           flatten
-           (remove nil?)
-           vec))
 
 (defn ^:private wrapper
   [screen-atom screen-fn]
@@ -58,9 +54,7 @@
 
 (defn ^:private reset-changed!
   [e-atom e-old e-new]
-  (when (and (not= e-old e-new)
+  (reset! e-atom e-new))
-             (compare-and-set! e-atom e-old e-new))
-    e-new))
 
 (defn ^:private add-to-timeline!
   [screen-atom entities]
@@ -76,16 +70,18 @@
   [screen entities
    {:keys [on-show on-render on-hide on-pause on-resize on-resume on-timer]
     :as options}]
-  (let [execute-fn! (fn [func & {:keys [] :as options}]
+  (let [execute-fn! (fn exec
-                      (when func
+                      ([func]
-                        (let [screen-map (merge @screen options)
+                          (exec func {}))
-                              old-entities @entities]
+                      ([func options]
-                          (some->> (with-meta
+                          (when func
-                                     #(normalize (func screen-map old-entities))
+                            (let [old-entities @entities]
-                                     (meta func))
+                              (some->> (with-meta
-                                   (wrapper screen)
+                                         #(normalize (func @screen old-entities options))
-                                   (reset-changed! entities old-entities)
+                                         (meta func)) 
-                                   (update-screen! @screen)))))
+                                       (wrapper screen)
+                                       (reset-changed! entities old-entities)
+                                       (update-screen! @screen))))))
         execute-fn-on-gl! (fn [& args]
                             (on-gl (apply execute-fn! args)))
         update-fn! (fn [func & args]
@@ -117,13 +113,23 @@
                       (update-fn! assoc :contact-listener)
                       update-screen!))
      :render (fn [d]
-               (swap! screen update-in [:total-time] #(+ (or %1 0) %2) d)
+               (let [s (.getTime (java.util.Date.))]
-               (some->> (execute-fn! on-render :delta-time d)
+                 (.begin (.getBatch ^Stage (:renderer @screen)))
-                        (add-to-timeline! screen)))
+                 (swap! screen (fn [s]
+                                 (-> s
+                                     (assoc :delta-time d)
+                                     (update-in [:total-time] #(unchecked-add (or ^double %1 0) d)))))
+                 (let [r (execute-fn! on-render @screen)]
+                   (.end (.getBatch ^Stage (:renderer @screen)))
+                   #_(when (= 0 (rand-int 60))
+                     (println "delta:" (graphics! :get-raw-delta-time)))
+                   #_(when (< 6 (- (.getTime (java.util.Date.)) s))
+                     (println (- (.getTime (java.util.Date.)) s)))
+                   r)))
      :hide #(execute-fn! on-hide)
      :pause #(execute-fn! on-pause)
      :resize (fn [w h]
-               (execute-fn! on-resize :width w :height h)
+               (execute-fn! on-resize {:width w :height h})
                (update-screen! @screen))
      :resume #(execute-fn! on-resume)}))
 
@@ -488,7 +494,7 @@ keywords and functions in pairs."
                             (intern *ns* map-sym# (atom {}))))
          entities-sym# (symbol (str '~n "-entities"))
          entities# (deref (or (resolve entities-sym#)
-                              (intern *ns* entities-sym# (atom []))))]
+                              (intern *ns* entities-sym# (atom {}))))]
      (def ~n (defscreen* screen# entities# fn-syms#))))
 
 (defn defgame*
@@ -568,8 +574,8 @@ of key-value pairs, which will be given to the function via its screen map.
 
     (screen! my-other-screen :on-show)
     (screen! my-other-screen :on-change-color :color :blue)"
-  [screen-object fn-name & options]
+  [screen-object fn-name options]
   (let [execute-fn! (:execute-fn! screen-object)
         screen-fn (-> screen-object :options (get fn-name))]
-    (apply execute-fn! screen-fn options)
+    (execute-fn! screen-fn options)
     nil))

src/play_clj/core_basics.clj

@@ -140,7 +140,8 @@
 (defn ^:private add-input!
   [^InputProcessor p]
   (when-let [^InputMultiplexer multi (input! :get-input-processor)]
-    (.addProcessor multi p)))
+    (when p
+      (.addProcessor multi p))))
 
 (defn ^:private remove-input!
   [^InputProcessor p]

src/play_clj/core_graphics.clj

@@ -485,30 +485,34 @@ with the tiled map file at `path` and `unit` scale.
     (.end batch))
   entities)
 
-(defmethod draw! Stage
+(def reset-color ^Color (color 1 1 1 1))
-  [{:keys [^Stage renderer ^Camera camera ^ShaderProgram shader] :as screen} entities]
+
+(defn render-one [{:keys [^Stage renderer ^Camera camera ^ShaderProgram shader] :as screen} {:keys [additive? opacity ^float r ^float g ^float b ^float hue-amount ^float multiply-amount] :as entity :or {opacity 1.0}}]
   (let [^Batch batch (.getBatch renderer)]
     (.setProjectionMatrix batch (.combined camera))   
-    (.begin batch)
+    (when (> opacity 0.0)
-    
-    (doseq [{:keys [additive? opacity ^float r ^float g ^float b ^float hue-amount ^float multiply-amount] :as entity :or {opacity 1.0}} entities
-            :when (> opacity 0.0)]
       (when shader
         (.setShader batch shader)
         (.setUniformf shader "multiply_amount" (float (or multiply-amount 1.0)))
-        (.setUniformf shader "hue_amount" (float (or hue-amount 1.0))))
+        (.setUniformf shader "hue_amount" (float (or hue-amount 0.0))))
       
       (when additive?
         (.setBlendFunction ^Batch batch (gl :gl-src-alpha) (gl :gl-one)))
-      (do (.setColor batch (color (or r 1.0) (or g 1.0) (or b 1.0)  opacity))
+      (do (.setColor batch (float (or r 1.0)) (float (or g 1.0)) (float (or b 1.0))  (float opacity))
           (e/draw! entity screen batch)
-          (.setColor batch (color 1 1 1 1)))
+          (.setColor batch ^Color reset-color))
       
       (when (or additive?)
-        (.setBlendFunction ^Batch batch (gl :gl-src-alpha) (gl :gl-one-minus-src-alpha))))
+        (.setBlendFunction ^Batch batch (gl :gl-src-alpha) (gl :gl-one-minus-src-alpha))))))
-    (.end batch))
+
+(defmethod draw! Stage
+  [screen entities]
+  (doseq [entity entities]
+    (render-one screen entity))
   entities)
 
+
+
 (defmethod draw! ModelBatch
   [{:keys [^ModelBatch renderer ^Camera camera] :as screen} entities]
   (.begin renderer camera)
@@ -550,7 +554,10 @@ specify which layers to render with or without.
 (defn render-stage!
   "Calls the stage renderer from `screen`."
   [{:keys [^Stage renderer] :as screen}]
-  (doto renderer .act .draw)
+
+  (.end (.getBatch renderer))
+  (doto renderer .act)
+  (.begin (.getBatch renderer))
   nil)
 
 (defn render!

src/play_clj/core_listeners.clj

@@ -4,32 +4,32 @@
 
 (defn ^:private 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]}
+           on-scrolled on-touch-down on-touch-dragged on-touch-up] :as screen}
    execute-fn!]
   (reify InputProcessor
     (keyDown [this k]
-      (execute-fn! on-key-down :key k)
+      (execute-fn! on-key-down {:key k})
       false)
     (keyTyped [this c]
-      (execute-fn! on-key-typed :character c)
+      (execute-fn! on-key-typed {:character c})
       false)
     (keyUp [this k]
-      (execute-fn! on-key-up :key k)
+      (execute-fn! on-key-up {:key k})
       false)
     (mouseMoved [this sx sy]
-      (execute-fn! on-mouse-moved :input-x sx :input-y sy)
+      (execute-fn! on-mouse-moved {:input-x sx :input-y sy})
       false)
     (scrolled [this a]
-      (execute-fn! on-scrolled :amount a)
+      (execute-fn! on-scrolled {:amount a})
       false)
     (touchDown [this sx sy p b]
-      (execute-fn! on-touch-down :input-x sx :input-y sy :pointer p :button b)
+      (execute-fn! on-touch-down {:input-x sx :input-y sy :pointer p :button b})
       false)
     (touchDragged [this sx sy p]
-      (execute-fn! on-touch-dragged :input-x sx :input-y sy :pointer p)
+      (execute-fn! on-touch-dragged {:input-x sx :input-y sy :pointer p})
       false)
     (touchUp [this sx sy p b]
-      (execute-fn! on-touch-up :input-x sx :input-y sy :pointer p :button b)
+      (execute-fn! on-touch-up {:input-x sx :input-y sy :pointer p :button b})
       false)))
 
 (defmacro input-processor!
@@ -41,34 +41,38 @@ in the `screen`."
      (u/call! object# ~k ~@options)))
 
 (defn ^:private gesture-listener
-  [{:keys [on-fling on-long-press on-pan on-pan-stop on-pinch on-tap on-zoom]}
+  [{:keys [on-fling on-long-press on-pan on-pan-stop on-pinch on-tap on-zoom pinch-stop]}
    execute-fn!]
   (reify GestureDetector$GestureListener
     (fling [this vx vy b]
-      (execute-fn! on-fling :velocity-x vx :velocity-y vy :button b)
+      (execute-fn! on-fling {:velocity-x vx :velocity-y vy :button b})
       (some? on-fling))
     (longPress [this x y]
-      (execute-fn! on-long-press :input-x x :input-y y)
+      (execute-fn! on-long-press {:input-x x :input-y y})
       (some? on-long-press))
     (pan [this x y dx dy]
-      (execute-fn! on-pan :input-x x :input-y y :delta-x dx :delta-y dy)
+      (execute-fn! on-pan {:input-x x :input-y y :delta-x dx :delta-y dy})
-      (some? on-pan))
+      false)
     (panStop [this x y p b]
-      (execute-fn! on-pan-stop :input-x x :input-y y :pointer p :button b)
+      (execute-fn! on-pan-stop {:input-x x :input-y y :pointer p :button b})
-      (some? on-pan-stop))
+      false)
+    (pinchStop [this]
+      (execute-fn! pinch-stop
+                   {})
+      false)
     (pinch [this ip1 ip2 p1 p2]
       (execute-fn! on-pinch
-                   :initial-pointer-1 ip1 :initial-pointer-2 ip2
+                   {:initial-pointer-1 ip1 :initial-pointer-2 ip2
-                   :pointer-1 p1 :pointer-2 p2)
+                    :pointer-1 p1 :pointer-2 p2})
-      (some? on-pinch))
+      false)
     (tap [this x y c b]
-      (execute-fn! on-tap :input-x x :input-y y :count c :button b)
+      (execute-fn! on-tap {:input-x x :input-y y :count c :button b})
-      (some? on-tap))
+      false)
     (touchDown [this x y p b]
       false)
     (zoom [this id d]
-      (execute-fn! on-zoom :initial-distance id :distance d)
+      (execute-fn! on-zoom {:initial-distance id :distance d})
-      (some? on-zoom))))
+      false)))
 
 (defn ^:private gesture-detector
   [options execute-fn!]
@@ -96,30 +100,30 @@ in the `screen`."
   (proxy [ActorGestureListener] []
     (fling [e vx vy b]
       (execute-fn! on-ui-fling
-                   :event e :velocity-x vx :velocity-y vy :button b))
+                   {:event e :velocity-x vx :velocity-y vy :button b}))
     (longPress [a x y]
-      (execute-fn! on-ui-long-press :actor a :input-x x :input-y y)
+      (execute-fn! on-ui-long-press {:actor a :input-x x :input-y y})
       (some? on-ui-long-press))
     (pan [e x y dx dy]
       (execute-fn! on-ui-pan
-                   :event e :input-x x :input-y y :delta-x dx :delta-y dy))
+                   { :event e :input-x x :input-y y :delta-x dx :delta-y dy}))
     (pinch [e ip1 ip2 p1 p2]
       (execute-fn! on-ui-pinch
-                   :event e :initial-pointer-1 ip1 :initial-pointer-2 ip2
+                   { :event e :initial-pointer-1 ip1 :initial-pointer-2 ip2
-                   :pointer1 p1 :pointer2 p2))
+                    :pointer1 p1 :pointer2 p2}))
     (tap [e x y p b]
       (execute-fn! on-ui-tap
-                   :event e :input-x x :input-y y :pointer p :button b))
+                   { :event e :input-x x :input-y y :pointer p :button b}))
     ;(touchDown [e x y p b])
     ;(touchUp [e x y p b])
     (zoom [e id d]
-      (execute-fn! on-ui-zoom :event e :initial-distance id :distance d))))
+      (execute-fn! on-ui-zoom { :event e :initial-distance id :distance d}))))
 
 (defn ^:private change-listener
   [{:keys [on-ui-changed]} execute-fn!]
   (proxy [ChangeListener] []
     (changed [e a]
-      (execute-fn! on-ui-changed :event e :actor a))))
+      (execute-fn! on-ui-changed { :event e :actor a}))))
 
 (defn ^:private click-listener
   [{:keys [on-ui-clicked on-ui-enter on-ui-exit
@@ -127,23 +131,23 @@ in the `screen`."
    execute-fn!]
   (proxy [ClickListener] []
     (clicked [e x y]
-      (execute-fn! on-ui-clicked :event e :input-x x :input-y y))
+      (execute-fn! on-ui-clicked { :event e :input-x x :input-y y}))
     (enter [e x y p a]
       (execute-fn! on-ui-enter
-                   :event e :input-x x :input-y y :pointer p :actor a))
+                   { :event e :input-x x :input-y y :pointer p :actor a}))
     (exit [e x y p a]
       (execute-fn! on-ui-exit
-                   :event e :input-x x :input-y y :pointer p :actor a))
+                   { :event e :input-x x :input-y y :pointer p :actor a}))
     (touchDown [e x y p b]
       (execute-fn! on-ui-touch-down
-                   :event e :input-x x :input-y y :pointer p :button b)
+                   { :event e :input-x x :input-y y :pointer p :button b})
       (some? on-ui-touch-down))
     (touchDragged [e x y p]
       (execute-fn! on-ui-touch-dragged
-                   :event e :input-x x :input-y y :pointer p))
+                   { :event e :input-x x :input-y y :pointer p}))
     (touchUp [e x y p b]
       (execute-fn! on-ui-touch-up
-                   :event e :input-x x :input-y y :pointer p :button b))))
+                   { :event e :input-x x :input-y y :pointer p :button b}))))
 
 (defn ^:private drag-listener
   [{:keys [on-ui-drag on-ui-drag-start on-ui-drag-stop]}
@@ -153,20 +157,20 @@ in the `screen`."
     ;(touchDragged [e x y p])
     ;(touchUp [e x y p b])
     (drag [e x y p]
-      (execute-fn! on-ui-drag :event e :input-x x :input-y y :pointer p))
+      (execute-fn! on-ui-drag { :event e :input-x x :input-y y :pointer p}))
     (dragStart [e x y p]
-      (execute-fn! on-ui-drag-start :event e :input-x x :input-y y :pointer p))
+      (execute-fn! on-ui-drag-start { :event e :input-x x :input-y y :pointer p}))
     (dragStop [e x y p]
-      (execute-fn! on-ui-drag-stop :event e :input-x x :input-y y :pointer p))))
+      (execute-fn! on-ui-drag-stop { :event e :input-x x :input-y y :pointer p}))))
 
 (defn ^:private focus-listener
   [{:keys [on-ui-keyboard-focus-changed on-ui-scroll-focus-changed]}
    execute-fn!]
   (proxy [FocusListener] []
     (keyboardFocusChanged [e a f]
-      (execute-fn! on-ui-keyboard-focus-changed :event e :actor a :focused? f))
+      (execute-fn! on-ui-keyboard-focus-changed { :event e :actor a :focused? f}))
     (scrollFocusChanged [e a f]
-      (execute-fn! on-ui-scroll-focus-changed :event e :actor a :focused? f))))
+      (execute-fn! on-ui-scroll-focus-changed { :event e :actor a :focused? f}))))
 
 (defn ^:private ui-listeners
   [options execute-fn!]
@@ -190,23 +194,26 @@ in the `screen`."
       (doto (.getViewport renderer)
         (.setCamera camera)
         (.setWorldSize (. camera viewportWidth) (. camera viewportHeight)))))
-  ([{:keys [^Stage renderer ui-listeners]} [entities]]
+  ([{:keys [^Stage renderer ui-listeners]} entities]
-     (let [actor-set (->> entities
+     #_(let [actor-set (->> entities
                           vals
                           (map :object)
                           (filter #(instance? Actor %))
-                          set)]
+                          )]
-       (doseq [^Actor a (clojure.set/difference (set (.getActors renderer)) actor-set )]
+       #_(doseq [^Actor a (clojure.set/difference (set (.getActors renderer)) actor-set )]
          (.remove a))
-       (doseq [object (clojure.set/difference actor-set (set (.getActors renderer)) ) ]
+       #_(doseq [[_ object] entities
-         (.addActor renderer object)
+               :when (and (instance? Actor (:object object))
+                          (not (.contains (.getActors renderer) (:object object) true)))]
+         (.addActor renderer (:object object))
          (doseq [[_ listener] ui-listeners]
-           (.addListener ^Actor object listener)))
+           (.addListener ^Actor (:object object) listener)))
-       (remove-input! renderer)
+       )
-       (add-input! renderer))))
+     (remove-input! renderer)
+       (add-input! renderer)))
 
 (defmulti update-physics!
-  (fn [screen & [entities]] (some-> screen :world class .getName))
+  (fn [screen & entities] (some-> screen :world class .getName))
   :default nil)
 
 (defmethod update-physics! nil [_ & _])
@@ -214,10 +221,9 @@ in the `screen`."
 (defn ^:private update-screen!
   ([{:keys [renderer world] :as screen}]
     (when (instance? Stage renderer)
-      (update-stage! screen))
+      (update-stage! screen)))
-    (update-physics! screen))
   ([{:keys [renderer world] :as screen} entities]
     (when (instance?  Stage renderer)
       (update-stage! screen entities))
-    (update-physics! screen entities)
+    
     entities))

src/play_clj/core_utils.clj

@@ -116,7 +116,7 @@ entities vector."
   [{:keys [execute-fn! on-timer]} id]
   (proxy [Timer$Task] []
     (run []
-      (execute-fn! on-timer :id id))))
+      (execute-fn! on-timer {:id id}))))
 
 (defn ^:private timer*
   []
@@ -175,7 +175,7 @@ found."
     (set-loaders! am (InternalFileHandleResolver.)))
   ([^AssetManager am res]
     (.setLoader am TiledMap (TmxMapLoader. res))
-    (.setLoader am ParticleEffect (proxy [ParticleEffectLoader] [res]
+    #_(.setLoader am ParticleEffect (proxy [ParticleEffectLoader] [res]
                                     (load [am file-name fh param]
                                       (doto (ParticleEffect.)
                                         (.load fh (.parent fh))))))))

src/play_clj/entities.clj

@@ -21,11 +21,13 @@
 
 (defrecord TextureEntity [object] Entity
   (draw! [{:keys [^TextureRegion object x y width height
-                         scale-x scale-y angle origin-x origin-y something]}
+                         scale-x scale-y angle origin-x origin-y offset-x offset-y]}
                  _
                  batch]
-    (let [x (float (- (float (or x 0)) (or origin-x 0.0)))
+    (let [x (float (+ (- (float (or x 0)) (or origin-x 0.0))
-          y (float (- (float (or y 0)) (or origin-y 0.0)))
+                      (float (or offset-x 0))))
+          y (float (+ (- (float (or y 0)) (or origin-y 0.0))
+                      (float (or offset-y 0))))
           width (float (or width (.getRegionWidth object)))
           height (float (or height (.getRegionHeight object)))]
       (if (or scale-x scale-y angle)

src/play_clj/g2d.clj

@@ -4,7 +4,9 @@
   (:import [com.badlogic.gdx Files Gdx]
            [com.badlogic.gdx.files FileHandle]
            [com.badlogic.gdx.graphics Pixmap Texture]
+[play_clj Animation2]
            [com.badlogic.gdx.graphics.g2d Animation BitmapFont NinePatch
+           
             ParticleEffect TextureAtlas TextureRegion]
            [play_clj.entities TextureEntity NinePatchEntity
             ParticleEffectEntity]))
@@ -44,7 +46,7 @@
       (-> ^Pixmap arg Texture. TextureRegion.)
       (instance?  Texture arg)
       (-> ^Texture arg TextureRegion.)
-      (instance?  TextureEntity )
+      (instance?  TextureEntity arg)
       (-> ^TextureRegion (:object arg) TextureRegion.)
       :else
       arg)))
@@ -190,7 +192,7 @@
 
 (defn animation*
   [duration textures]
-  (Animation. duration
+  (Animation2. duration
               (u/gdx-array (map #(u/get-obj % :object) textures))
               (play-mode :normal)))
 
@@ -201,14 +203,14 @@
                [walk-1 walk-2 walk-3]
                :set-play-mode (play-mode :loop-pingpong))"
   [duration textures & options]
-  `(u/calls! ^Animation (animation* ~duration ~textures) ~@options))
+  `(u/calls! ^Animation2 (animation* ~duration ~textures) ~@options))
 
 (defmacro animation!
   "Calls a single method on an `animation`.
 
     (animation! object :set-play-mode (play-mode :loop))"
   [object k & options]
-  (let [object (vary-meta object assoc :tag `Animation)]
+  (let [object (vary-meta object assoc :tag `Animation2)]
     `(u/call! ~object ~k ~@options)))
 
 (defn animation->texture
@@ -216,7 +218,7 @@
 time the `screen` has been showing.
 
     (animation->texture screen anim)"
-  ([{:keys [total-time] :as screen} ^Animation animation]
+  ([{:keys [total-time] :as screen} ^Animation2 animation]
-    (texture* (.getKeyFrame animation total-time true)))
+    (texture* (.getKeyFrame ^Animation2 animation total-time true)))
-  ([{:keys [total-time] :as screen} ^Animation animation is-looping?]
+  ([{:keys [total-time] :as screen} ^Animation2 animation is-looping?]
-    (texture* (.getKeyFrame animation total-time is-looping?))))
+    (texture* (.getKeyFrame ^Animation2 animation total-time is-looping?))))

src/play_clj/g2d_physics.clj

@@ -228,13 +228,13 @@ such as :on-begin-contact."
    execute-fn!]
   (reify ContactListener
     (beginContact [this c]
-      (execute-fn! on-begin-contact :contact c))
+      (execute-fn! on-begin-contact { :contact c}))
     (endContact [this c]
-      (execute-fn! on-end-contact :contact c))
+      (execute-fn! on-end-contact { :contact c}))
     (postSolve [this c i]
-      (execute-fn! on-post-solve :contact c :impulse i))
+      (execute-fn! on-post-solve { :contact c :impulse i}))
     (preSolve [this c m]
-      (execute-fn! on-pre-solve :contact c :old-manifold m))))
+      (execute-fn! on-pre-solve { :contact c :old-manifold m}))))
 
 (defmethod c/update-physics!
   "com.badlogic.gdx.physics.box2d.World"

src/play_clj/g3d_physics.clj

@@ -273,9 +273,9 @@ such as :on-begin-contact."
    execute-fn!]
   (ContactListener3D.
     (fn [a b]
-      (execute-fn! on-begin-contact :first-body a :second-body b))
+      (execute-fn! on-begin-contact { :first-body a :second-body b}))
     (fn [a b]
-      (execute-fn! on-end-contact :first-body a :second-body b))))
+      (execute-fn! on-end-contact { :first-body a :second-body b}))))
 
 (defn ^:private get-bodies
   [screen]

texture

@@ -0,0 +1,11 @@
+src/play_clj/g2d.clj:(defn animation->texture
+src/play_clj/g2d.clj:    (animation->texture screen anim)"
+doclet/resources/classes.edn: "AnimationController" {"animation-controller" :methods
+doclet/resources/classes.edn:                        "animation-controller!" :methods}
+src/play_clj/g3d.clj:; animation-controller
+src/play_clj/g3d.clj:(defn animation-controller*
+src/play_clj/g3d.clj:(defmacro animation-controller
+src/play_clj/g3d.clj:    (animation-controller model-entity)"
+src/play_clj/g3d.clj:  `(let [^AnimationController object# (animation-controller* ~entity)]
+src/play_clj/g3d.clj:(defmacro animation-controller!
+src/play_clj/g3d.clj:  "Calls a single method on an `animation-controller`."