CacheSystem.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-2023 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 "Language.h"
#include "RefCountingObject.h"
#include "RefCountingObjectPtr.h"
#include "RigDef_File.h"
#include "SimData.h"
 
#include <Ogre.h>
#include <rapidjson/document.h>
#include <string>
#include <set>
 
#define CACHE_FILE "mods.cache"
#define CACHE_FILE_FORMAT 13
#define CACHE_FILE_FRESHNESS 86400 // 60*60*24 = one day
 
namespace RoR {
 
struct AuthorInfo
{
    int id = -1;
    Ogre::String type;
    Ogre::String name;
    Ogre::String email;
};
 
class CacheEntry: public RefCountingObject<CacheEntry>
{
 
public:
 
    CacheEntry();
    ~CacheEntry();
 
    CacheEntryID_t number;              
 
    Ogre::String fpath;                 
    Ogre::String fname;                 
    Ogre::String fname_without_uid;     
    Ogre::String fext;                  
    Ogre::String dname;                 
 
    int categoryid;                     
    Ogre::String categoryname;          
 
    std::time_t addtimestamp;           
    Ogre::String uniqueid;              
    Ogre::String guid;                  
    std::set<std::string> addonpart_guids; 
    int version;                        
    
    std::string resource_bundle_type;   
    std::string resource_bundle_path;   
    
    std::time_t filetime;               
    bool deleted;                       
    int usagecounter;                   
    std::vector<AuthorInfo> authors;    
    Ogre::String filecachename;         
 
    Ogre::String resource_group;        
 
    RigDef::DocumentPtr actor_def; 
    std::shared_ptr<RoR::SkinDef> skin_def;  
    RoR::TuneupDefPtr tuneup_def;  
    // TBD: Make Terrn2Def a RefcountingObjectPtr<> and cache it here too.
 
    // following all TRUCK detail information:
    Ogre::String description;
    Ogre::String tags;
    std::string default_skin;
    int fileformatversion;
    bool hasSubmeshs;
    int nodecount;
    int beamcount;
    int shockcount;
    int fixescount;
    int hydroscount;
    int wheelcount;
    int propwheelcount;
    int commandscount;
    int flarescount;
    int propscount;
    int wingscount;
    int turbopropscount;
    int turbojetcount;
    int rotatorscount;
    int exhaustscount;
    int flexbodiescount;
    int soundsourcescount;
 
    float truckmass;
    float loadmass;
    float minrpm;
    float maxrpm;
    float torque;
    bool customtach;
    bool custom_particles;
    bool forwardcommands;
    bool importcommands;
    bool rescuer;
 
    ActorType driveable;
    int numgears;
    char enginetype;
    std::vector<Ogre::String> sectionconfigs;
};
 
typedef RefCountingObjectPtr<CacheEntry> CacheEntryPtr;
 
enum CacheCategoryId
{
    CID_None          = 0,
 
    CID_Projects      = 8000, 
    CID_Tuneups       = 8001, 
 
    CID_Max           = 9000, 
    CID_Unsorted      = 9990,
    CID_All           = 9991,
    CID_Fresh         = 9992,
    CID_Hidden        = 9993,
    CID_SearchResults = 9994,
};
 
struct CacheQueryResult
{
    CacheQueryResult(CacheEntryPtr entry, size_t score);
 
    bool operator<(CacheQueryResult const& other) const;
 
    CacheEntryPtr cqr_entry;
    size_t        cqr_score;
};
 
enum class CacheSearchMethod // Always case-insensitive
{
    NONE,     
    FULLTEXT, 
    GUID,     
    AUTHORS,  
    WHEELS,   
    FILENAME  
};
 
struct CacheQuery
{
    RoR::LoaderType                cqy_filter_type = RoR::LoaderType::LT_None;
    int                            cqy_filter_category_id = CacheCategoryId::CID_All;
    std::string                    cqy_filter_guid; 
    CacheSearchMethod              cqy_search_method = CacheSearchMethod::NONE;
    std::string                    cqy_search_string;
    
    std::vector<CacheQueryResult>  cqy_results;
    std::map<int, size_t>          cqy_res_category_usage; 
    std::time_t                    cqy_res_last_update = std::time_t();
 
    void resetResults()
    {
        cqy_results.clear();
        cqy_res_category_usage.clear();
        cqy_res_last_update = std::time_t();
    }
};
 
enum class CacheValidity
{
    UNKNOWN,
    VALID,
    NEEDS_UPDATE,
    NEEDS_REBUILD,
};
 
enum class CreateProjectRequestType
{
    NONE,
    DEFAULT,                 
    SAVE_TUNEUP,             
};
 
struct CreateProjectRequest
{
    CreateProjectRequest();
    ~CreateProjectRequest();
 
    std::string cpr_name;            
    std::string cpr_description;     
    CacheEntryPtr cpr_source_entry;  
    ActorPtr cpr_source_actor;       
    CreateProjectRequestType cpr_type = CreateProjectRequestType::NONE;     
    bool cpr_overwrite;
};
 
enum class ModifyProjectRequestType
{
    NONE,
    TUNEUP_USE_ADDONPART_SET,          
    TUNEUP_USE_ADDONPART_RESET,        
    TUNEUP_FORCEREMOVE_PROP_SET,       
    TUNEUP_FORCEREMOVE_PROP_RESET,     
    TUNEUP_FORCEREMOVE_FLEXBODY_SET,   
    TUNEUP_FORCEREMOVE_FLEXBODY_RESET, 
    TUNEUP_FORCED_WHEEL_SIDE_SET,      
    TUNEUP_FORCED_WHEEL_SIDE_RESET,    
    TUNEUP_PROTECTED_PROP_SET,         
    TUNEUP_PROTECTED_PROP_RESET,       
    TUNEUP_PROTECTED_FLEXBODY_SET,     
    TUNEUP_PROTECTED_FLEXBODY_RESET,   
    TUNEUP_PROTECTED_WHEEL_SET,        
    TUNEUP_PROTECTED_WHEEL_RESET,      
    PROJECT_LOAD_TUNEUP,               
    PROJECT_RESET_TUNEUP,              
};
 
struct ModifyProjectRequest
{
    ActorPtr mpr_target_actor;
    ModifyProjectRequestType mpr_type = ModifyProjectRequestType::NONE;
 
    // Subject (either name or ID applies depending on type)
    std::string mpr_subject; // addonpart
    int mpr_subject_id = -1; // wheel, prop, flexbody, node
    int mpr_value_int;       // forced wheel side
};
 
class CacheSystem
{
    friend class ContentManager;
public:
    typedef std::map<int, Ogre::String> CategoryIdNameMap;
 
    CacheSystem();
 
    void                  LoadModCache(CacheValidity validity);
    bool                  IsModCacheLoaded() { return m_loaded; }
 
    CacheEntryPtr         FindEntryByFilename(RoR::LoaderType type, bool partial, const std::string& filename); 
    CacheEntryPtr         GetEntryByNumber(int modid);
    CacheEntryPtr         FetchSkinByName(std::string const & skin_name);
    size_t                Query(CacheQuery& query);
 
    void                  LoadResource(CacheEntryPtr& t); 
    bool                  CheckResourceLoaded(Ogre::String &in_out_filename); 
    bool                  CheckResourceLoaded(Ogre::String &in_out_filename, Ogre::String &out_group); 
    void                  ReLoadResource(CacheEntryPtr& t); 
    void                  UnLoadResource(CacheEntryPtr& t); 
    void                  LoadSupplementaryDocuments(CacheEntryPtr& t); 
    void                  LoadAssetPack(CacheEntryPtr& t_dest, Ogre::String const & assetpack_filename); 
 
    CacheEntryPtr         CreateProject(CreateProjectRequest* request); 
    void                  ModifyProject(ModifyProjectRequest* request);
    void                  DeleteProject(CacheEntryPtr& entry);
 
    const std::vector<CacheEntryPtr>   &GetEntries()        const { return m_entries; }
    const CategoryIdNameMap         &GetCategories()     const { return m_categories; }
 
    Ogre::String GetPrettyName(Ogre::String fname);
    std::string ActorTypeToName(ActorType driveable);
 
 
 
private:
 
    CacheValidity EvaluateCacheValidity(); // Called by `ContentManager` on startup only.
 
    void WriteCacheFileJson();
    void ExportEntryToJson(rapidjson::Value& j_entries, rapidjson::Document& j_doc, CacheEntryPtr const & entry);
    CacheValidity LoadCacheFileJson();
    void ImportEntryFromJson(rapidjson::Value& j_entry, CacheEntryPtr & out_entry);
 
    static Ogre::String StripUIDfromString(Ogre::String uidstr); 
    static Ogre::String StripSHA1fromString(Ogre::String sha1str);
    static std::string ComposeResourceGroupName(const CacheEntryPtr& entry);
 
    void ParseZipArchives(Ogre::String group);
    bool ParseKnownFiles(Ogre::String group); // returns true if no known files are found
    void ParseSingleZip(Ogre::String path);
 
    void ClearCache(); // removes                   all files from the cache
    void PruneCache(); // removes modified (or deleted) files from the cache
    void ClearResourceGroups();
 
    void AddFile(Ogre::String group, Ogre::FileInfo f, Ogre::String ext);
 
    void DetectDuplicates();
 
    void LoadAssociatedSkinDef(CacheEntryPtr& cache_entry); 
    void LoadAssociatedTuneupDef(CacheEntryPtr& cache_entry); 
 
    void FillTerrainDetailInfo(CacheEntryPtr &entry, Ogre::DataStreamPtr ds, Ogre::String fname);
    void FillTruckDetailInfo(CacheEntryPtr &entry, Ogre::DataStreamPtr ds, Ogre::String fname, Ogre::String group);
    void FillSkinDetailInfo(CacheEntryPtr &entry, std::shared_ptr<SkinDef>& skin_def);
    void FillAddonPartDetailInfo(CacheEntryPtr &entry, Ogre::DataStreamPtr ds);
    void FillTuneupDetailInfo(CacheEntryPtr &entry, TuneupDefPtr& tuneup_def);
    void FillAssetPackDetailInfo(CacheEntryPtr &entry, Ogre::DataStreamPtr ds);
 
    void GenerateHashFromFilenames();         
 
    void GenerateFileCache(CacheEntryPtr &entry, Ogre::String group);
    void RemoveFileCache(CacheEntryPtr &entry);
 
    bool Match(size_t& out_score, std::string data, std::string const& query, size_t );
 
    bool                                 m_loaded = false;
    std::time_t                          m_update_time;      
    std::string                          m_filenames_hash_loaded;   
    std::string                          m_filenames_hash_generated;   
    std::vector<CacheEntryPtr>           m_entries;
    std::vector<Ogre::String>            m_known_extensions; 
    std::set<Ogre::String>               m_resource_paths;   
    std::map<int, Ogre::String>          m_categories = {
            // these are the category numbers from the repository. do not modify them!
 
            // vehicles
            {108, _LC("ModCategory", "Other Land Vehicles")},
 
            {146, _LC("ModCategory", "Street Cars")},
            {147, _LC("ModCategory", "Light Racing Cars")},
            {148, _LC("ModCategory", "Offroad Cars")},
            {149, _LC("ModCategory", "Fantasy Cars")},
            {150, _LC("ModCategory", "Bikes")},
            {155, _LC("ModCategory", "Crawlers")},
 
            {152, _LC("ModCategory", "Towercranes")},
            {153, _LC("ModCategory", "Mobile Cranes")},
            {154, _LC("ModCategory", "Other cranes")},
 
            {107, _LC("ModCategory", "Buses")},
            {151, _LC("ModCategory", "Tractors")},
            {156, _LC("ModCategory", "Forklifts")},
            {159, _LC("ModCategory", "Fantasy Trucks")},
            {160, _LC("ModCategory", "Transport Trucks")},
            {161, _LC("ModCategory", "Racing Trucks")},
            {162, _LC("ModCategory", "Offroad Trucks")},
 
            {110, _LC("ModCategory", "Boats")},
 
            {113, _LC("ModCategory", "Helicopters")},
            {114, _LC("ModCategory", "Aircraft")},
 
            {117, _LC("ModCategory", "Trailers")},
            {118, _LC("ModCategory", "Other Loads")},
 
            // terrains
            {129, _LC("ModCategory", "Addon Terrains")},
 
            {859, _LC("ModCategory", "Container")},
 
            {875, _LC("ModCategory", "Submarine")},
 
            // note: these categories are NOT in the repository:
            {5000, _LC("ModCategory", "Official Terrains")},
            {5001, _LC("ModCategory", "Night Terrains")},
 
            {CID_Projects, _LC("ModCategory", "Projects")},
            {CID_Tuneups, _LC("ModCategory", "Tuneups")},
 
            // do not use category numbers above 9000!
            {CID_Unsorted, _LC("ModCategory", "Unsorted")},
            {CID_All, _LC("ModCategory", "All")},
            {CID_Fresh, _LC("ModCategory", "Fresh")},
            {CID_Hidden, _LC("ModCategory", "Hidden")},
        };
};
 
} // namespace RoR