DashBoardManager.h

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2013-2020 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#pragma once
 
 
#include "Application.h"
#include "RefCountingObject.h"
#include "RefCountingObjectPtr.h"
#include "RTTLayer.h"
 
#include <MyGUI.h>
 
#include <map>
#include <string>
#include <vector>
 
namespace RoR {
 
#define DD_MAXCHAR 255
#define DD_MAX_SCREWPROP  6
#define DD_MAX_AEROENGINE 6
#define DD_MAX_WING       6
#define DD_MAX_GEOMETRIC_ANIMATIONS 10
 
struct dataContainer_t
{
    bool value_bool = false;
    int value_int = 0;
    float value_float = 0.f;
    char value_char[DD_MAXCHAR] = {};
};
 
enum
{
    DC_MIN, // Used for validation
 
    DC_BOOL,
    DC_INT,
    DC_FLOAT,
    DC_CHAR,
    DC_INVALID,
 
    DC_MAX // Used for validation
};
 
typedef struct dashData_t
{
    char type; // DC_*
    dataContainer_t data;
    bool enabled;
    std::string name; // char string of name
 
    dashData_t() : type(DC_INVALID), name("")
    {
        enabled = false;
    }
 
    dashData_t(char type, std::string name) : type(type), name(name)
    {
        enabled = true;
    }
} dashData_t;
 
// DashData enum definition
// important: if you add things here, also change the initialization in the constructor
enum DashData
{
    DD_ENGINE_RPM,
    DD_ENGINE_SPEEDO_KPH,      
    DD_ENGINE_SPEEDO_MPH,      
    DD_ENGINE_TURBO,           
    DD_ENGINE_IGNITION,
    DD_ENGINE_RUNNING,
    DD_ENGINE_OFF,
    DD_ENGINE_BATTERY,         
    DD_ENGINE_CLUTCH_WARNING,  
 
    DD_ENGINE_GEAR,            
    DD_ENGINE_NUM_GEAR,
    DD_ENGINE_GEAR_STRING,     
    DD_ENGINE_AUTOGEAR_STRING, 
    DD_ENGINE_AUTO_GEAR,       
 
    DD_ENGINE_CLUTCH, // the engines clutch
 
    DD_BRAKE, // the brake application in % 0-1
    DD_ACCELERATOR, // accelerator pedal in %, 0-1
 
    DD_ROLL, // roll of the chassis
    DD_ROLL_CORR, // correction roll of the chassis
    DD_ROLL_CORR_ACTIVE, // correction rolling active
 
    DD_PITCH, 
 
    DD_PARKINGBRAKE, 
    DD_LOCKED, 
 
    DD_LOW_PRESSURE, 
 
    DD_TRACTIONCONTROL_MODE,
    DD_ANTILOCKBRAKE_MODE,
    DD_TIES_MODE, 
    DD_CRUISECONTROL_ACTIVE,
 
    // water things
    DD_SCREW_THROTTLE_0, // throttle for screwprop 0
    DD_SCREW_THROTTLE_1,
    DD_SCREW_THROTTLE_2,
    DD_SCREW_THROTTLE_3,
    DD_SCREW_THROTTLE_4,
    DD_SCREW_THROTTLE_5, // if you add some, change DD_MAX_SCREWPROP and DD_SCREW_STEER_*
 
    DD_SCREW_STEER_0, // steering direction of screw 0
    DD_SCREW_STEER_1, // steering direction of screw 1
    DD_SCREW_STEER_2, // steering direction of screw 2
    DD_SCREW_STEER_3, // steering direction of screw 3
    DD_SCREW_STEER_4, // steering direction of screw 4
    DD_SCREW_STEER_5, // steering direction of screw 4,  if you add some, change DD_MAX_SCREWPROP and DD_SCREW_THROTTLE_*
 
    DD_WATER_DEPTH, // how much water is under the boat
    DD_WATER_SPEED, // speed in knots
 
    // airplane things
    DD_AEROENGINE_THROTTLE_0,
    DD_AEROENGINE_THROTTLE_1,
    DD_AEROENGINE_THROTTLE_2,
    DD_AEROENGINE_THROTTLE_3,
    DD_AEROENGINE_THROTTLE_4,
    DD_AEROENGINE_THROTTLE_5,
 
    DD_AEROENGINE_FAILED_0,
    DD_AEROENGINE_FAILED_1,
    DD_AEROENGINE_FAILED_2,
    DD_AEROENGINE_FAILED_3,
    DD_AEROENGINE_FAILED_4,
    DD_AEROENGINE_FAILED_5,
 
    DD_AEROENGINE_RPM_0,
    DD_AEROENGINE_RPM_1,
    DD_AEROENGINE_RPM_2,
    DD_AEROENGINE_RPM_3,
    DD_AEROENGINE_RPM_4,
    DD_AEROENGINE_RPM_5,
 
    DD_AIRSPEED, // speed in air
 
    DD_WING_AOA_0,
    DD_WING_AOA_1,
    DD_WING_AOA_2,
    DD_WING_AOA_3,
    DD_WING_AOA_4,
    DD_WING_AOA_5,
 
    DD_ALTITUDE,
    DD_ALTITUDE_STRING,
 
    DD_ODOMETER_TOTAL,
    DD_ODOMETER_USER,
 
    // Lights (mirrors RoRnet::Lightmask)
 
    DD_CUSTOM_LIGHT1,  
    DD_CUSTOM_LIGHT2,  
    DD_CUSTOM_LIGHT3,  
    DD_CUSTOM_LIGHT4,  
    DD_CUSTOM_LIGHT5,  
    DD_CUSTOM_LIGHT6,  
    DD_CUSTOM_LIGHT7,  
    DD_CUSTOM_LIGHT8,  
    DD_CUSTOM_LIGHT9,  
    DD_CUSTOM_LIGHT10, 
 
    DD_HEADLIGHTS,
    DD_HIGHBEAMS,
    DD_FOGLIGHTS,
    DD_SIDELIGHTS,
    DD_BRAKE_LIGHTS,
    DD_REVERSE_LIGHT,
    DD_BEACONS,
    DD_LIGHTS_LEGACY,    
 
    DD_SIGNAL_TURNLEFT,  
    DD_SIGNAL_TURNRIGHT, 
    DD_SIGNAL_WARNING,   
 
    DD_GUISETTING_SPEEDO,     
    DD_GUISETTING_TACHO,      
    DD_GUISETTING_HELP,       
    DD_GUISETTING_SPEEDO_KPH, 
    DD_GUISETTING_TACHO_RPM,  
 
    DD_MAX // This is the starting point for custom inputs
};
 
enum LoadDashBoardFlags
{
    LOADDASHBOARD_SCREEN_HUD = BITMASK(1), 
    LOADDASHBOARD_RTT_TEXTURE = BITMASK(2), 
    LOADDASHBOARD_RENDERDASH = BITMASK(3), 
    LOADDASHBOARD_STACKABLE = BITMASK(4) 
};
 
// this class is NOT intended to be thread safe - performance is required
class DashBoardManager : public RefCountingObject<DashBoardManager>
{
public:
    DashBoardManager(ActorPtr actor);
    virtual ~DashBoardManager() override;
 
    int registerCustomInput(Ogre::String name, int dataType);
 
    // Getter / Setter
    bool _getBool(int key) { return key < data.size() ? data[key].data.value_bool : false; };
    int _getInt(int key) { return data[key].data.value_int; };
    float _getFloat(int key) { return data[key].data.value_float; };
    float getNumeric(int key);
    char* getChar(int key) { return key < data.size() ? data[key].data.value_char : nullptr; };
    bool getEnabled(int key) { return key < data.size() ? data[key].enabled : false; };
 
    void setBool(int key, bool val) { if (key < data.size()) data[key].data.value_bool = val; };
    void setInt(int key, int val) { if (key < data.size()) data[key].data.value_int = val; };
    void setFloat(int key, float val) { if (key < data.size()) data[key].data.value_float = val; };
    void setChar(int key, const char* val) { if (key < data.size()) strncpy(data[key].data.value_char, val, DD_MAXCHAR); };
 
    void setEnabled(int key, bool val) { if (key < data.size()) data[key].enabled = val; };
 
    int getDataType(int key) { return key < data.size() ? data[key].type : DC_INVALID; };
 
    int getLinkIDForName(Ogre::String& str);
    std::string getLinkNameForID(DashData id);
 
    DashBoard* loadDashBoard(const std::string& filename, BitMask_t flags, RTTLayer* rttLayer);
 
    void update(float dt);
    void updateFeatures();
 
    bool wasDashboardHudLoaded() const { return m_hud_loaded; };
    bool wasDashboardRttLoaded() const { return m_rtt_loaded; };
 
    void setVisible(bool visibility);
    void setVisible3d(bool visibility);
    bool getVisible() { return visible; };
    void windowResized();
    void applyUiScale(); 
    size_t getInputCount() { return data.size(); }
    int getNumLoadedRTTDashboards() const { return loadedRTTDashboards; }
protected:
    std::string determineLayoutFromDashboardMod(CacheEntryPtr& entry, std::string const& basename, BitMask_t loaddashboardFlags);
    std::string determineTruckLayoutFromDashboardMod(Ogre::FileInfoListPtr& filelist);
    void loadDashboardModDetails(CacheEntryPtr& entry);
    bool visible = false;
    std::vector<dashData_t> data;
    std::vector<DashBoard*> m_dashboards;
    bool m_hud_loaded = false;
    bool m_rtt_loaded = false;
    ActorPtr m_actor;
    int registeredCustomInputs = 0;
    int loadedRTTDashboards = 0;
};
 
class DashBoard
{
    friend class DashBoardManager;
 
public:
    DashBoard(DashBoardManager* manager, Ogre::String filename, RTTLayer* _rttLayer);
    ~DashBoard();
 
    void setVisible(bool visible, bool smooth = true);
    bool getVisible() { return visible; };
 
    bool getIsTextureLayer() { return rttLayer != nullptr; }
 
    void update(float dt);
    void updateFeatures();
 
    void windowResized();
    void applyUiScale(); 
 
    float getSmoothNumeric(int linkID, float& lastVal);
 
protected:
    struct WidgetOrigin
    {
        MyGUI::IntCoord coord;
        int font_height = 0; 
    };
 
    void snapshotWidgetOriginsRecursive(MyGUI::Widget* parent);
    void applyUiScaleRecursive(MyGUI::Widget* parent, MyGUI::IntSize parent_orig_size, MyGUI::IntSize parent_new_size);
 
    std::map<MyGUI::Widget*, WidgetOrigin> m_widget_origins; 
    MyGUI::IntSize m_main_origin_size; 
    float m_ui_scale = 1.f; 
 
    DashBoardManager* manager{nullptr};
    Ogre::String filename;
    MyGUI::VectorWidgetPtr widgets;
    MyGUI::WindowPtr mainWidget;
    bool visible;
    std::string prefix;
    RTTLayer* rttLayer{nullptr};
 
    enum
    {
        ANIM_NONE,
        ANIM_ROTATE,
        ANIM_SCALE,
        ANIM_TEXTFORMAT,
        ANIM_TEXTSTRING,
        ANIM_LAMP,
        ANIM_SERIES,
        ANIM_TRANSLATE,
        ANIM_TEXTCOLOR,
        ANIM_IMAGETEXTURE
    };
 
    enum
    {
        DIRECTION_NONE,
        DIRECTION_UP,
        DIRECTION_RIGHT,
        DIRECTION_DOWN,
        DIRECTION_LEFT
    };
 
    enum
    {
        CONDITION_NONE,
        CONDITION_GREATER,
        CONDITION_LESSER
    };
 
    typedef struct layoutGeometricAnimation_t
    {
        int linkID; // DD_*
 
        char animationType; // ANIM_*
 
        float wmin; // rotation/offset whatever (widget min/max)
        float wmax;
        float vmin; // value min/max
        float vmax;
        char direction; // DIRECTION_*
        float lastVal;
    } layoutGeometricAnimation_t;
 
    typedef struct layoutGraphicalAnimation_t
    {
        int linkID; // DD_*
 
        char animationType; // ANIM_*
 
        int condition; // CONDITION_*
        float conditionArgument;
        char format[255]; // string format
        char texture[255]; // texture filename
        char format_neg_zero[255]; 
        float lastVal;
    } layoutGraphicalAnimation_t;
 
    // linking attributes
    typedef struct layoutLink_t
    {
        int linkIDForVisibility;
 
        char name[255]; // widget name
 
        layoutGraphicalAnimation_t graphicalAnimation;
        layoutGeometricAnimation_t geometricAnimations[DD_MAX_GEOMETRIC_ANIMATIONS];
        int geometricAnimationCount;
 
        MyGUI::Widget* widget;
        MyGUI::RotatingSkin* rotImg;
        MyGUI::ImageBox* img;
        MyGUI::TextBox* txt;
        MyGUI::IntSize initialSize;
        MyGUI::IntPoint initialPosition;
 
        bool lastState;
    } layoutLink_t;
 
    void loadLayoutInternal();
    void loadLayoutRecursive(MyGUI::WidgetPtr ptr);
    bool parseLink(std::string& linkArgs, int& linkID, char& condition, float& conditionArgument, const std::string& filename, const std::string& name);
    std::vector<layoutLink_t> controls;
};
 
} // namespace RoR