Csc3dElementModelsRepository.h

Go to the documentation of this file.

#ifndef Csc3dElementModelsRepository_h
#define Csc3dElementModelsRepository_h
 
#include "CoreObjects/Resources/CscResourceSpec.h"
#include "Csc3dElementModelResolver.h"
#include "CscCommon.h"
 
using namespace conscience_core::core_objects::resources;
using std::lock_guard;
namespace conscience_core::core_objects::entities {
class CscEntityModelsRepository;
}
 
namespace conscience_core::core_objects::element_3d {
 
using namespace conscience_core::core_objects::entities;
 
class CscObjectModelsRepository;
class CscPlaceModelsRepository;
 
class Csc3dElementModelResolverOffline;
 
struct Csc3dElementModelImportData {
    string id;
    string name;
    string provider;
    string type = "";
 
    string toString() const;
};
 
class Csc3dElementModelsRepository {
 
public:
    bool isOffline();
 
    void setOnlineLibraryServiceEnabled(bool enabled);
 
    inline static const string EntityModelFileNamePrefix = "Conscience_";
    inline static const string PlaceModelFileNamePrefix = "Conscience_";
    inline static const string ObjectModelFileNamePrefix = "Conscience_Object_";
 
    static fs::path get3dElementModelsDaeDirectoryPath(Csc3dElementType elementType);
    static fs::path get3dElementModelsglTFDirectoryPath(Csc3dElementType elementType);
    static fs::path get3dElementModelsObjDirectoryPath(Csc3dElementType elementType);
    static fs::path get3dElementModelsLogoDirectoryPath(Csc3dElementType elementType);
    static fs::path get3dElementModelSourceDirectoryPath(Csc3dElementType elementType, CscWorldElementModelFormat format);
 
    static fs::path get3dElementModelsLocalRepositoryPath(Csc3dElementType elementType);
 
    static void set3dElementModelsLocalRepositoryPath(Csc3dElementType elementType, fs::path directoryPath);
 
    static CscObjectModelsRepository *getObjectRepositoryInstance();
    static CscPlaceModelsRepository *getPlaceRepositoryInstance();
    static CscEntityModelsRepository *getEntityRepositoryInstance();
 
    Csc3dElementModelsRepository() = default;
    virtual ~Csc3dElementModelsRepository() = default;
 
    void setResolver(ptr<Csc3dElementModelResolver>);
 
    virtual ptr<const Csc3dElementModel> getModel(const string &modelId);
 
    virtual ptr<CscResourceSpec> getLogo(ptr<const Csc3dElementModel> model);
 
    virtual optional<CscWorldElementModelSourceSpec> getModelSource(const string &modelId, optional<CscWorldElementModelFormat> requestedFormat = {}, optional<OnProgressCallback> onProgress = {});
 
    vector<string> getAllAvailableIds();
 
    vector<ptr<const Csc3dElementModel>> getAllAvailableModels(optional<CscWorldElementModelFormat> requestedFormat = {});
 
    void importLocalModelFile(const fs::path &filePath, const Csc3dElementModelImportData &importData);
 
protected:
    Csc3dElementModelsRepository(Csc3dElementType elementType);
    unique_ptr<CscLogger> logger = CscLogger::getForCategory("Csc3dElementModelsRepository");
    void recheckOnlineMode();
    mutex resolverOnlineCheckMutex;
 
    Csc3dElementType elementType;
 
    inline static optional<fs::path> ConscienceEntitiesRessourceLocalRepositoryPath = {};
    inline static optional<fs::path> ConsciencePlacesRessourceLocalRepositoryPath = {};
    inline static optional<fs::path> ConscienceObjectsRessourceLocalRepositoryPath = {};
 
    bool onlineModeAllowed = false;
    const ptr<Csc3dElementModelResolverOffline> resolverOffline = nullptr;
 
    unsigned long long lastOnlineCheckTimeMillis = 0;
 
    ptr<Csc3dElementModelResolver> resolver = nullptr;
    map<string, ptr<const Csc3dElementModel>> modelsCache;
    mutex cacheMutex;
 
    inline static CscObjectModelsRepository *objectRepositoryInstance = nullptr;
    inline static CscPlaceModelsRepository *placeRepositoryInstance = nullptr;
 
    template <class TModel>
    ptr<const TModel> getModelInstance(const string &id) {
        {
            const lock_guard<mutex> lock(cacheMutex);
            map<string, ptr<const Csc3dElementModel>>::iterator match = modelsCache.find(id);
            if (match != modelsCache.end()) {
                LOGGER_TRACE("getModel(" + id + ") - get from cache");
                return newptr<const TModel>(*match->second);
            }
        }
 
        LOGGER_TRACE("getModel(" + id + ") - cache miss, delegate to resolver");
        recheckOnlineMode();
        ptr<const TModel> model = nullptr;
        {
            const lock_guard<mutex> lock(resolverOnlineCheckMutex);
            auto modelPtr = resolver->resolve(id);
            if (modelPtr) {
                model = newptr<TModel>(*modelPtr);
            }
        }
 
        if (model != nullptr) {
            cacheMutex.lock();
            modelsCache[id] = model;
            cacheMutex.unlock();
        }
        return model;
    }
 
    virtual string buildFilename(const Csc3dElementModelImportData &data);
 
    fs::path getModelSourceDirectoryPath(CscWorldElementModelFormat format);
};
 
class CscObjectModel : public Csc3dElementModel {
public:
    static constexpr int MODEL_ID_FIRE = 777;
    static constexpr int MODEL_ID_PERSON = 10;
    static constexpr int MODEL_ID_UNCONSCIOUS_PERSON = 49;
    static constexpr int MODEL_ID_ARROW_BLUE = 0;
    static constexpr int MODEL_ID_TENNIS_BALL = 1;
    static constexpr int MODEL_ID_CUBE = 3;
    static constexpr int MODEL_ID_CAR = 2;
    static constexpr int MODEL_ID_BED = 161;
    static constexpr int MODEL_ID_CHAIR = 17;
    static constexpr int MODEL_ID_PERSON_STANDING = 160;
    static constexpr int MODEL_ID_PERSON_NURSE = 189;
 
    CscObjectModel() {}
    CscObjectModel(const Csc3dElementType &elementType,
                   const string &id,
                   const string &name,
                   const optional<string> &type,
                   const optional<string> &provider,
                   unsigned long long lastModificationTimeMillis)
        : Csc3dElementModel(elementType, id, name, type, provider, lastModificationTimeMillis) {
    }
    CscObjectModel(const Csc3dElementModel &other)
        : Csc3dElementModel(other) {
    }
};
 
#define PLACE_MODEL_NAME_CHECKERBOARD "checkerboard"
#define PLACE_MODEL_OWNER_CHECKERBOARD "Conscience"
class CscPlaceModel : public Csc3dElementModel {
public:
    static constexpr int MODEL_ID_CHECKERBOARD = 32;
 
    CscPlaceModel() {}
    CscPlaceModel(const Csc3dElementType &elementType,
                  const string &id,
                  const string &name,
                  const optional<string> &type,
                  const optional<string> &provider,
                  unsigned long long lastModificationTimeMillis)
        : Csc3dElementModel(elementType, id, name, type, provider, lastModificationTimeMillis) {
    }
    CscPlaceModel(const Csc3dElementModel &other)
        : Csc3dElementModel(other) {
    }
};
 
class CscObjectModelsRepository : public Csc3dElementModelsRepository {
 
public:
    CscObjectModelsRepository() : Csc3dElementModelsRepository(ELEMENT_OBJECT) {
    }
    ~CscObjectModelsRepository() override {
    }
 
    ptr<const CscObjectModel> getObjectModel(const string &modelId);
    string buildFilename(const Csc3dElementModelImportData &data) override;
};
 
class CscPlaceModelsRepository : public Csc3dElementModelsRepository {
 
public:
    CscPlaceModelsRepository() : Csc3dElementModelsRepository(ELEMENT_PLACE) {
    }
    ~CscPlaceModelsRepository() override {
    }
 
    ptr<const CscPlaceModel> getPlaceModel(const string &modelId);
    string buildFilename(const Csc3dElementModelImportData &data) override;
};
 
}
 
#endif