Move frame prediction logic for camera from Sector to Camera

This makes it possible to avoid interpolating the camera position
when a Camera::move or other discontinuous transition is requested.

Author: mstoeckl

src/editor/editor.cpp

@@ -180,8 +180,6 @@ Editor::draw(Compositor& compositor)
       m_new_scale = 0.f;
     }
 
-    m_sector->pause_camera_interpolation();
-
     // Avoid drawing the sector if we're about to test it, as there is a dangling pointer
     // issue with the PlayerStatus.
     if (!m_leveltested)

src/object/camera.cpp

@@ -25,6 +25,7 @@
 #include "math/random.hpp"
 #include "math/util.hpp"
 #include "object/player.hpp"
+#include "supertux/constants.hpp"
 #include "supertux/gameconfig.hpp"
 #include "supertux/globals.hpp"
 #include "supertux/level.hpp"
@@ -82,7 +83,9 @@ Camera::Camera(const std::string& name) :
   m_scale_easing(),
   m_scale_anchor(),
   m_minimum_scale(1.f),
-  m_enfore_minimum_scale(false)
+  m_enfore_minimum_scale(false),
+  m_last_translation(0.0f, 0.0f),
+  m_last_scale(1.0f)
 {
 }
 
@@ -118,7 +121,9 @@ Camera::Camera(const ReaderMapping& reader) :
   m_scale_easing(),
   m_scale_anchor(),
   m_minimum_scale(1.f),
-  m_enfore_minimum_scale(false)
+  m_enfore_minimum_scale(false),
+  m_last_translation(0.0f, 0.0f),
+  m_last_scale(1.0f)
 {
   std::string modename;
 
@@ -207,6 +212,25 @@ Camera::check_state()
   PathObject::check_state();
 }
 
+void Camera::reset_prediction_state() {
+  m_last_translation = get_translation();
+  m_last_scale = get_current_scale();
+}
+
+Vector
+Camera::get_predicted_translation(float time_offset) const {
+  // TODO: extrapolate forwards instead of interpolating over the last frame
+  float x = time_offset * LOGICAL_FPS;
+  return get_translation() * x + (1 - x) * m_last_translation;
+}
+
+float
+Camera::get_predicted_scale(float time_offset) const {
+  // TODO: extrapolate forwards instead of interpolating over the last frame
+  float x = time_offset * LOGICAL_FPS;
+  return get_current_scale() * x + (1 - x) * m_last_scale;
+}
+
 const Vector
 Camera::get_translation() const
 {
@@ -218,6 +242,7 @@ void
 Camera::set_translation_centered(const Vector& translation)
 {
   m_translation = translation - m_screen_size.as_vector() / 2;
+  reset_prediction_state();
 }
 
 Rectf
@@ -237,6 +262,7 @@ Camera::reset(const Vector& tuxpos)
   keep_in_bounds(m_translation);
 
   m_cached_translation = m_translation;
+  reset_prediction_state();
 }
 
 void
@@ -286,6 +312,7 @@ Camera::scroll_to(const Vector& goal, float scrolltime)
     m_translation.x = goal.x;
     m_translation.y = goal.y;
     m_mode = Mode::MANUAL;
+    reset_prediction_state();
     return;
   }
 
@@ -313,6 +340,10 @@ Camera::draw(DrawingContext& context)
 void
 Camera::update(float dt_sec)
 {
+  // For use by camera position prediction
+  m_last_scale = get_current_scale();
+  m_last_translation = get_translation();
+
   // Minimum scale should be set during the update sequence; else, reset it.
   m_enfore_minimum_scale = false;
 
@@ -361,6 +392,8 @@ Camera::keep_in_bounds(const Rectf& bounds)
 
   // Remove any scale factor we may have added in the checks above.
   m_translation -= scale_factor;
+
+  reset_prediction_state();
 }
 
 void
@@ -754,6 +787,8 @@ Camera::ease_scale(float scale, float time, easing ease, AnchorPoint anchor)
     m_scale = scale;
     if (m_mode == Mode::MANUAL)
       m_translation = m_scale_target_translation;
+
+    reset_prediction_state();
   }
 }
 

src/object/camera.hpp

@@ -87,9 +87,16 @@ class Camera final : public LayerObject,
   /** reset camera position */
   void reset(const Vector& tuxpos);
 
+  /** Get the predicted position of the camera, time_offset seconds from now. */
+  Vector get_predicted_translation(float time_offset) const;
+  /** Get the predicted scale of the camera, time_offset seconds from now. */
+  float get_predicted_scale(float time_offset) const;
+
   /** return camera position */
   const Vector get_translation() const;
-  inline void set_translation(const Vector& translation) { m_translation = translation; }
+  inline void set_translation(const Vector& translation) {
+    m_translation = translation; reset_prediction_state();
+  }
   void set_translation_centered(const Vector& translation);
 
   void keep_in_bounds(const Rectf& bounds);
@@ -271,6 +278,10 @@ class Camera final : public LayerObject,
   Vector get_scale_anchor_target() const;
   void reload_scale();
 
+  /** This function should be called whenever the last updates/changes
+   * to the camera should not be interpolated or extrapolated. */
+  void reset_prediction_state();
+
 private:
   Mode m_mode;
   Mode m_defaultmode;
@@ -318,6 +329,13 @@ class Camera final : public LayerObject,
   float m_minimum_scale;
   bool m_enfore_minimum_scale;
 
+  // Remember last camera position, to linearly interpolate camera position
+  // when drawing frames that are predicted forward a fraction of a game step.
+  // This is somewhat of a hack: ideally these variables would not be necessary
+  // and one could predict the next camera scale/translation directly from the
+  // current camera member variable values.
+  Vector m_last_translation;
+  float m_last_scale;
 private:
   Camera(const Camera&) = delete;
   Camera& operator=(const Camera&) = delete;

src/supertux/sector.cpp

@@ -287,9 +287,6 @@ Sector::activate(const Vector& player_pos)
   if (!m_init_script.empty() && !Editor::is_active()) {
     run_script(m_init_script, "init-script");
   }
-
-  // Do not interpolate camera after it has been warped
-  pause_camera_interpolation();
 }
 
 void
@@ -361,12 +358,6 @@ Sector::update(float dt_sec)
 
   BIND_SECTOR(*this);
 
-  // Record last camera parameters, to allow for camera interpolation
-  Camera& camera = get_camera();
-  m_last_scale = camera.get_current_scale();
-  m_last_translation = camera.get_translation();
-  m_last_dt = dt_sec;
-
   m_squirrel_environment->update(dt_sec);
 
   GameObjectManager::update(dt_sec);
@@ -483,21 +474,8 @@ Sector::draw(DrawingContext& context)
   context.push_transform();
 
   Camera& camera = get_camera();
-
-  if (g_config->frame_prediction && m_last_dt > 0.f) {
-    // Interpolate between two camera settings; there are many possible ways to do this, but on
-    // short time scales all look about the same. This delays the camera position by one frame.
-    // (The proper thing to do, of course, would be not to interpolate, but instead to adjust
-    // the Camera class to extrapolate, and provide scale/translation at a given time; done
-    // right, this would make it possible to, for example, exactly sinusoidally shake the
-    // camera instead of piecewise linearly.)
-    float x = std::min(1.f, context.get_time_offset() / m_last_dt);
-    context.set_translation(camera.get_translation() * x + (1 - x) * m_last_translation);
-    context.scale(camera.get_current_scale() * x + (1 - x) * m_last_scale);
-  } else {
-    context.set_translation(camera.get_translation());
-    context.scale(camera.get_current_scale());
-  }
+  context.set_translation(camera.get_predicted_translation(context.get_time_offset()));
+  context.scale(camera.get_predicted_scale(context.get_time_offset()));
 
   GameObjectManager::draw(context);
 
@@ -742,12 +720,6 @@ Sector::stop_looping_sounds()
   }
 }
 
-void
-Sector::pause_camera_interpolation()
-{
-  m_last_dt = 0.;
-}
-
 void Sector::play_looping_sounds()
 {
   for (const auto& object : get_objects()) {

src/supertux/sector.hpp

@@ -99,9 +99,6 @@ class Sector final : public Base::Sector
   /** stops all looping sounds in whole sector. */
   void stop_looping_sounds();
 
-  /** Freeze camera position for this frame, preventing camera interpolation jumps and loops */
-  void pause_camera_interpolation();
-
   /** continues the looping sounds in whole sector. */
   void play_looping_sounds();
 
@@ -263,10 +260,6 @@ class Sector final : public Base::Sector
 
   TextObject& m_text_object;
 
-  Vector m_last_translation; // For camera interpolation at high frame rates
-  float m_last_scale;
-  float m_last_dt;
-
 private:
   Sector(const Sector&) = delete;
   Sector& operator=(const Sector&) = delete;