Refactor and add render functions

common/src/play_clj/core.clj

@@ -1,36 +1,66 @@
 (ns play-clj.core
-  (:import [com.badlogic.gdx Game Screen]))
+  (:import [com.badlogic.gdx Game Gdx Screen]
+           [com.badlogic.gdx.graphics.g2d SpriteBatch]
+           [com.badlogic.gdx.graphics
+            Camera Color GL20 OrthographicCamera PerspectiveCamera]
+           [com.badlogic.gdx.maps.tiled TmxMapLoader]
+           [com.badlogic.gdx.maps.tiled.renderers
+            BatchTiledMapRenderer
+            HexagonalTiledMapRenderer
+            IsometricStaggeredTiledMapRenderer
+            IsometricTiledMapRenderer
+            OrthogonalTiledMapRenderer]))
 
-(defn set-screen!
+(load "render")
-  [^Game game ^Screen screen]
+
-  (.setScreen game screen))
+(defn clear!
+  ([] (clear! 0 0 0 0))
+  ([r g b a]
+    (doto (Gdx/gl)
+      (.glClearColor r g b a)
+      (.glClear GL20/GL_COLOR_BUFFER_BIT))))
 
 (defn defscreen*
-  [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume]}]
+  [{:keys [on-show on-render on-dispose on-hide on-pause on-resize on-resume
-  (let [total-time (atom 0)
+           renderer camera]
-        on-show (or on-show (fn []))
+    :as options}]
-        on-render (or on-render (fn [d t]))
+  (let [screen (atom {})
-        on-dispose (or on-dispose (fn []))
+        on-show (or on-show (fn [s]))
-        on-hide (or on-hide (fn []))
+        on-render (or on-render (fn [s d]))
-        on-pause (or on-pause (fn []))
+        on-dispose (or on-dispose (fn [s]))
-        on-resize (or on-resize (fn [w h]))
+        on-hide (or on-hide (fn [s]))
-        on-resume (or on-resume (fn []))]
+        on-pause (or on-pause (fn [s]))
+        on-resize (or on-resize (fn [s w h]))
+        on-resume (or on-resume (fn [s]))]
     (proxy [Screen] []
-      (show [] (on-show))
+      (show []
+        (swap! screen assoc
+               :renderer (when renderer (renderer))
+               :camera (create-camera camera)
+               :total-time 0)
+        (on-show @screen))
       (render [delta-time]
-        (swap! total-time + delta-time)
+        (swap! screen assoc :total-time (+ (:total-time @screen) delta-time))
-        (on-render delta-time @total-time))
+        (on-render @screen delta-time))
-      (dispose [] (on-dispose))
+      (dispose [] (on-dispose @screen))
-      (hide [] (on-hide))
+      (hide [] (on-hide @screen))
-      (pause [] (on-pause))
+      (pause [] (on-pause @screen))
-      (resize [w h] (on-resize w h))
+      (resize [w h] (on-resize @screen w h))
-      (resume [] (on-resume)))))
+      (resume [] (on-resume @screen)))))
 
 (defmacro defscreen
   [name & {:keys [] :as options}]
   `(def ~name (defscreen* ~options)))
 
-(defn create-game
+(defn set-screen!
+  [^Game game ^Screen screen]
+  (.setScreen game screen))
+
+(defn defgameobj*
   [{:keys [start-screen]}]
   (proxy [Game] []
     (create [] (when start-screen (set-screen! this start-screen)))))
+
+(defmacro defgameobj
+  [name options]
+  `(def ~name (defgameobj* ~options)))

common/src/play_clj/render.clj

@@ -0,0 +1,69 @@
+(ns play-clj.render)
+
+(in-ns 'play-clj.core)
+
+; tiled map renderers
+
+(defmulti create-tiled-map-renderer :type :default :orthogonal)
+
+(defmethod create-tiled-map-renderer :orthogonal [options]
+  (OrthogonalTiledMapRenderer. (:map options) (:unit-scale options)))
+
+(defmethod create-tiled-map-renderer :isometric [options]
+  (IsometricTiledMapRenderer. (:map options) (:unit-scale options)))
+
+(defmethod create-tiled-map-renderer :isometric-staggered [options]
+  (IsometricStaggeredTiledMapRenderer. (:map options) (:unit-scale options)))
+
+(defmethod create-tiled-map-renderer :hexagonal [options]
+  (HexagonalTiledMapRenderer. (:map options) (:unit-scale options)))
+
+(defn tiled-map
+  [& {:keys [file tile-size type] :as options}]
+  (assert (string? file))
+  (assert (number? tile-size))
+  (fn []
+    (let [tiled-map (.load (TmxMapLoader.) file)
+          unit-scale (float (/ 1 tile-size))
+          options (assoc options
+                         :map tiled-map
+                         :unit-scale unit-scale)]
+      (create-tiled-map-renderer options))))
+
+(defn render-tiled-map!
+  [{:keys [^BatchTiledMapRenderer renderer ^OrthographicCamera camera]}]
+  (.setView renderer camera)
+  (.render renderer))
+
+; cameras
+
+(defmulti create-camera identity :default :orthographic)
+
+(defmethod create-camera :orthographic [_]
+  (OrthographicCamera.))
+
+(defmethod create-camera :perspective [_]
+  (PerspectiveCamera.))
+
+(defn resize-camera!
+  [{:keys [^Camera camera]} width height]
+  (.setToOrtho camera false width height))
+
+; draw entities
+
+(defmulti sprite-batch (fn [screen] (class (:renderer screen))) :default nil)
+
+(defmethod sprite-batch nil [screen]
+  (SpriteBatch.))
+
+(defmethod sprite-batch BatchTiledMapRenderer [screen]
+  (.getSpriteBatch (:renderer screen)))
+
+(defn draw-entities!
+  [screen entities]
+  (let [batch (sprite-batch screen)]
+    (.begin batch)
+    (doseq [{:keys [image x y width height]} entities]
+      (when (and image x y width height)
+        (.draw batch image x y width height)))
+    (.end batch)))

desktop/src/play_clj/desktop.clj

@@ -10,7 +10,7 @@
         width (or width 800)
         height (or height 600)]
     `(do
-       (def ~name (create-game ~options))
+       (defgameobj ~name ~options)
        (defn ~'-main
          []
          (LwjglApplication. ~name ~title ~width ~height true)