performance enhancements for tick's tales.

src/play_clj/core.clj

@@ -54,9 +54,7 @@
 
 (defn ^:private reset-changed!
   [e-atom e-old e-new]
-  (when (and (not= e-old e-new)
-             (compare-and-set! e-atom e-old e-new))
-    e-new))
+  (reset! e-atom e-new))
 
 (defn ^:private add-to-timeline!
   [screen-atom entities]
@@ -115,11 +113,19 @@
                       (update-fn! assoc :contact-listener)
                       update-screen!))
      :render (fn [d]
-               (swap! screen (fn [s]
-                               (-> s
-                                   (assoc :delta-time d)
-                                   (update-in [:total-time] #(unchecked-add (or ^double %1 0) ^double d)))))
-               (execute-fn! on-render @screen))
+               (let [s (.getTime (java.util.Date.))]
+                 (.begin (.getBatch ^Stage (:renderer @screen)))
+                 (swap! screen (fn [s]
+                                 (-> s
+                                     (assoc :delta-time 0.0167)
+                                     (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]

src/play_clj/core_graphics.clj

@@ -489,7 +489,7 @@ with the tiled map file at `path` and `unit` scale.
   [{:keys [^Stage renderer ^Camera camera ^ShaderProgram shader] :as screen} entities]
   (let [^Batch batch (.getBatch renderer)]
     (.setProjectionMatrix batch (.combined camera))
-    (.begin batch)
+    #_(.begin batch)
     
     (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)]
@@ -506,7 +506,7 @@ with the tiled map file at `path` and `unit` scale.
       
       (when (or additive?)
         (.setBlendFunction ^Batch batch (gl :gl-src-alpha) (gl :gl-one-minus-src-alpha))))
-    (.end batch))
+    #_(.end batch))
   entities)
 
 (defmethod draw! ModelBatch
@@ -550,7 +550,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

@@ -191,19 +191,22 @@ in the `screen`."
         (.setCamera camera)
         (.setWorldSize (. camera viewportWidth) (. camera viewportHeight)))))
   ([{: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)) ) ]
-         (.addActor renderer object)
+       #_(doseq [[_ object] entities
+               :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)))
-       (remove-input! renderer)
-       (add-input! renderer))))
+           (.addListener ^Actor (:object object) listener)))
+       )
+     (remove-input! renderer)
+       (add-input! renderer)))
 
 (defmulti update-physics!
   (fn [screen & entities] (some-> screen :world class .getName))

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)))
-          y (float (- (float (or y 0)) (or origin-y 0.0)))
+    (let [x (float (+ (- (float (or x 0)) (or origin-x 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)