Revert recent camera change & fix #5270

src/config/user_config.hpp

@@ -1037,12 +1037,12 @@ namespace UserConfigParams
                         "Camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_camera_normal,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_camera_normal,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1062,7 +1062,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_camera_normal,
             "Focal distance (single player)"));
 
@@ -1076,22 +1076,18 @@ namespace UserConfigParams
                             "The current used camera. 0=Custom; 1=Standard; 2=Drone chase") );
 
     // ---- Standard camera settings
-    PARAM_PREFIX BoolUserConfigParam       m_camera_updated_one_five
-            PARAM_DEFAULT(  BoolUserConfigParam(false, "camera-updated-one-five",
-                            "Used to update the standard camera values for users upgrading to 1.5") );
-
     PARAM_PREFIX GroupUserConfigParam        m_standard_camera_settings
             PARAM_DEFAULT( GroupUserConfigParam(
                         "standard-camera-settings",
                         "Standard camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_standard_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_standard_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1111,7 +1107,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_standard_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_standard_camera_settings,
             "Focal distance (single player)"));
 
@@ -1168,12 +1164,12 @@ namespace UserConfigParams
                         "Saved custom camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_saved_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_saved_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1193,7 +1189,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_saved_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_saved_camera_settings,
             "Focal distance (single player)"));
 
@@ -1474,4 +1470,4 @@ extern UserConfig *user_config;
 
 #endif
 
-/*EOF*/
+/*EOF*/

src/graphics/camera/camera.hpp

@@ -185,8 +185,6 @@ class Camera : public NoCopy
     /** Returns the type of this camera. */
     CameraType getType() { return m_type; }
     // ------------------------------------------------------------------------
-    bool isNormal() { return (m_type == CM_TYPE_NORMAL); }
-    // ------------------------------------------------------------------------
     /** Sets the field of view for the irrlicht camera. */
     void setFoV() { m_camera->setFOV(m_fov); }
     // ------------------------------------------------------------------------

src/graphics/camera/camera_normal.cpp

@@ -31,7 +31,6 @@
 #include "karts/kart.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/skidding.hpp"
-#include "network/rewind_manager.hpp"
 #include "tracks/track.hpp"
 
 // ============================================================================
@@ -45,7 +44,7 @@
  */
 CameraNormal::CameraNormal(Camera::CameraType type,  int camera_index, 
                            AbstractKart* kart) 
-            : Camera(type, camera_index, kart), m_camera_offset(0, 0, -15.0f)
+            : Camera(type, camera_index, kart), m_camera_offset(0., 1., -15.0f)
 {
     m_distance = kart ? UserConfigParams::m_camera_distance : 1000.0f;
     m_ambient_light = Track::getCurrentTrack()->getDefaultAmbientColor();
@@ -82,8 +81,6 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 {
     if(!m_kart) return;
 
-    if (RewindManager::get()->isRewinding()) return;
-
     Kart *kart = dynamic_cast<Kart*>(m_kart);
     if (kart->isFlying())
     {
@@ -105,34 +102,23 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
     float skid_factor = ks->getVisualSkidRotation();
 
     float skid_angle = asinf(skid_factor);
-
-    // Adjust the distance of the camera to the kart with speed
-    // Note that distance is negative (< 0)
     float ratio = current_speed / max_speed_without_zipper;
+
     ratio = ratio > -0.12f ? ratio : -0.12f;
-    float speed_factor = ((distance - 2.0f) - 1.0f * ratio) / (distance - 2.0f);
-    float camera_distance = distance * speed_factor;
 
-    // Adjust the camera angle
+    // distance of camera from kart in x and z plane
+    float camera_distance = -1.25f - 2.5f * ratio;
+    float min_distance = (distance * 2.0f);
+    if (distance > 0) camera_distance += distance + 1; // note that distance < 0
+    if (camera_distance > min_distance) camera_distance = min_distance; // don't get too close to the kart
+
     float tan_up = 0;
-    if (cam_angle > 0) tan_up = tanf(cam_angle) * std::max(distance - 1.0f, distance * (1.0f + 0.25f * ratio));
-    // Avoid a camera razing the ground (it generates a lot of terrain clipping with the current near value of 1.0)
-    if (tan_up > -0.5f)
-        tan_up = -0.5f;
-
-    // Defines how far the camera should be from the player's kart.
-    float squared_x = distance * sinf(skid_angle / 2);
-    squared_x *= squared_x;
-    float squared_y = tan_up;
-    squared_y *= squared_y;
-    float squared_z = distance * cosf(skid_angle / 2);
-    squared_z *= squared_z;
-    float length = sqrt(squared_x + squared_y + squared_z);
-    float camera_distance_factor = -camera_distance * camera_distance / length;
-
-    Vec3 wanted_camera_offset(camera_distance_factor * sinf(skid_angle / 2),
-        -tan_up,
-        camera_distance_factor * cosf(skid_angle / 2));
+    if (cam_angle > 0) tan_up = tanf(cam_angle) * distance;
+
+    // Defines how far camera should be from player kart.
+    Vec3 wanted_camera_offset(camera_distance * sinf(skid_angle / 2),
+        (0.85f + ratio / 2.5f) - tan_up,
+        camera_distance * cosf(skid_angle / 2));
 
     float delta = 1;
     float delta2 = 1;
@@ -189,10 +175,28 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 }   // moveCamera
 
 //-----------------------------------------------------------------------------
-void CameraNormal::snapToPosition()
+void CameraNormal::snapToPosition(bool reset_distance)
 {
-    float angle = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
-    moveCamera(1.0f, false, angle, -m_distance);
+    btTransform btt = m_kart->getSmoothedTrans();
+
+    if (reset_distance)
+    {
+        const Vec3& up = btt.getBasis().getColumn(1);
+        m_kart_position = btt.getOrigin();
+        m_kart_rotation = btt.getRotation();
+        m_camera->setUpVector(up.toIrrVector());
+        m_camera_offset = irr::core::vector3df(0., 1., -15.);
+    }
+    else
+    {
+        float angle = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
+        btQuaternion q1 = m_kart_rotation.normalized();
+        btQuaternion q2 = btt.getRotation().normalized();
+        moveCamera(1.0f, false, angle, -m_distance);
+
+        // Quick adjustion of camera direction
+        m_kart_rotation = q1.slerp(q2, 0.5f);
+    }
 }   // snapToPosition
 
 //-----------------------------------------------------------------------------
@@ -207,22 +211,6 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
                                      float *sideway, float *distance,
                                      bool *smoothing, float *cam_roll_angle)
 {
-    // Update the standard camera for users updating to 1.5
-    if(!UserConfigParams::m_camera_updated_one_five)
-    {
-        UserConfigParams::m_standard_camera_fov.revertToDefaults();
-        UserConfigParams::m_standard_camera_distance.revertToDefaults();
-        UserConfigParams::m_standard_camera_forward_up_angle.revertToDefaults();
-        if (UserConfigParams::m_camera_present == 1) // Currently using a standard camera 
-        {
-            UserConfigParams::m_camera_fov.revertToDefaults();
-            UserConfigParams::m_camera_distance.revertToDefaults();
-            UserConfigParams::m_camera_forward_up_angle.revertToDefaults();
-            m_distance = UserConfigParams::m_camera_distance;
-        }
-        UserConfigParams::m_camera_updated_one_five = true;
-    }
-
     switch(getMode())
     {
     case CM_NORMAL:
@@ -469,4 +457,4 @@ void CameraNormal::positionCamera(float dt, float above_kart, float cam_angle,
         btMatrix3x3 m(q);
         m_camera->setUpVector(((Vec3)m.getColumn(1)).toIrrVector());
     }
-}   // positionCamera
+}   // positionCamera

src/graphics/camera/camera_normal.hpp

@@ -73,8 +73,8 @@ class CameraNormal : public Camera
     virtual ~CameraNormal() {}
 public:
 
-    void snapToPosition();
-     // ------------------------------------------------------------------------
+    void snapToPosition(bool reset_distance);
+    // ------------------------------------------------------------------------
     bool isDebug() { return false; }
     // ------------------------------------------------------------------------
     bool isFPS() { return false; }
@@ -95,4 +95,4 @@ class CameraNormal : public Camera
 
 #endif
 
-/* EOF */
+/* EOF */

src/karts/controller/local_player_controller.cpp

@@ -272,7 +272,7 @@ void LocalPlayerController::update(int ticks)
             if (camera->getMode() == Camera::CM_REVERSE)
             {
                 camera->setMode(Camera::CM_NORMAL);
-                dynamic_cast<CameraNormal*>(camera)->snapToPosition();
+                dynamic_cast<CameraNormal*>(camera)->snapToPosition(false);
             }
         }
         if (m_sky_particles_emitter)

src/modes/world.cpp

@@ -895,10 +895,9 @@ void World::resetAllKarts()
         {
             Camera* cam = Camera::getCamera(i);
             cam->setInitialTransform();
-            // Ensure that smoothed cameras start from a correct position
-            if (cam->isNormal())
-                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
         }
+        m_snap_camera = true;
+        m_snap_reset_distance = true;
     }
 }   // resetAllKarts
 
@@ -946,6 +945,7 @@ void World::moveKartTo(AbstractKart* kart, const btTransform &transform)
     Track::getCurrentTrack()->getCheckManager()->resetAfterKartMove(kart);
 
     m_snap_camera = true;
+    m_snap_reset_distance = false;
 }   // moveKartTo
 
 // ----------------------------------------------------------------------------
@@ -1029,18 +1029,6 @@ void World::updateWorld(int ticks)
         m_schedule_unpause = false;
     }
 
-    if (m_snap_camera)
-    {
-        m_snap_camera = false;
-        for(unsigned int i=0; i<Camera::getNumCameras(); i++)
-        {
-            Camera* cam = Camera::getCamera(i);
-            // Ensure that smoothed cameras start from a correct position
-            if (cam->isNormal())
-                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
-        }
-    }
-
     // Don't update world if a menu is shown or the race is over.
     // Exceptions : - Networking (local pause doesn't affect the server or other players)
     //              - Benchmarking (a pause would mess up measurements)
@@ -1059,6 +1047,18 @@ void World::updateWorld(int ticks)
         return;
     }
 
+    if (m_snap_camera)
+    {
+        m_snap_camera = false;
+        for(unsigned int i=0; i<Camera::getNumCameras(); i++)
+        {
+            Camera* cam = Camera::getCamera(i);
+            // Ensure that smoothed cameras start from a correct position
+            dynamic_cast<CameraNormal*>(cam)->snapToPosition(m_snap_reset_distance);
+        }
+        m_snap_reset_distance = false;
+    }
+
 #ifdef DEBUG
     assert(m_magic_number == 0xB01D6543);
 #endif

src/modes/world.hpp

@@ -175,6 +175,7 @@ class World : public WorldStatus
     Phase m_scheduled_pause_phase;
 
     bool m_snap_camera;
+    bool m_snap_reset_distance;
 
     /** Set when the world needs to be deleted but you can't do it immediately
      * because you are e.g. within World::update()