TuneupFileFormat.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-2024 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 "CacheSystem.h"
#include "RefCountingObject.h"
 
#include <OgreResourceManager.h>
 
#include <array>
#include <vector>
#include <string>
#include <set>
 
namespace RoR {
 
const size_t TUNEUP_BUF_SIZE = 2000;
 
struct TuneupNodeTweak 
{
    NodeNum_t       tnt_nodenum = NODENUM_INVALID; 
    Ogre::Vector3   tnt_pos = Ogre::Vector3::ZERO; 
    std::string     tnt_origin; 
};
 
struct TuneupCineCameraTweak 
{
    CineCameraID_t  tct_cinecam_id = CINECAMERAID_INVALID; 
    Ogre::Vector3   tct_pos = Ogre::Vector3::ZERO; 
    std::string     tct_origin; 
};
 
struct TuneupWheelTweak 
{
    WheelID_t          twt_wheel_id = WHEELID_INVALID;       
    std::array<std::string, 2> twt_media;      
    WheelSide  twt_side = WheelSide::INVALID; 
    float              twt_tire_radius = -1.f;  
    float              twt_rim_radius = -1.f;   
    std::string        twt_origin;              
    
};
 
struct TuneupPropTweak 
{
    PropID_t        tpt_prop_id = PROPID_INVALID;
    std::array<std::string, 2> tpt_media;                     
    Ogre::Vector3   tpt_offset = Ogre::Vector3::ZERO;
    Ogre::Vector3   tpt_rotation = Ogre::Vector3::ZERO;
    std::string     tpt_origin;                       
};
 
struct TuneupFlexbodyTweak 
{
    FlexbodyID_t    tft_flexbody_id = FLEXBODYID_INVALID;
    std::string     tft_media;
    Ogre::Vector3   tft_offset = Ogre::Vector3::ZERO;
    Ogre::Vector3   tft_rotation = Ogre::Vector3::ZERO;
    std::string     tft_origin;                       
};
 
struct TuneupManagedMatTweak 
{
    std::string     tmt_name;               
    std::string     tmt_type;               
    std::array<std::string, 3> tmt_media;   
    std::string     tmt_origin;             
};
 
struct TuneupDef: public RefCountingObject<TuneupDef>
{
    std::string      name;
    std::string      guid;        
    std::string      filename;    
    std::string      thumbnail;
    std::string      description;
    std::string      author_name;
    int              author_id = -1;
    CacheCategoryId  category_id = CID_None;
 
    std::set<std::string>                         use_addonparts;        
 
    std::map<NodeNum_t, TuneupNodeTweak>          node_tweaks;           
    std::map<CineCameraID_t, TuneupCineCameraTweak>    cinecam_tweaks;   
    std::map<WheelID_t, TuneupWheelTweak>         wheel_tweaks;          
    std::map<PropID_t, TuneupPropTweak>           prop_tweaks;           
    std::map<FlexbodyID_t, TuneupFlexbodyTweak>   flexbody_tweaks;       
    std::map<std::string, TuneupManagedMatTweak>  managedmat_tweaks;     
    std::set<PropID_t>                            unwanted_props;          
    std::set<FlexbodyID_t>                        unwanted_flexbodies;     
    std::set<FlareID_t>                           unwanted_flares;         
    std::set<ExhaustID_t>                         unwanted_exhausts;       
    std::set<std::string>                         unwanted_managedmats;    
 
    std::set<PropID_t>                            force_remove_props;      
    std::set<FlexbodyID_t>                        force_remove_flexbodies; 
    std::map<WheelID_t, WheelSide>                force_wheel_sides;       
    std::map<VideoCameraID_t, VideoCamRole>       force_video_cam_roles;   
    std::set<FlareID_t>                           force_remove_flares;     
    std::set<ExhaustID_t>                         force_remove_exhausts;   
    std::set<std::string>                         force_remove_managedmats;
 
    std::set<NodeNum_t>                           protected_nodes;       
    std::set<CineCameraID_t>                      protected_cinecams;    
    std::set<WheelID_t>                           protected_wheels;      
    std::set<PropID_t>                            protected_props;       
    std::set<FlexbodyID_t>                        protected_flexbodies;  
    std::set<FlareID_t>                           protected_flares;      
    std::set<ExhaustID_t>                         protected_exhausts;    
    std::set<std::string>                         protected_managedmats; 
 
    TuneupDefPtr clone();
    void reset();
 
    bool         isPropProtected(PropID_t propid) const { return protected_props.find(propid) != protected_props.end(); }
    bool         isFlexbodyProtected(FlexbodyID_t flexbodyid) const { return protected_flexbodies.find(flexbodyid) != protected_flexbodies.end(); }
    bool         isWheelProtected(WheelID_t wheelid) const { return protected_wheels.find(wheelid) != protected_wheels.end(); }
    bool         isNodeProtected(NodeNum_t nodenum) const { return protected_nodes.find(nodenum) != protected_nodes.end(); }
    bool         isCineCameraProtected(CineCameraID_t cinecamid) const { return protected_cinecams.find(cinecamid) != protected_cinecams.end(); }
    bool         isFlareProtected(FlareID_t flareid) const { return protected_flares.find(flareid) != protected_flares.end(); }
    bool         isExhaustProtected(ExhaustID_t exhaustid) const { return protected_exhausts.find(exhaustid) != protected_exhausts.end(); }
    bool         isManagedMatProtected(const std::string& matname) const { return protected_managedmats.find(matname) != protected_managedmats.end(); }
 
    bool         isPropUnwanted(PropID_t propid) { return unwanted_props.find(propid) != unwanted_props.end(); }
    bool         isFlexbodyUnwanted(FlexbodyID_t flexbodyid) { return unwanted_flexbodies.find(flexbodyid) != unwanted_flexbodies.end(); }
    bool         isFlareUnwanted(FlareID_t flareid) { return unwanted_flares.find(flareid) != unwanted_flares.end(); }
    bool         isExhaustUnwanted(ExhaustID_t exhaustid) { return unwanted_exhausts.find(exhaustid) != unwanted_exhausts.end(); }
    bool         isManagedMatUnwanted(const std::string& matname) { return unwanted_managedmats.find(matname) != unwanted_managedmats.end(); }
 
    bool         isPropForceRemoved(PropID_t propid) { return force_remove_props.find(propid) != force_remove_props.end(); }
    bool         isFlexbodyForceRemoved(FlexbodyID_t flexbodyid) { return force_remove_flexbodies.find(flexbodyid) != force_remove_flexbodies.end(); }
    bool         isWheelSideForced(WheelID_t wheelid, WheelSide& out_val) const;
    bool         isFlareForceRemoved(FlareID_t flareid) { return force_remove_flares.find(flareid) != force_remove_flares.end(); }
    bool         isExhaustForceRemoved(ExhaustID_t exhaustid) { return force_remove_exhausts.find(exhaustid) != force_remove_exhausts.end(); }
    bool         isManagedMatForceRemoved(const std::string& matname) { return force_remove_managedmats.find(matname) != force_remove_managedmats.end(); }
    bool         isVideoCameraRoleForced(VideoCameraID_t camera_id, VideoCamRole& out_val) const;
};
 
class TuneupUtil
{
public:
 
    static std::vector<TuneupDefPtr> ParseTuneups(Ogre::DataStreamPtr& stream);
    static void ExportTuneup(Ogre::DataStreamPtr& stream, TuneupDefPtr& tuneup);
 
    static bool               isAddonPartUsed(TuneupDefPtr& tuneup_entry, const std::string& filename);
 
    static float              getTweakedWheelTireRadius(TuneupDefPtr& tuneup_entry, WheelID_t wheel_id, float orig_val);
    static float              getTweakedWheelRimRadius(TuneupDefPtr& tuneup_entry, WheelID_t wheel_id, float orig_val);
    static std::string        getTweakedWheelMedia(TuneupDefPtr& tuneup_entry, WheelID_t wheel_id, int media_idx, const std::string& orig_val);
    static std::string        getTweakedWheelMediaRG(TuneupDefPtr& tuneup_def, WheelID_t wheel_id, int media_idx, const std::string& orig_val);
    static WheelSide          getTweakedWheelSide(TuneupDefPtr& tuneup_entry, WheelID_t wheel_id, WheelSide orig_val);
    static bool               isWheelTweaked(TuneupDefPtr& tuneup_entry, WheelID_t wheel_id, TuneupWheelTweak*& out_tweak);
 
    static Ogre::Vector3      getTweakedNodePosition(TuneupDefPtr& tuneup_entry, NodeNum_t nodenum, Ogre::Vector3 orig_val);
    static bool               isNodeTweaked(TuneupDefPtr& tuneup_entry, NodeNum_t nodenum, TuneupNodeTweak*& out_tweak);
 
    static Ogre::Vector3      getTweakedCineCameraPosition(TuneupDefPtr& tuneup_entry, CineCameraID_t cinecamid, Ogre::Vector3 orig_val);
    static bool               isCineCameraTweaked(TuneupDefPtr& tuneup_entry, CineCameraID_t cinecamid, TuneupCineCameraTweak*& out_tweak);
 
    static bool               isPropAnyhowRemoved(TuneupDefPtr& tuneup_def, PropID_t prop_id);
    static Ogre::Vector3      getTweakedPropOffset(TuneupDefPtr& tuneup_entry, PropID_t prop_id, Ogre::Vector3 orig_val);
    static Ogre::Vector3      getTweakedPropRotation(TuneupDefPtr& tuneup_entry, PropID_t prop_id, Ogre::Vector3 orig_val);
    static std::string        getTweakedPropMedia(TuneupDefPtr& tuneup_entry, PropID_t prop_id, int media_idx, const std::string& orig_val);
    static std::string        getTweakedPropMediaRG(TuneupDefPtr& tuneup_def, PropID_t prop_id, int media_idx, const std::string& orig_val);
    static bool               isPropTweaked(TuneupDefPtr& tuneup_entry, PropID_t flexbody_id, TuneupPropTweak*& out_tweak);
 
    static bool               isFlexbodyAnyhowRemoved(TuneupDefPtr& tuneup_def, FlexbodyID_t flexbody_id);
    static Ogre::Vector3      getTweakedFlexbodyOffset(TuneupDefPtr& tuneup_entry, FlexbodyID_t flexbody_id, Ogre::Vector3 orig_val);
    static Ogre::Vector3      getTweakedFlexbodyRotation(TuneupDefPtr& tuneup_entry, FlexbodyID_t flexbody_id, Ogre::Vector3 orig_val);
    static std::string        getTweakedFlexbodyMedia(TuneupDefPtr& tuneup_entry, FlexbodyID_t flexbody_id, int media_idx, const std::string& orig_val);
    static std::string        getTweakedFlexbodyMediaRG(TuneupDefPtr& tuneup_def, FlexbodyID_t flexbody_id, int media_idx, const std::string& orig_val);
    static bool               isFlexbodyTweaked(TuneupDefPtr& tuneup_entry, FlexbodyID_t flexbody_id, TuneupFlexbodyTweak*& out_tweak);
 
    static bool               isFlareAnyhowRemoved(TuneupDefPtr& tuneup_def, FlareID_t flare_id);
 
    static bool               isExhaustAnyhowRemoved(TuneupDefPtr& tuneup_def, ExhaustID_t exhaust_id);
 
    static bool               isManagedMatAnyhowRemoved(TuneupDefPtr& tuneup_def, const std::string& matname);
    static std::string        getTweakedManagedMatType(TuneupDefPtr& tuneup_def, const std::string& matname, const std::string& orig_val);
    static std::string        getTweakedManagedMatMedia(TuneupDefPtr& tuneup_def, const std::string& matname, int media_idx, const std::string& orig_val);
    static std::string        getTweakedManagedMatMediaRG(TuneupDefPtr& tuneup_def, const std::string& matname, int media_idx, const std::string& orig_val);
    static bool               isManagedMatTweaked(TuneupDefPtr& tuneup_def, const std::string& matname, TuneupManagedMatTweak*& out_tweak);
 
    static VideoCamRole       getTweakedVideoCameraRole(TuneupDefPtr& tuneup_def, VideoCameraID_t camera_id, VideoCamRole orig_val);
 
private:
 
    static void ParseTuneupAttribute(const std::string& line, TuneupDefPtr& tuneup_def);
};
 
}; // namespace RoR