Add initial scene2d support

common/src/play_clj/core.clj

@@ -10,15 +10,15 @@
             HexagonalTiledMapRenderer
             IsometricStaggeredTiledMapRenderer
             IsometricTiledMapRenderer
-            OrthogonalTiledMapRenderer]))
+            OrthogonalTiledMapRenderer]
+           [com.badlogic.gdx.scenes.scene2d Actor Stage]))
 
 (load "core_2d")
 (load "core_global")
 (load "core_render")
 
 (defn defscreen*
-  [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume
-           state renderer camera]
+  [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume]
     :as options}]
   (let [screen (atom {})
         dummy-fn (fn [s])
@@ -31,13 +31,15 @@
     (proxy [Screen] []
       (show []
         (on-show (swap! screen assoc
-                        :renderer (create-renderer renderer)
-                        :camera (create-camera camera)
                         :width (game :width)
                         :height (game :height)
                         :total-time 0
                         :delta-time 0
-                        :save #(swap! screen assoc :entities %))))
+                        :set-entities #(swap! screen assoc :entities %)
+                        :create-renderer #(swap! screen assoc
+                                                 :renderer (renderer %))
+                        :create-camera #(swap! screen assoc
+                                               :camera (camera %)))))
       (render [delta-time]
         (on-render (swap! screen assoc
                           :total-time (+ (:total-time @screen) delta-time)
@@ -64,7 +66,18 @@
   [^Game game ^Screen screen]
   (.setScreen game screen))
 
-(defn save!
-  [{:keys [save]} entities]
-  (save entities)
+(defn set-entities!
+  [{:keys [set-entities]} entities]
+  (:entities (set-entities entities)))
+
+(defn get-entities
+  [{:keys [entities]}]
   entities)
+
+(defn create-renderer!
+  [{:keys [create-renderer]} & {:keys [] :as args}]
+  (:renderer (create-renderer args)))
+
+(defn create-camera!
+  [{:keys [create-camera]} & {:keys [] :as args}]
+  (:camera (create-camera args)))

common/src/play_clj/core_2d.clj

@@ -11,12 +11,17 @@
   (assert renderer)
   (.getSpriteBatch renderer))
 
-(defn draw! [screen entities]
-  (let [batch (sprite-batch screen)]
+(defn draw! [{:keys [renderer]} entities]
+  (assert renderer)
+  (let [batch (.getSpriteBatch renderer)]
     (.begin batch)
-    (doseq [{:keys [image x y width height]} entities]
-      (when (and image x y width height)
-        (.draw batch image (float x) (float y) (float width) (float height))))
+    (doseq [e entities]
+      (cond
+        (map? e)
+        (let [{:keys [image x y width height]} e]
+          (.draw batch image (float x) (float y) (float width) (float height)))
+        (isa? (type e) Actor)
+        (.draw e batch 1)))
     (.end batch))
   entities)
 

common/src/play_clj/core_render.clj

@@ -12,12 +12,17 @@
   (assert (number? tile-size))
   (float (/ 1 tile-size)))
 
-(defn render-tiled-map!
-  [{:keys [^BatchTiledMapRenderer renderer ^Camera camera]}]
-  (assert (and renderer camera))
-  (doto renderer
-    (.setView camera)
-    .render))
+(defn render!
+  [{:keys [renderer ^Camera camera]}]
+  (assert renderer)
+  (cond
+    (isa? (type renderer) BatchTiledMapRenderer)
+    (doto renderer
+      (.setView camera)
+      .render)
+    (isa? (type renderer) Stage)
+    (.draw renderer)
+    :else nil))
 
 (defn tiled-map-layer
   [{:keys [^BatchTiledMapRenderer renderer]} layer]
@@ -32,28 +37,33 @@
         layer)
       (.getCell x y)))
 
-(defmulti create-renderer :type :default :orthogonal-tiled-map)
+(defmulti renderer :type :default nil)
 
-(defmethod create-renderer :orthogonal-tiled-map [opts]
+(defmethod renderer nil [opts])
+
+(defmethod renderer :orthogonal-tiled-map [opts]
   (OrthogonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
 
-(defmethod create-renderer :isometric-tiled-map [opts]
+(defmethod renderer :isometric-tiled-map [opts]
   (IsometricTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
 
-(defmethod create-renderer :isometric-staggered-tiled-map [opts]
+(defmethod renderer :isometric-staggered-tiled-map [opts]
   (IsometricStaggeredTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
 
-(defmethod create-renderer :hexagonal-tiled-map [opts]
+(defmethod renderer :hexagonal-tiled-map [opts]
   (HexagonalTiledMapRenderer. (load-tiled-map opts) (unit-scale opts)))
 
+(defmethod renderer :stage [_]
+  (Stage.))
+
 ; cameras
 
-(defmulti create-camera identity :default :orthographic)
+(defmulti camera identity :default :orthographic)
 
-(defmethod create-camera :orthographic [_]
+(defmethod camera :orthographic [_]
   (OrthographicCamera.))
 
-(defmethod create-camera :perspective [_]
+(defmethod camera :perspective [_]
   (PerspectiveCamera.))
 
 (defn resize-camera!