Change camera/renderer creation process

src/play_clj/core.clj

@@ -28,6 +28,7 @@
   {:type :actor :object obj})
 
 (load "core_2d")
+(load "core_deprecated")
 (load "core_global")
 (load "core_render")
 
@@ -46,16 +47,12 @@
                                (remove nil?)
                                (reset! entities)))
         create-renderer-fn! #(swap! screen assoc :renderer (renderer %))
-        create-camera-fn! #(swap! screen assoc :camera (camera %))
-        update-fn! #(swap! screen assoc
-                           :renderer (renderer (:renderer %))
-                           :camera (camera (:camera %)))]
+        update-fn! #(swap! screen merge %)]
     {:show (fn []
              (->> (swap! screen assoc
                          :total-time 0
                          :delta-time 0
                          :create-renderer-fn! create-renderer-fn!
-                         :create-camera-fn! create-camera-fn!
                          :update-fn! update-fn!)
                   (execute-fn! on-show)))
      :render (fn [delta-time]
@@ -104,11 +101,3 @@
 (defn update!
   [{:keys [update-fn!]} & {:keys [] :as args}]
   (update-fn! args))
-
-(defn create-renderer!
-  [{:keys [create-renderer-fn!]} & {:keys [] :as args}]
-  (:renderer (create-renderer-fn! args)))
-
-(defn create-camera!
-  [{:keys [create-camera-fn!]} & {:keys [] :as args}]
-  (:camera (create-camera-fn! args)))

src/play_clj/core_deprecated.clj

@@ -0,0 +1,12 @@
+(in-ns 'play-clj.core)
+
+(defn create-renderer!
+  [{:keys [create-renderer-fn!]} & {:keys [] :as args}]
+  (:renderer (create-renderer-fn! args)))
+
+(defmulti renderer :type :default nil)
+
+(defmethod renderer nil [opts])
+
+(defmethod renderer :stage [_]
+  (Stage.))

src/play_clj/core_render.clj

@@ -1,16 +1,6 @@
 (in-ns 'play-clj.core)
 
-; renderers
-
-(defn load-tiled-map
-  [{:keys [file]}]
-  (assert (string? file))
-  (.load (TmxMapLoader.) file))
-
-(defn unit-scale
-  [{:keys [tile-size]}]
-  (assert (number? tile-size))
-  (float (/ 1 tile-size)))
+; rendering
 
 (defn render!
   [{:keys [renderer ^Camera camera]}]
@@ -50,37 +40,41 @@
   [screen layer x y]
   (.getCell ^TiledMapTileLayer (tiled-map-layer screen layer) x y))
 
-(defmulti renderer :type :default nil)
+; renderers
 
-(defmethod renderer nil [opts])
+(defn tiled-map
+  [s]
+  (if (string? s)
+    (.load (TmxMapLoader.) s)
+    s))
 
-(defmethod renderer :orthogonal-tiled-map [opts]
-  (OrthogonalTiledMapRenderer. ^TiledMap (load-tiled-map opts)
-                               ^double (unit-scale opts)))
+(defn tiled-map-renderer
+  [renderer-type path pixels-per-tile]
+  (let [^TiledMap tmap (tiled-map path)
+        ^double unit-scale (/ 1 pixels-per-tile)]
+    (case renderer-type
+      :orthogonal
+      (OrthogonalTiledMapRenderer. tmap unit-scale)
+      :isometric
+      (IsometricTiledMapRenderer. tmap unit-scale)
+      :isometric-staggered
+      (IsometricStaggeredTiledMapRenderer. tmap unit-scale)
+      :hexagonal
+      (IsometricTiledMapRenderer. tmap unit-scale)
+      nil)))
 
-(defmethod renderer :isometric-tiled-map [opts]
-  (IsometricTiledMapRenderer. ^TiledMap (load-tiled-map opts)
-                              ^double (unit-scale opts)))
-
-(defmethod renderer :isometric-staggered-tiled-map [opts]
-  (IsometricStaggeredTiledMapRenderer. ^TiledMap (load-tiled-map opts)
-                                       ^double (unit-scale opts)))
-
-(defmethod renderer :hexagonal-tiled-map [opts]
-  (HexagonalTiledMapRenderer. ^TiledMap (load-tiled-map opts)
-                              ^double (unit-scale opts)))
-
-(defmethod renderer :stage [_]
+(defn stage
+  []
   (Stage.))
 
 ; cameras
 
-(defmulti camera identity :default :orthographic)
-
-(defmethod camera :orthographic [_]
+(defn orthographic-camera
+  []
   (OrthographicCamera.))
 
-(defmethod camera :perspective [_]
+(defn perspective-camera
+  []
   (PerspectiveCamera.))
 
 (defn resize-camera!