add camera settings in option screen (#4273)

* add camera settings in option screen

* Remove camera settings (distance, backward/forward angles, smoothing) from kart characteristics

Co-authored-by: luffah <luffah@runbox.com>

data/gui/dialogs/custom_camera_settings.stkgui

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<stkgui>
+    <div x="2%" y="1%" width="96%" height="98%" layout="vertical-row" >
+        <header id="title" width="100%" height="fit" text_align="center" word_wrap="true" text="Camera Settings" />
+        <spacer width="100%" height="3%"/>
+        <div width="100%" height="91%" layout="vertical-row" >
+
+            <label width="100%" I18N="In the ui/camera settings" text="Player camera"/>
+            <spacer width="5" height="1%"/>
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <label width="20%" height="100%" I18N="In the ui/camera screen" text="FOV"/>
+                    <gauge id="fov" proportion="1"/>
+                </div>
+            </div>
+
+            <spacer height="2%" width="100%" />
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <label width="20%" height="100%" text_align="left" I18N="In the ui/camera screen" text="Distance"/>
+                    <gauge id="camera_distance" proportion="1"/>
+                </div>
+            </div>
+
+            <spacer height="2%" width="100%" />
+
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <label width="20%" height="100%" text_align="left" I18N="In the ui/camera screen" text="Angle"/>
+                    <gauge id="camera_angle" proportion="1"/>
+                </div>
+            </div>
+
+            <spacer height="2%" width="100%" />
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <checkbox id="camera_smoothing"/>
+                    <spacer width="1%" height="100%" />
+                    <label height="100%" text_align="left" I18N="In the ui/camera screen" text="Smoothing"/>
+                </div>
+            </div>
+
+
+            <spacer width="5" height="2%"/>
+            <label width="100%" I18N="In the ui/camera settings" text="Backward camera"/>
+            <spacer width="5" height="1%"/>
+
+            <spacer height="2%" width="100%" />
+
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <label width="20%" height="100%" text_align="left" I18N="In the ui/camera screen" text="Angle"/>
+                    <gauge id="backward_camera_angle" proportion="1"/>
+                </div>
+            </div>
+
+            <spacer height="2%" width="100%" />
+
+            <div width="100%" height="fit" layout="horizontal-row">
+                <spacer width="3%" height="100%" />
+                <div proportion="1" height="fit" layout="horizontal-row" >
+                    <checkbox id="use_soccer_camera"/>
+                    <spacer width="1%" height="100%" />
+                    <label height="100%" text_align="left" I18N="In the ui/camera screen" text="Follow ball in soccer mode"/>
+                </div>
+            </div>
+
+            <spacer width="100%" height="2%"/>
+            <button id="close" text="Apply" align="center"/>
+            <spacer width="100%" height="1%"/>
+        </div>
+    </div>
+</stkgui>

data/gui/screens/options_ui.stkgui

@@ -75,6 +75,21 @@
 
                 <spacer width="5" height="2%"/>
 
+                <!-- ************ GRAPHICAL EFFECTS SETTINGS ************ -->
+                <div width="100%" height="fit" layout="horizontal-row">
+                    <div layout="vertical-row" width="10f" height="fit">
+                        <spinner id="camera_preset" width="100%" align="center" />
+                    </div>
+                    <div layout="vertical-row" proportion="1" height="100%">
+                        <label height="100%" I18N="In the ui settings" text="Camera" align="left"/>
+                    </div>
+                    <div layout="vertical-row" proportion="1" height="100%" id="outer_box" >
+                        <button id="custom_camera" text="Custom..." I18N="In the ui settings" align="center"/>
+                    </div>
+                </div>
+
+                <spacer width="5" height="2%"/>
+
                 <div layout="horizontal-row" width="100%" height="fit">
                     <checkbox id="showfps"/>
                     <spacer width="1%" height="100%" />
@@ -91,7 +106,6 @@
 
                 <spacer width="5" height="2%"/>
 
-
                 <div layout="horizontal-row" width="100%" height="fit">
                     <checkbox id="story-mode-timer"/>
                     <spacer width="1%" height="100%" />

src/config/user_config.hpp

@@ -937,6 +937,38 @@ namespace UserConfigParams
             PARAM_DEFAULT(  BoolUserConfigParam(false, "crashed") );
 
     // ---- Camera
+    PARAM_PREFIX GroupUserConfigParam        m_camera_normal
+            PARAM_DEFAULT( GroupUserConfigParam(
+                        "camera-normal",
+                        "Camera settings for player.") );
+
+    PARAM_PREFIX FloatUserConfigParam         m_camera_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(0, "forward-up-angle",
+            &m_camera_normal,
+            "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
+
+    PARAM_PREFIX BoolUserConfigParam         m_camera_forward_smoothing
+            PARAM_DEFAULT(  BoolUserConfigParam(true, "forward-smoothing",
+            &m_camera_normal,
+            "if true, use smoothing (forward-up-angle become relative to speed) when pointing forward"));
+
+    PARAM_PREFIX FloatUserConfigParam         m_camera_backward_up_angle
+            PARAM_DEFAULT(  FloatUserConfigParam(5, "backward-up-angle",
+            &m_camera_normal,
+            "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(80, "fov",
+            &m_camera_normal,
+            "Focal distance (single player)"));
+
+
+    // camera in artist mode
     PARAM_PREFIX GroupUserConfigParam        m_camera
             PARAM_DEFAULT( GroupUserConfigParam("camera",
                                                 "(Debug) camera settings.") );

src/graphics/camera.cpp

@@ -175,9 +175,15 @@ void Camera::setupCamera()
         float(irr_driver->getActualScreenSize().Width) / m_viewport.getWidth() , 
         float(irr_driver->getActualScreenSize().Height) / m_viewport.getHeight());
 
+    if (RaceManager::get()->getNumLocalPlayers() > 0)
+    {
         m_fov = DEGREE_TO_RAD * stk_config->m_camera_fov
-        [RaceManager::get()->getNumLocalPlayers() > 0 ?
+          [RaceManager::get()->getNumLocalPlayers() - 1];
-        RaceManager::get()->getNumLocalPlayers() - 1 : 0];
+    }
+    else
+    {
+        m_fov = DEGREE_TO_RAD * UserConfigParams::m_camera_fov;
+    }
 
     m_camera->setFOV(m_fov);
     m_camera->setAspectRatio(m_aspect);

src/graphics/camera_debug.cpp

@@ -20,6 +20,7 @@
 #include "graphics/camera_debug.hpp"
 
 #include "config/stk_config.hpp"
+#include "config/user_config.hpp"
 #include "karts/abstract_kart.hpp"
 #include "karts/explosion_animation.hpp"
 #include "karts/kart.hpp"
@@ -55,8 +56,6 @@ CameraDebug::~CameraDebug()
 void CameraDebug::getCameraSettings(float *above_kart, float *cam_angle,
                                     float *sideway, float *distance    )
 {
-    const KartProperties *kp = getKart()->getKartProperties();
-
     // Set some default values
     float steering = m_kart->getSteerPercent()
                    * (1.0f + (m_kart->getSkidding()->getSkidFactor()
@@ -78,7 +77,7 @@ void CameraDebug::getCameraSettings(float *above_kart, float *cam_angle,
     case CM_DEBUG_SIDE_OF_KART:
     case CM_DEBUG_TOP_OF_KART:
         *above_kart    = 0.75f;
-        *cam_angle     = kp->getCameraForwardUpAngle() * DEGREE_TO_RAD;
+        *cam_angle     = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
         *distance      = -m_distance;
         break;
     }   // switch 

src/graphics/camera_end.cpp

@@ -18,6 +18,7 @@
 
 #include "graphics/camera_end.hpp"
 
+#include "config/user_config.hpp"
 #include "karts/abstract_kart.hpp"
 #include "karts/kart_properties.hpp"
 #include "race/race_manager.hpp"
@@ -133,7 +134,7 @@ void CameraEnd::update(float dt)
         }
     case EndCameraInformation::EC_AHEAD_OF_KART:
         {
-            float cam_angle = m_kart->getKartProperties()->getCameraBackwardUpAngle()
+            float cam_angle = UserConfigParams::m_camera_backward_up_angle
                             * DEGREE_TO_RAD;
 
             positionCamera(dt, /*above_kart*/0.75f,

src/graphics/camera_normal.cpp

@@ -46,7 +46,7 @@ CameraNormal::CameraNormal(Camera::CameraType type,  int camera_index,
                            AbstractKart* kart) 
             : Camera(type, camera_index, kart), m_camera_offset(0, 0, -15.0f)
 {
-    m_distance = kart ? kart->getKartProperties()->getCameraDistance() : 1000.0f;
+    m_distance = kart ? UserConfigParams::m_camera_distance : 1000.0f;
     m_ambient_light = Track::getCurrentTrack()->getDefaultAmbientColor();
 
     // TODO: Put these values into a config file
@@ -192,15 +192,13 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
                                      float *sideway, float *distance,
                                      bool *smoothing, float *cam_roll_angle)
 {
-    const KartProperties *kp = m_kart->getKartProperties();
-
     switch(getMode())
     {
     case CM_NORMAL:
     case CM_FALLING:
         {
             *above_kart = 0.75f;
-            *cam_angle = kp->getCameraForwardUpAngle() * DEGREE_TO_RAD;
+            *cam_angle = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
             *distance = -m_distance;
             float steering = m_kart->getSteerPercent()
                            * (1.0f + (m_kart->getSkidding()->getSkidFactor()
@@ -208,7 +206,7 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
             // quadratically to dampen small variations (but keep sign)
             float dampened_steer = fabsf(steering) * steering;
             *sideway             = -m_rotation_range*dampened_steer*0.5f;
-            *smoothing           = kp->getCameraForwardSmoothing();
+            *smoothing           = UserConfigParams::m_camera_forward_smoothing;
             *cam_roll_angle      = 0.0f;
             if (UserConfigParams::m_multitouch_controls == MULTITOUCH_CONTROLS_GYROSCOPE)
             {
@@ -223,7 +221,7 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
     case CM_REVERSE: // Same as CM_NORMAL except it looks backwards
         {
             *above_kart = 0.75f;
-            *cam_angle  = kp->getCameraBackwardUpAngle() * DEGREE_TO_RAD;
+            *cam_angle  = UserConfigParams::m_camera_backward_up_angle * DEGREE_TO_RAD;
             *sideway    = 0;
             *distance   = 2.0f*m_distance;
             *smoothing  = false;

src/graphics/camera_normal.hpp

@@ -84,6 +84,8 @@ public:
     /** Sets the ambient light for this camera. */
     void setAmbientLight(const video::SColor &color) { m_ambient_light=color; }
     // ------------------------------------------------------------------------
+    void setDistanceToKart(float distance) { m_distance = distance; }
+    // ------------------------------------------------------------------------
     float getDistanceToKart() const { return m_distance; }
     // ------------------------------------------------------------------------
     /** Returns the current ambient light. */

src/guiengine/widgets/spinner_widget.cpp

@@ -98,10 +98,20 @@ SpinnerWidget::SpinnerWidget(const bool gauge) : Widget(WTYPE_SPINNER)
     m_spinner_widget_player_id=-1;
     m_min = 0;
     m_max = 999;
+    m_step = 1.0;
     m_left_selected = false;
     m_right_selected = false;
 }
 
+// -----------------------------------------------------------------------------
+void SpinnerWidget::setRange(int min, int max, float step)
+{
+    clearLabels();
+    setStep(step);
+    setMin(min/step);
+    setMax(max/step);
+}
+
 // -----------------------------------------------------------------------------
 
 void SpinnerWidget::add()
@@ -420,9 +430,19 @@ void SpinnerWidget::setValue(const int new_value)
         m_children[1].m_element->setText( text.c_str() );
     }
     else if (m_children.size() > 0)
+    {
+        if (m_step == 1.0)
         {
             m_children[1].m_element->setText( stringw(m_value).c_str() );
         }
+        else
+        {
+            std::wstringstream ws;
+            ws << (m_value*m_step);
+            std::wstring text = ws.str();
+            m_children[1].m_element->setText( text.c_str() );
+        }
+    }
 }
 
 // -----------------------------------------------------------------------------

src/guiengine/widgets/spinner_widget.hpp

@@ -57,6 +57,7 @@ namespace GUIEngine
         ISpinnerConfirmListener* m_listener;
         
         int m_value, m_min, m_max;
+        float m_step;
         
         int m_spinner_widget_player_id;
         bool m_use_background_color;
@@ -156,9 +157,6 @@ namespace GUIEngine
             return false;
         }
 
-
-
-
         void setListener(ISpinnerConfirmListener* listener) { m_listener = listener; }
 
         /** \brief implement method from base class Widget */
@@ -170,6 +168,12 @@ namespace GUIEngine
          */
         void setValue(const int new_value);
 
+        /**
+         * \brief            sets the float value of the spinner
+         * \param new_value  the new value that will be become the current value of this spinner.
+         */
+        void setFloatValue(const float new_value) { setValue(int(round(new_value/m_step))); }
+        
         /**
           * \brief        sets the current value of the spinner
           * \pre the 'new_value' string passed must be the name of an item
@@ -188,6 +192,12 @@ namespace GUIEngine
          */
         int  getValue() const { return m_value; }
 
+        /**
+         * \brief retrieve the current value of the spinner
+         * \return the current value of the spinner, in a float form
+         */
+        float getFloatValue() const { return m_value*m_step; }
+        
         /**
           * \brief retrieve the current value of the spinner
           * \return the current value of the spinner, in a string form
@@ -205,6 +215,18 @@ namespace GUIEngine
             return m_labels[id];
         }
 
+        /**
+          * \return the step value of the spinner
+          */
+        // --------------------------------------------------------------------
+        /** Returns the step value. */
+        float  getStep()  const { return m_step; }
+        // --------------------------------------------------------------------
+        /** \brief Sets the maximum value for a spinner.
+         *  If the current value is larger than the new maximum, the current
+         *  value is set to the new maximum. */
+        void setStep(float n) { m_step = n; }
+        // --------------------------------------------------------------------
         /**
           * \return the maximum value the spinner can take
           */
@@ -242,6 +264,11 @@ namespace GUIEngine
         /** Display custom text in spinner */
         void setCustomText(const core::stringw& text);
         const core::stringw& getCustomText() const { return m_custom_text; }
+
+        /* Set a spinner with numeric values min <= i <= max, with a precision of defined by step */
+        void setRange(int min, int max, float step);
+        void setRange(int min, int max) { setRange(min, max, 1.0); }
+
         void onPressed(int x, int y);
         void doValueUpdatedCallback()
         {
@@ -253,6 +280,7 @@ namespace GUIEngine
         {
             m_value_updated_callback = callback;
         }
+
     };
 
 }

src/karts/abstract_characteristic.cpp

@@ -107,14 +107,6 @@ AbstractCharacteristic::ValueType AbstractCharacteristic::getType(
         return TYPE_FLOAT;
     case WHEELS_DAMPING_COMPRESSION:
         return TYPE_FLOAT;
-    case CAMERA_DISTANCE:
-        return TYPE_FLOAT;
-    case CAMERA_FORWARD_UP_ANGLE:
-        return TYPE_FLOAT;
-    case CAMERA_FORWARD_SMOOTHING:
-        return TYPE_BOOL;
-    case CAMERA_BACKWARD_UP_ANGLE:
-        return TYPE_FLOAT;
     case JUMP_ANIMATION_TIME:
         return TYPE_FLOAT;
     case LEAN_MAX:
@@ -349,14 +341,6 @@ std::string AbstractCharacteristic::getName(CharacteristicType type)
         return "WHEELS_DAMPING_RELAXATION";
     case WHEELS_DAMPING_COMPRESSION:
         return "WHEELS_DAMPING_COMPRESSION";
-    case CAMERA_DISTANCE:
-        return "CAMERA_DISTANCE";
-    case CAMERA_FORWARD_UP_ANGLE:
-        return "CAMERA_FORWARD_UP_ANGLE";
-    case CAMERA_FORWARD_SMOOTHING:
-        return "CAMERA_FORWARD_SMOOTHING";
-    case CAMERA_BACKWARD_UP_ANGLE:
-        return "CAMERA_BACKWARD_UP_ANGLE";
     case JUMP_ANIMATION_TIME:
         return "JUMP_ANIMATION_TIME";
     case LEAN_MAX:
@@ -843,53 +827,6 @@ float AbstractCharacteristic::getWheelsDampingCompression() const
     return result;
 }  // getWheelsDampingCompression
 
-// ----------------------------------------------------------------------------
-float AbstractCharacteristic::getCameraDistance() const
-{
-    float result;
-    bool is_set = false;
-    process(CAMERA_DISTANCE, &result, &is_set);
-    if (!is_set)
-        Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
-                    getName(CAMERA_DISTANCE).c_str());
-    return result;
-}  // getCameraDistance
-
-// ----------------------------------------------------------------------------
-float AbstractCharacteristic::getCameraForwardUpAngle() const
-{
-    float result;
-    bool is_set = false;
-    process(CAMERA_FORWARD_UP_ANGLE, &result, &is_set);
-    if (!is_set)
-        Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
-                    getName(CAMERA_FORWARD_UP_ANGLE).c_str());
-    return result;
-}  // getCameraForwardUpAngle
-
-// ----------------------------------------------------------------------------
-bool AbstractCharacteristic::getCameraForwardSmoothing() const
-{
-    bool result;
-    bool is_set = false;
-    process(CAMERA_FORWARD_SMOOTHING, &result, &is_set);
-    if (!is_set)
-        Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
-                    getName(CAMERA_FORWARD_SMOOTHING).c_str());
-    return result;
-}  // getCameraForwardSmoothing
-
-// ----------------------------------------------------------------------------
-float AbstractCharacteristic::getCameraBackwardUpAngle() const
-{
-    float result;
-    bool is_set = false;
-    process(CAMERA_BACKWARD_UP_ANGLE, &result, &is_set);
-    if (!is_set)
-        Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
-                    getName(CAMERA_BACKWARD_UP_ANGLE).c_str());
-    return result;
-}  // getCameraBackwardUpAngle
 
 // ----------------------------------------------------------------------------
 float AbstractCharacteristic::getJumpAnimationTime() const

src/karts/abstract_characteristic.hpp

@@ -111,12 +111,6 @@ public:
         WHEELS_DAMPING_RELAXATION,
         WHEELS_DAMPING_COMPRESSION,
 
-        // Camera
-        CAMERA_DISTANCE,
-        CAMERA_FORWARD_UP_ANGLE,
-        CAMERA_FORWARD_SMOOTHING,
-        CAMERA_BACKWARD_UP_ANGLE,
-
         // Jump
         JUMP_ANIMATION_TIME,
 

src/karts/kart_properties.cpp

@@ -21,6 +21,7 @@
 #include "audio/sfx_manager.hpp"
 #include "addons/addon.hpp"
 #include "audio/sfx_manager.hpp"
+#include "config/user_config.hpp"
 #include "config/stk_config.hpp"
 #include "config/player_manager.hpp"
 #include "graphics/central_settings.hpp"
@@ -354,6 +355,7 @@ void KartProperties::combineCharacteristics(HandicapLevel handicap)
     m_combined_characteristic->addCharacteristic(kart_properties_manager->
         getDifficultyCharacteristic(RaceManager::get()->getDifficultyAsString(
             RaceManager::get()->getDifficulty())));
+    // FIXME add get user characteristics
 
     // Try to get the kart type
     const AbstractCharacteristic *characteristic = kart_properties_manager->
@@ -773,29 +775,6 @@ float KartProperties::getWheelsDampingCompression() const
     return m_cached_characteristic->getWheelsDampingCompression();
 }  // getWheelsDampingCompression
 
-// ----------------------------------------------------------------------------
-float KartProperties::getCameraDistance() const
-{
-    return m_cached_characteristic->getCameraDistance();
-}  // getCameraDistance
-
-// ----------------------------------------------------------------------------
-float KartProperties::getCameraForwardUpAngle() const
-{
-    return m_cached_characteristic->getCameraForwardUpAngle();
-}  // getCameraForwardUpAngle
-
-// ----------------------------------------------------------------------------
-bool KartProperties::getCameraForwardSmoothing() const
-{
-    return m_cached_characteristic->getCameraForwardSmoothing();
-}  // getCameraForwardSmoothing
-
-// ----------------------------------------------------------------------------
-float KartProperties::getCameraBackwardUpAngle() const
-{
-    return m_cached_characteristic->getCameraBackwardUpAngle();
-}  // getCameraBackwardUpAngle
 
 // ----------------------------------------------------------------------------
 float KartProperties::getJumpAnimationTime() const

src/karts/kart_properties.hpp

@@ -407,11 +407,6 @@ public:
     float getWheelsDampingRelaxation() const;
     float getWheelsDampingCompression() const;
 
-    float getCameraDistance() const;
-    float getCameraForwardUpAngle() const;
-    bool getCameraForwardSmoothing() const;
-    float getCameraBackwardUpAngle() const;
-
     float getJumpAnimationTime() const;
 
     float getLeanMax() const;

src/karts/xml_characteristic.cpp

@@ -1,4 +1,4 @@
-//
+
 //  SuperTuxKart - a fun racing game with go-kart
 //  Copyright (C) 2006-2015 SuperTuxKart-Team
 //
@@ -397,18 +397,6 @@ void XmlCharacteristic::load(const XMLNode *node)
             &m_values[WHEELS_DAMPING_COMPRESSION]);
     }
 
-    if (const XMLNode *sub_node = node->getNode("camera"))
-    {
-        sub_node->get("distance",
-            &m_values[CAMERA_DISTANCE]);
-        sub_node->get("forward-up-angle",
-            &m_values[CAMERA_FORWARD_UP_ANGLE]);
-        sub_node->get("forward-smoothing",
-            &m_values[CAMERA_FORWARD_SMOOTHING]);
-        sub_node->get("backward-up-angle",
-            &m_values[CAMERA_BACKWARD_UP_ANGLE]);
-    }
-
     if (const XMLNode *sub_node = node->getNode("jump"))
     {
         sub_node->get("animation-time",

src/states_screens/dialogs/custom_camera_settings.cpp

@@ -0,0 +1,97 @@
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2009-2015 Marianne Gagnon
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "states_screens/dialogs/custom_camera_settings.hpp"
+
+#include "config/user_config.hpp"
+#include "guiengine/widgets/check_box_widget.hpp"
+#include "guiengine/widgets/spinner_widget.hpp"
+#include "states_screens/options/options_screen_ui.hpp"
+#include "utils/translation.hpp"
+#include "graphics/central_settings.hpp"
+#include "graphics/irr_driver.hpp"
+#include "utils/string_utils.hpp"
+#include "utils/translation.hpp"
+
+#include <IGUIEnvironment.h>
+
+
+using namespace GUIEngine;
+using namespace irr;
+using namespace irr::core;
+using namespace irr::gui;
+
+// -----------------------------------------------------------------------------
+
+CustomCameraSettingsDialog::CustomCameraSettingsDialog(const float w, const float h) :
+        ModalDialog(w, h)
+{
+    m_self_destroy = false;
+    loadFromFile("custom_camera_settings.stkgui");
+    getWidget<SpinnerWidget>("fov")->setValue(UserConfigParams::m_camera_fov);
+    getWidget<SpinnerWidget>("camera_distance")->setFloatValue(UserConfigParams::m_camera_distance);
+    getWidget<SpinnerWidget>("camera_angle")->setValue(UserConfigParams::m_camera_forward_up_angle);
+    getWidget<CheckBoxWidget>("camera_smoothing")->setState(UserConfigParams::m_camera_forward_smoothing);
+    getWidget<SpinnerWidget>("backward_camera_angle")->setValue(UserConfigParams::m_camera_backward_up_angle);
+//    updateActivation();
+}
+
+// -----------------------------------------------------------------------------
+
+CustomCameraSettingsDialog::~CustomCameraSettingsDialog()
+{
+}
+
+
+// -----------------------------------------------------------------------------
+
+void CustomCameraSettingsDialog::beforeAddingWidgets()
+{
+#ifndef SERVER_ONLY
+    getWidget<SpinnerWidget>("fov")->setRange(75, 115);
+    getWidget<SpinnerWidget>("fov")->setValue(UserConfigParams::m_camera_fov);
+    getWidget<SpinnerWidget>("camera_distance")->setRange(0 , 20, 0.1);
+    getWidget<SpinnerWidget>("camera_distance")->setFloatValue(UserConfigParams::m_camera_distance);
+    getWidget<SpinnerWidget>("camera_angle")->setRange(0 , 45);
+    getWidget<SpinnerWidget>("camera_angle")->setValue(UserConfigParams::m_camera_forward_up_angle);
+    getWidget<CheckBoxWidget>("camera_smoothing")->setState(UserConfigParams::m_camera_forward_smoothing);
+    getWidget<SpinnerWidget>("backward_camera_angle")->setRange(0 , 45);
+    getWidget<SpinnerWidget>("backward_camera_angle")->setValue(UserConfigParams::m_camera_backward_up_angle);
+    getWidget<CheckBoxWidget>("use_soccer_camera")->setState(UserConfigParams::m_reverse_look_use_soccer_cam);
+#endif
+}
+
+// -----------------------------------------------------------------------------
+
+GUIEngine::EventPropagation CustomCameraSettingsDialog::processEvent(const std::string& eventSource)
+{
+#ifndef SERVER_ONLY
+    if (eventSource == "close")
+    {
+        UserConfigParams::m_camera_fov = getWidget<SpinnerWidget>("fov")->getValue();
+        UserConfigParams::m_camera_distance = getWidget<SpinnerWidget>("camera_distance")->getFloatValue();
+        UserConfigParams::m_camera_forward_up_angle = getWidget<SpinnerWidget>("camera_angle")->getValue();
+        UserConfigParams::m_camera_forward_smoothing = getWidget<CheckBoxWidget>("camera_smoothing")->getState();
+        UserConfigParams::m_camera_backward_up_angle = getWidget<SpinnerWidget>("backward_camera_angle")->getValue();
+        UserConfigParams::m_reverse_look_use_soccer_cam = getWidget<CheckBoxWidget>("use_soccer_camera")->getState();
+        OptionsScreenUI::getInstance()->updateCameraPresetSpinner();
+        m_self_destroy = true;
+        return GUIEngine::EVENT_BLOCK;
+    }
+#endif
+    return GUIEngine::EVENT_LET;
+}   // processEvent

src/states_screens/dialogs/custom_camera_settings.hpp

@@ -0,0 +1,63 @@
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2009-2015 Marianne Gagnon
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+
+#ifndef HEADER_CUSTOM_CAMERA_SETTINGS_HPP
+#define HEADER_CUSTOM_CAMERA_SETTINGS_HPP
+
+#include "guiengine/modaldialog.hpp"
+
+/**
+ * \brief Dialog that allows the player to select custom video settings
+ * \ingroup states_screens
+ */
+class CustomCameraSettingsDialog : public GUIEngine::ModalDialog
+{
+private:
+    bool m_self_destroy;
+public:
+    /**
+     * Creates a modal dialog with given percentage of screen width and height
+     */
+    CustomCameraSettingsDialog(const float percentWidth, const float percentHeight);
+    ~CustomCameraSettingsDialog();
+
+    virtual void beforeAddingWidgets();
+
+    void updateActivation();
+
+    GUIEngine::EventPropagation processEvent(const std::string& eventSource);
+
+    virtual bool onEscapePressed()
+    {
+        m_self_destroy = true;
+        return false;
+    }
+
+    virtual void onUpdate(float dt)
+    {
+        // It's unsafe to delete from inside the event handler so we do it here
+        if (m_self_destroy)
+        {
+            ModalDialog::dismiss();
+            return;
+        }
+    }
+    
+};
+
+#endif

src/states_screens/options/options_screen_ui.cpp

@@ -20,10 +20,13 @@
 #include "addons/news_manager.hpp"
 #include "audio/sfx_manager.hpp"
 #include "audio/sfx_base.hpp"
+#include "graphics/camera.hpp"
+#include "graphics/camera_normal.hpp"
 #include "challenges/story_mode_timer.hpp"
 #include "config/hardware_stats.hpp"
 #include "config/player_manager.hpp"
 #include "config/user_config.hpp"
+#include "config/stk_config.hpp"
 #include "font/bold_face.hpp"
 #include "font/font_manager.hpp"
 #include "font/regular_face.hpp"
@@ -41,6 +44,7 @@
 #include "online/request_manager.hpp"
 #include "states_screens/dialogs/message_dialog.hpp"
 #include "states_screens/main_menu_screen.hpp"
+#include "states_screens/dialogs/custom_camera_settings.hpp"
 #include "states_screens/options/options_screen_audio.hpp"
 #include "states_screens/options/options_screen_general.hpp"
 #include "states_screens/options/options_screen_input.hpp"
@@ -143,6 +147,9 @@ void OptionsScreenUI::loadedFromFile()
         font_size->m_properties[GUIEngine::PROP_MIN_VALUE] = "1";
         font_size->m_properties[GUIEngine::PROP_MAX_VALUE] = "5";
     }
+
+    updateCameraPresetSpinner();
+
     font_size->setValueUpdatedCallback([this](SpinnerWidget* spinner)
     {
         // Add a special value updated callback so font size is updated when
@@ -155,6 +162,7 @@ void OptionsScreenUI::loadedFromFile()
         m_reload_option->m_focus_name = "font_size";
         m_reload_option->m_focus_right = right;
     });
+
 }   // loadedFromFile
 
 // -----------------------------------------------------------------------------
@@ -328,8 +336,81 @@ void OptionsScreenUI::init()
         GUIEngine::reloadSkin();
         irr_driver->setMaxTextureSize();
     }
+
+    // Camera presets
+    m_camera_presets.push_back // Standard
+    ({
+        80 /* fov */, 1.0f /* distance */, 0.0f  /* angle */, true /* smoothing */, 5.0f /* backward angle */,
+    });
+
+    m_camera_presets.push_back // Drone chase
+    ({
+        100 /* fov */, 2.6f /* distance */, 33.0f  /* angle */, false /* smoothing */, 10.0f /* backward angle */,
+    });
+
+    GUIEngine::SpinnerWidget* camera_preset = getWidget<GUIEngine::SpinnerWidget>("camera_preset");
+    assert( camera_preset != NULL );
+
+    camera_preset->m_properties[PROP_WRAP_AROUND] = "true";
+    camera_preset->clearLabels();
+    //I18N: custom camera setting
+    camera_preset->addLabel( core::stringw(_("Custom")));
+    //I18N: In the UI options,litscreen_method in the race UI
+    camera_preset->addLabel( core::stringw(_("Standard")));
+    //I18N: In the UI options, splitscreen_method position in the race UI
+    camera_preset->addLabel( core::stringw(_("Drone chase")));
+    camera_preset->m_properties[GUIEngine::PROP_MIN_VALUE] = "1";
+    camera_preset->m_properties[GUIEngine::PROP_MAX_VALUE] = "2";
+
+    updateCameraPresetSpinner();
 }   // init
 
+void updateCamera()
+{
+  bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
+  if (in_game)
+  {
+    (Camera::getActiveCamera()->getCameraSceneNode())->setFOV(DEGREE_TO_RAD * UserConfigParams::m_camera_fov);
+    CameraNormal *camera = dynamic_cast<CameraNormal*>(Camera::getActiveCamera());
+    if (camera)
+    {
+       camera->setDistanceToKart(UserConfigParams::m_camera_distance);
+    }
+  }
+}
+
+void OptionsScreenUI::updateCameraPresetSpinner()
+{
+    GUIEngine::SpinnerWidget* camera_preset = getWidget<GUIEngine::SpinnerWidget>("camera_preset");
+    assert( camera_preset != NULL );
+
+#define FLOAT_EPSILON 0.001
+
+    bool found = false;
+    unsigned int i = 0;
+    for (; i < m_camera_presets.size(); i++)
+    {
+        if (m_camera_presets[i].fov == UserConfigParams::m_camera_fov &&
+            m_camera_presets[i].smoothing == UserConfigParams::m_camera_forward_smoothing &&
+            fabs(m_camera_presets[i].distance - UserConfigParams::m_camera_distance) < FLOAT_EPSILON &&
+            fabs(m_camera_presets[i].angle - UserConfigParams::m_camera_forward_up_angle) < FLOAT_EPSILON &&
+            fabs(m_camera_presets[i].backward_angle - UserConfigParams::m_camera_backward_up_angle) < FLOAT_EPSILON)
+        {
+            camera_preset->setValue(i + 1);
+            found = true;
+            break;
+        }
+    }
+
+    if (!found)
+    {
+        camera_preset->setValue(0);
+        camera_preset->m_properties[GUIEngine::PROP_MIN_VALUE] = std::to_string(0);
+    }
+    updateCamera();
+
+} // updateCameraPresetSpinner
+
 // -----------------------------------------------------------------------------
 
 void OptionsScreenUI::eventCallback(Widget* widget, const std::string& name, const int playerID)
@@ -456,6 +537,24 @@ void OptionsScreenUI::eventCallback(Widget* widget, const std::string& name, con
         }
         UserConfigParams::m_speedrun_mode = speedrun_timer->getState();
     }
+    else if (name == "camera_preset")
+    {
+        GUIEngine::SpinnerWidget* camera_preset = getWidget<GUIEngine::SpinnerWidget>("camera_preset");
+        assert( camera_preset != NULL );
+        unsigned int i = camera_preset->getValue();
+        if (i != 0) {
+            UserConfigParams::m_camera_fov = m_camera_presets[i-1].fov;
+            UserConfigParams::m_camera_distance = m_camera_presets[i-1].distance;
+            UserConfigParams::m_camera_forward_up_angle = m_camera_presets[i-1].angle;
+            UserConfigParams::m_camera_forward_smoothing = m_camera_presets[i-1].smoothing;
+            UserConfigParams::m_camera_backward_up_angle = m_camera_presets[i-1].backward_angle;
+        }
+        updateCamera();
+    }
+    else if(name == "custom_camera")
+    {
+        new CustomCameraSettingsDialog(0.8f, 0.9f);
+    }
 #endif
 }   // eventCallback
 

src/states_screens/options/options_screen_ui.hpp

@@ -26,6 +26,15 @@
 
 namespace GUIEngine { class Widget; }
 
+struct CameraPreset
+{
+    int fov;
+    float distance;
+    float angle;
+    bool smoothing;
+    float backward_angle;
+};
+
 struct Input;
 
 /**
@@ -45,6 +54,8 @@ class OptionsScreenUI : public GUIEngine::Screen, public GUIEngine::ScreenSingle
     OptionsScreenUI();
     bool m_inited;
 
+    std::vector<CameraPreset> m_camera_presets;
+
     std::map<core::stringw, std::string> m_skins;
 
 public:
@@ -66,6 +77,8 @@ public:
     /** \brief implement optional callback from parent class GUIEngine::Screen */
     virtual void unloaded() OVERRIDE;
 
+    void         updateCameraPresetSpinner();
+
     virtual void onUpdate(float delta) OVERRIDE;
 
     void reloadGUIEngine();