MegaMol Project Concept

core/include/mmcore/MegaMolGraph.h

@@ -14,7 +14,9 @@
 #include "FrontendResource.h"
 #include "FrontendResourcesLookup.h"
 #include "ImagePresentationEntryPoints.h"
+#include "MegaMolProject.h"
 #include "ModuleGraphSubscription.h"
+
 #include "mmcore/MegaMolGraphTypes.h"
 #include "mmcore/MegaMolGraph_Convenience.h"
 #include "mmcore/RootModuleNamespace.h"
@@ -136,6 +138,8 @@ class MegaMolGraph {
     std::list<Module::ptr_type> graph_entry_points;
     megamol::frontend_resources::ImagePresentationEntryPoints* m_image_presentation = nullptr;
 
+    megamol::frontend_resources::MegaMolProject* m_current_project_path = nullptr;
+
     MegaMolGraph_Convenience convenience_functions;
 
     frontend_resources::MegaMolGraph_SubscriptionRegistry graph_subscribers;

core/include/mmcore/param/FilePathParam.h

@@ -45,6 +45,8 @@ class FilePathParam : public AbstractParam {
      * @param flags The flags for the parameter
      * @param exts The required file extensions for the parameter
      */
+    FilePathParam(const std::filesystem::path& initVal, Flags_t flags, const Extensions_t& exts,
+        const std::filesystem::path& project_directory);
     FilePathParam(const std::filesystem::path& initVal, Flags_t flags = Flag_File, const Extensions_t& exts = {});
     FilePathParam(const std::string& initVal, Flags_t flags = Flag_File, const Extensions_t& exts = {});
     FilePathParam(const char* initVal, Flags_t flags = Flag_File, const Extensions_t& exts = {});
@@ -83,7 +85,7 @@ class FilePathParam : public AbstractParam {
      * @return The value of the parameter
      */
     std::filesystem::path Value() const {
-        return this->value;
+        return this->GetAbsolutePathValue(this->value);
     }
 
     /**
@@ -92,7 +94,7 @@ class FilePathParam : public AbstractParam {
      * @return The value of the parameter as string.
      */
     std::string ValueString() const override {
-        return this->value.generic_u8string();
+        return this->GetRelativePathValueString();
     }
 
     /**
@@ -113,25 +115,66 @@ class FilePathParam : public AbstractParam {
         return this->extensions;
     }
 
+    inline std::filesystem::path GetProjectDirectory() const {
+        return this->project_directory;
+    }
+
     /**
      * Function checks if path is valid for given flags
      *
      * @return Return 0 for success, flags with failed check otherwise.
      */
-    static Flags_t ValidatePath(const std::filesystem::path& p, const Extensions_t&, Flags_t f);
+    static Flags_t ValidatePath(
+        const std::filesystem::path& p, const Extensions_t&, Flags_t f, const std::filesystem::path& project_dir = "");
+
+
+    /**
+     * Adds absolute path to current project directory to the file path parameter.
+     * This way file paths relative to the project directory can be resolved.
+     */
+    void SetProjectDirectory(const std::filesystem::path& p);
+
+    /**
+     * Returns either the current path value if it is an absolute path,
+     * or concatinates project directory path and current path value if it is a relative path.
+     */
+    std::filesystem::path GetAbsolutePathValue(const std::filesystem::path& p) const;
+
+    /**
+     * Returns the current raw path value, which might be an absolute path in the file system
+     * or a path relative to some project directory
+     */
+    std::filesystem::path GetRelativePathValue() const {
+        return this->value;
+    }
+
+    /**
+     * Returns string of the current raw path value, which might be an absolute path in the file system
+     * or a path relative to some project directory.
+     * This is used by the serialization function of the MegaMolGraph to preserve relative paths of FilePathParams.
+     */
+    std::string GetRelativePathValueString() const {
+        return GetRelativePathValue().generic_u8string();
+    }
 
 private:
     /** The flags of the parameter */
-    const Flags_t flags;
+    Flags_t flags;
 
     /** The accepted file extension(s).
      * Leave empty to allow all extensions.
      * Only considered when Flag_RestrictExtension is set.
      */
-    const Extensions_t extensions;
+    Extensions_t extensions;
 
     /** The file or directory path */
     std::filesystem::path value;
+
+    /**
+     * Absolute path to project directory. If empty, no project path available.
+     * This path is absolute per guarantee of the frontend
+     */
+    std::filesystem::path project_directory;
 };
 
 

core/src/MegaMolGraph.cpp

@@ -10,6 +10,7 @@
 #include "ResourceRequest.h"
 #include "mmcore/AbstractSlot.h"
 #include "mmcore/param/ButtonParam.h"
+#include "mmcore/param/FilePathParam.h"
 #include "mmcore/utility/String.h"
 #include "mmcore/utility/log/Log.h"
 #include "mmcore/view/AbstractView_EventConsumption.h"
@@ -476,6 +477,7 @@ bool megamol::core::MegaMolGraph::AddFrontendResources(
 
     auto [success, graph_resources] = provided_resources_lookup.get_requested_resources({
         "ImagePresentationEntryPoints",
+        "MegaMolProject",
     });
 
     if (!success)
@@ -484,6 +486,9 @@ bool megamol::core::MegaMolGraph::AddFrontendResources(
     m_image_presentation = &const_cast<megamol::frontend_resources::ImagePresentationEntryPoints&>(
         graph_resources[0].getResource<megamol::frontend_resources::ImagePresentationEntryPoints>());
 
+    m_current_project_path = &const_cast<megamol::frontend_resources::MegaMolProject&>(
+        graph_resources[1].getResource<megamol::frontend_resources::MegaMolProject>());
+
     return true;
 }
 
@@ -598,6 +603,23 @@ bool megamol::core::MegaMolGraph::add_module(ModuleInstantiationRequest_t const&
 
     module_ptr->setParent(this->dummy_namespace);
 
+    // we want to enable filename parameters to open file paths relative to the current .lua project file
+    // for this to work we need to manually find FilePathParam parameters in created modules and tell them
+    // the current project directory path
+    if (m_current_project_path->attributes.has_value()) {
+        auto project_directory_path = m_current_project_path->attributes.value().project_directory;
+
+        for (auto child = module_ptr->ChildList_Begin(); child != module_ptr->ChildList_End(); ++child) {
+            auto ps = dynamic_cast<param::ParamSlot*>((*child).get());
+            if (ps != nullptr) {
+                auto p = ps->Param<param::FilePathParam>();
+                if (p != nullptr) {
+                    p->SetProjectDirectory(project_directory_path);
+                }
+            }
+        }
+    }
+
     const auto create_module = [module_description, module_ptr](auto& module_lifetime_dependencies) {
         const bool init_ok =
             module_ptr->Create(module_lifetime_dependencies); // seems like Create() internally checks IsAvailable()

core/src/MegaMolGraph_Convenience.cpp

@@ -74,16 +74,22 @@ std::string megamol::core::MegaMolGraph_Convenience::SerializeCalls() const {
 std::string megamol::core::MegaMolGraph_Convenience::SerializeModuleParameters(std::string const& module_name) const {
     std::string serParams;
 
+    auto parameter_serialization = [](std::string const& name, std::string const& value) {
+        return "mmSetParamValue(\"" + name + "\",[=[" + value + "]=])\n";
+    };
+
     for (auto& paramSlot : get(m_graph_ptr).EnumerateModuleParameterSlots(module_name)) {
-        // it seems serialiing button params is illegal
+        // it seems serializing button params is illegal
         if (auto* p_ptr = paramSlot->template Param<core::param::ButtonParam>()) {
             continue;
         }
+
         auto name = std::string{paramSlot->FullName()};
         // as FullName() prepends :: to module names, normalize multiple leading :: in parameter name path
         name = "::" + name.substr(name.find_first_not_of(':'));
+
         auto value = paramSlot->Parameter()->ValueString();
-        serParams.append("mmSetParamValue(\"" + name + "\",[=[" + value + "]=])\n");
+        serParams.append(parameter_serialization(name, value));
     }
 
     return serParams + '\n';

core/src/param/FilePathParam.cpp

@@ -10,6 +10,11 @@
 
 using namespace megamol::core::param;
 
+FilePathParam::FilePathParam(const std::filesystem::path& initVal, Flags_t flags, const Extensions_t& exts,
+    const std::filesystem::path& project_directory)
+        : FilePathParam(initVal, flags, exts) {
+    this->SetProjectDirectory(project_directory);
+}
 
 FilePathParam::FilePathParam(const std::filesystem::path& initVal, Flags_t flags, const Extensions_t& exts)
         : AbstractParam()
@@ -42,12 +47,18 @@ bool FilePathParam::ParseValue(std::string const& v) {
 
 void FilePathParam::SetValue(const std::filesystem::path& v, bool setDirty) {
 
-    try {
-        auto tmp_val_str = v.generic_u8string();
+    const auto normalize_path = [](std::filesystem::path const& path) -> std::filesystem::path {
+        auto tmp_val_str = path.generic_u8string();
         std::replace(tmp_val_str.begin(), tmp_val_str.end(), '\\', '/');
-        auto new_value = std::filesystem::path(tmp_val_str);
+        return std::filesystem::path{tmp_val_str};
+    };
+
+    try {
+        auto new_value = normalize_path(v);
+
         if (this->value != new_value) {
-            auto error_flags = FilePathParam::ValidatePath(new_value, this->extensions, this->flags);
+            auto absolute_new_value = GetAbsolutePathValue(new_value);
+            auto error_flags = FilePathParam::ValidatePath(absolute_new_value, this->extensions, this->flags);
 
             if (error_flags & Flag_File) {
                 megamol::core::utility::log::Log::DefaultLog.WriteWarn(
@@ -73,6 +84,29 @@ void FilePathParam::SetValue(const std::filesystem::path& v, bool setDirty) {
                     new_value.generic_u8string().c_str(), log_exts.c_str());
             }
             if (error_flags == 0) {
+                if (new_value.is_absolute() && !this->project_directory.empty()) {
+                    // is new path in project directory?
+                    // then represent as relative path
+
+                    // walk along directory path where project dir and new file path are the same
+                    auto val_it = new_value.begin();
+                    auto proj_it = project_directory.begin();
+                    while (*val_it == *proj_it) {
+                        val_it++;
+                        proj_it++;
+                    }
+                    // if we walked the project directory till the end, new file is inside that directory
+                    if (*proj_it == *project_directory.end()) {
+                        // collect the tail of new file path and use it as new value
+                        std::filesystem::path project_relative_path;
+                        while (val_it != new_value.end()) {
+                            project_relative_path = project_relative_path / *val_it;
+                            val_it++;
+                        }
+                        new_value = normalize_path(project_relative_path);
+                    }
+                }
+
                 this->value = new_value;
                 this->indicateParamChange();
                 if (setDirty)
@@ -98,25 +132,31 @@ void megamol::core::param::FilePathParam::SetValue(const char* v, bool setDirty)
 }
 
 
-FilePathParam::Flags_t FilePathParam::ValidatePath(const std::filesystem::path& p, const Extensions_t& e, Flags_t f) {
+FilePathParam::Flags_t FilePathParam::ValidatePath(
+    const std::filesystem::path& p, const Extensions_t& e, Flags_t f, const std::filesystem::path& project_dir) {
+
+    std::filesystem::path path = p;
+    if (!project_dir.empty() && project_dir.is_absolute() && p.is_relative()) {
+        path = project_dir / p;
+    }
 
     try {
         FilePathParam::Flags_t retval = 0;
         if ((f & FilePathParam::Flag_Any) != FilePathParam::Flag_Any) {
-            if ((f & FilePathParam::Flag_File) && std::filesystem::is_directory(p)) {
+            if ((f & FilePathParam::Flag_File) && std::filesystem::is_directory(path)) {
                 retval |= FilePathParam::Flag_File;
             }
-            if ((f & FilePathParam::Flag_Directory) && std::filesystem::is_regular_file(p)) {
+            if ((f & FilePathParam::Flag_Directory) && std::filesystem::is_regular_file(path)) {
                 retval |= FilePathParam::Flag_Directory;
             }
         }
-        if (!(f & Internal_NoExistenceCheck) && !std::filesystem::exists(p)) {
+        if (!(f & Internal_NoExistenceCheck) && !std::filesystem::exists(path)) {
             retval |= FilePathParam::Internal_NoExistenceCheck;
         }
         if (f & FilePathParam::Internal_RestrictExtension) {
             bool valid_ext = false;
             for (auto& ext : e) {
-                if (p.extension().generic_u8string() == std::string("." + ext)) {
+                if (path.extension().generic_u8string() == std::string("." + ext)) {
                     valid_ext = true;
                 }
             }
@@ -131,3 +171,16 @@ FilePathParam::Flags_t FilePathParam::ValidatePath(const std::filesystem::path&
         return 0;
     }
 }
+
+void FilePathParam::SetProjectDirectory(const std::filesystem::path& p) {
+    assert(p.is_absolute());
+
+    this->project_directory = p;
+}
+
+std::filesystem::path FilePathParam::GetAbsolutePathValue(const std::filesystem::path& p) const {
+    if (p.empty() || p.is_absolute())
+        return p;
+
+    return this->project_directory / p;
+}

frontend/main/src/CLIConfigParsing.cpp

@@ -48,6 +48,7 @@ std::pair<RuntimeConfig, GlobalValueStore> megamol::frontend::handle_cli_and_con
     RuntimeConfig config;
 
     config.megamol_executable_directory = getExecutableDirectory().u8string();
+    config.megamol_current_working_directory = std::filesystem::current_path().u8string();
 
     // config files are already checked to exist in file system
     config.configuration_files = extract_config_file_paths(argc, argv);

frontend/resources/include/MegaMolProject.h

@@ -0,0 +1,41 @@
+/*
+ * MegaMolProject.h
+ *
+ * Copyright (C) 2022 by VISUS (Universitaet Stuttgart).
+ * Alle Rechte vorbehalten.
+ */
+
+#pragma once
+
+#include <cassert>
+#include <filesystem>
+#include <optional>
+#include <string>
+
+namespace megamol {
+namespace frontend_resources {
+
+struct MegaMolProject {
+    using path = std::filesystem::path;
+
+    struct ProjectAttributes {
+        // example: C:/megamol/project.lua
+        std::string project_name = ""; // name of project in some way, either "projcet.lua" or "project" or "something"
+        path project_file;             // C:/megamol/project.lua
+        path project_directory;        // C:/megamol/
+    };
+
+    std::optional<ProjectAttributes> attributes = std::nullopt;
+
+    void setProjectFile(path const& file) {
+        assert(file.is_absolute());
+        ProjectAttributes a;
+        a.project_file = file;
+        a.project_directory = path{file}.remove_filename(); // leaves trailing '/'
+        a.project_name = file.filename().stem().string();
+
+        attributes = a;
+    }
+};
+} /* end namespace frontend_resources */
+} /* end namespace megamol */

frontend/resources/include/RuntimeConfig.h

@@ -31,7 +31,8 @@ struct RuntimeConfig {
     std::vector<std::string> configuration_file_contents = {};
     std::vector<StringPair> cli_options_from_configs = {}; // mmSetCliOption - set config/option values accepted in CLI
     std::vector<std::string> configuration_file_contents_as_cli = {};
-    Path megamol_executable_directory = "";      // mmGetMegaMolExecutableDirectory
+    Path megamol_executable_directory = ""; // mmGetMegaMolExecutableDirectory
+    Path megamol_current_working_directory = "";
     Path application_directory = "";             // mmSetAppDir
     std::vector<Path> resource_directories = {}; // mmAddResourceDir
     std::vector<Path> shader_directories = {};   // mmAddShaderDir