Merge pull request #1193 from reinago/anim-editor

Fixes to Animation Editor and others

core/include/mmcore/Call.h

@@ -137,8 +137,8 @@ class Call : public std::enable_shared_from_this<Call> {
     // and thereby linking the frontend service headers into the core
     // so make the perf queries public when profiling is active...
 public:
-    frontend_resources::PerformanceManager* perf_man = nullptr;
-    frontend_resources::PerformanceManager::handle_vector cpu_queries, gl_queries;
+    frontend_resources::performance::PerformanceManager* perf_man = nullptr;
+    frontend_resources::performance::handle_vector cpu_queries, gl_queries;
 #endif // MEGAMOL_USE_PROFILING
 #ifdef MEGAMOL_USE_OPENGL_DEBUGGROUPS
 public:

core/include/mmcore/utility/animation/AnimationData.h

@@ -11,6 +11,7 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <imgui.h>
+#include <sol/sol.hpp>
 
 #include "mmcore/MegaMolGraph.h"
 
@@ -20,10 +21,30 @@ using KeyTimeType = int32_t;
 
 enum class InterpolationType : int32_t { Step = 0, Linear = 1, Hermite = 2, CubicBezier = 3, SLERP = 4 };
 
+class ExpressionInterpreter {
+public:
+    static ExpressionInterpreter& getInstance() {
+        static ExpressionInterpreter instance;
+        return instance;
+    }
+    ExpressionInterpreter(ExpressionInterpreter const&) = delete;
+    void operator=(ExpressionInterpreter const&) = delete;
+
+    float EvaluateFloat(const std::string& script, KeyTimeType t);
+
+    std::string EvaluateString(const std::string& script, KeyTimeType t);
+
+private:
+    ExpressionInterpreter() {
+        lua.open_libraries(sol::lib::base, sol::lib::math, sol::lib::string);
+    }
+    sol::state lua;
+};
+
 struct FloatKey {
     using ValueType = float;
     KeyTimeType time;
-    ValueType value;
+    ValueType value = ValueType();
     InterpolationType interpolation = InterpolationType::Linear;
     bool tangents_linked = true;
     ImVec2 in_tangent{-1.0f, 0.0f};
@@ -61,6 +82,20 @@ struct StringKey {
     ValueType value;
 };
 
+struct ScriptedStringKey {
+    using ValueType = std::string;
+    KeyTimeType time;
+    ValueType value;
+    std::string script;
+};
+
+struct ScriptedFloatKey {
+    using ValueType = float;
+    KeyTimeType time;
+    ValueType value;
+    std::string script;
+};
+
 template<class KeyType>
 class GenericAnimation {
 public:
@@ -98,6 +133,9 @@ class GenericAnimation {
     const std::string& GetName() const {
         return param_name;
     }
+    void SetName(std::string param) {
+        param_name = param;
+    }
     typename KeyMap::size_type GetSize() const {
         return keys.size();
     }
@@ -218,6 +256,21 @@ float GenericAnimation<FloatKey>::GetMinValue() const;
 template<>
 float GenericAnimation<FloatKey>::GetMaxValue() const;
 
+using ScriptedStringAnimation = GenericAnimation<ScriptedStringKey>;
+
+// Scripted Strings do everything differently
+template<>
+GenericAnimation<ScriptedStringKey>::ValueType::ValueType GenericAnimation<ScriptedStringKey>::GetValue(
+    KeyTimeType time) const;
+
+using ScriptedFloatAnimation = GenericAnimation<ScriptedFloatKey>;
+
+// Scripted Floats as well
+template<>
+GenericAnimation<ScriptedFloatKey>::ValueType::ValueType GenericAnimation<ScriptedFloatKey>::GetValue(
+    KeyTimeType time) const;
+
+
 // same goes for vec keys, plus some more specialization
 template<class C>
 class VectorAnimation : public GenericAnimation<VectorKey<C>> {

core/include/mmcore/utility/animation/AnimationUtils.h

@@ -18,14 +18,22 @@ void to_json(nlohmann::json& j, const StringKey& k);
 void from_json(const nlohmann::json& j, StringKey& k);
 void to_json(nlohmann::json& j, const VectorKey<FloatKey>& k);
 void from_json(const nlohmann::json& j, VectorKey<FloatKey>& k);
+void to_json(nlohmann::json& j, const ScriptedFloatKey& k);
+void from_json(const nlohmann::json& j, ScriptedFloatKey& k);
+void to_json(nlohmann::json& j, const ScriptedStringKey& k);
+void from_json(const nlohmann::json& j, ScriptedStringKey& k);
 
 void to_json(nlohmann::json& j, const FloatAnimation& f);
 void from_json(const nlohmann::json& j, FloatAnimation& f);
 void to_json(nlohmann::json& j, const StringAnimation& s);
 void from_json(const nlohmann::json& j, StringAnimation& s);
 void to_json(nlohmann::json& j, const FloatVectorAnimation& v);
-void from_json(const nlohmann::json& j, FloatVectorAnimation& s);
+void from_json(const nlohmann::json& j, FloatVectorAnimation& v);
 
+void to_json(nlohmann::json& j, const ScriptedFloatAnimation& f);
+void from_json(const nlohmann::json& j, ScriptedFloatAnimation& f);
+void to_json(nlohmann::json& j, const ScriptedStringAnimation& s);
+void from_json(const nlohmann::json& j, ScriptedStringAnimation& s);
 
 // this does not seem okay
 // PD code from https://github.com/ocornut/imgui/issues/1496#issuecomment-1287772456

core/src/Call.cpp

@@ -75,17 +75,18 @@ bool Call::operator()(unsigned int func) {
         }
 #endif
 #ifdef MEGAMOL_USE_PROFILING
-        perf_man->start_timer(cpu_queries[func]);
+        auto& cpu_region = perf_man->start_timer(cpu_queries[func]);
+        frontend_resources::performance::timer_region* gpu_region = nullptr;
         if (caps.OpenGLRequired()) {
-            perf_man->start_timer(gl_queries[func]);
+            gpu_region = &perf_man->start_timer(gl_queries[func]);
         }
 #endif
         res = this->callee->InCall(this->funcMap[func], *this);
 #ifdef MEGAMOL_USE_PROFILING
         if (caps.OpenGLRequired()) {
-            perf_man->stop_timer(gl_queries[func]);
+            gpu_region->end_region();
         }
-        perf_man->stop_timer(cpu_queries[func]);
+        cpu_region.end_region();
 #endif
 #ifdef MEGAMOL_USE_OPENGL_DEBUGGROUPS
         if (caps.OpenGLRequired()) {

core/src/utility/animation/AnimationData.cpp

@@ -23,6 +23,33 @@ std::ostream& megamol::core::utility::operator<<(
     return outs << ss.str();
 }
 
+float ExpressionInterpreter::EvaluateFloat(const std::string& script, KeyTimeType t) {
+    lua.set("time", t);
+    // I think this makes it too complicated
+    //sol::table in_t = lua["in_tangent"];
+    //in_t.clear();
+    //in_t.add(in_tangent[0], in_tangent[1]);
+    //sol::table out_t = lua["out_tangent"];
+    //out_t.clear();
+    //out_t.add(in_tangent[0], in_tangent[1]);
+    try {
+        const float res = lua.script(script);
+        return res;
+    } catch (sol::error& e) {
+        return 0.0f;
+    }
+}
+
+std::string ExpressionInterpreter::EvaluateString(const std::string& script, KeyTimeType t) {
+    lua.set("time", t);
+    try {
+        std::string res = lua.script(script);
+        return res;
+    } catch (sol::error& e) {
+        return "";
+    }
+}
+
 FloatKey::ValueType FloatKey::InterpolateForTime(FloatKey first, FloatKey second, KeyTimeType time) {
     FloatKey my_first = first;
     FloatKey my_second = second;
@@ -264,13 +291,13 @@ GenericAnimation<FloatKey>::ValueType::ValueType GenericAnimation<FloatKey>::Get
         if (keys.empty()) {
             return ValueType::ValueType();
         }
-        return keys.begin()->second.value;
+        return FloatKey::InterpolateForTime(keys.begin()->second, keys.begin()->second, time);
     }
     FloatKey before_key = keys.begin()->second, after_key = keys.begin()->second;
     bool ok = false;
     for (auto it = keys.begin(); it != keys.end(); ++it) {
         if (it->second.time == time) {
-            return it->second.value;
+            return FloatKey::InterpolateForTime(it->second, it->second, time);
         }
         if (it->second.time < time) {
             before_key = it->second;
@@ -284,7 +311,7 @@ GenericAnimation<FloatKey>::ValueType::ValueType GenericAnimation<FloatKey>::Get
     if (ok) {
         return FloatKey::InterpolateForTime(before_key, after_key, time);
     } else {
-        return before_key.value;
+        return FloatKey::InterpolateForTime(before_key, before_key, time);
     }
 }
 
@@ -293,7 +320,7 @@ template<>
 ImVec2 GenericAnimation<FloatKey>::GetTangent(KeyTimeType time) const {
     if (keys.size() < 2) {
         if (keys.empty()) {
-            return ImVec2();
+            return ImVec2(1.0, 0.0);
         }
         return keys.begin()->second.out_tangent;
     }
@@ -339,7 +366,7 @@ InterpolationType GenericAnimation<FloatKey>::GetInterpolation(KeyTimeType time)
 
 
 template<>
-float GenericAnimation<FloatKey>::GetMinValue() const {
+GenericAnimation<FloatKey>::ValueType::ValueType GenericAnimation<FloatKey>::GetMinValue() const {
     if (!keys.empty()) {
         auto min = std::numeric_limits<float>::max();
         for (auto& k : keys) {
@@ -352,7 +379,7 @@ float GenericAnimation<FloatKey>::GetMinValue() const {
 }
 
 template<>
-float GenericAnimation<FloatKey>::GetMaxValue() const {
+GenericAnimation<FloatKey>::ValueType::ValueType GenericAnimation<FloatKey>::GetMaxValue() const {
     if (!keys.empty()) {
         auto max = std::numeric_limits<float>::lowest();
         for (auto& k : keys) {
@@ -363,3 +390,15 @@ float GenericAnimation<FloatKey>::GetMaxValue() const {
         return 1.0f;
     }
 }
+
+template<>
+GenericAnimation<ScriptedStringKey>::ValueType::ValueType GenericAnimation<ScriptedStringKey>::GetValue(
+    KeyTimeType time) const {
+    return ExpressionInterpreter::getInstance().EvaluateString(keys.begin()->second.script, time);
+}
+
+template<>
+GenericAnimation<ScriptedFloatKey>::ValueType::ValueType GenericAnimation<ScriptedFloatKey>::GetValue(
+    KeyTimeType time) const {
+    return ExpressionInterpreter::getInstance().EvaluateFloat(keys.begin()->second.script, time);
+}

core/src/utility/animation/AnimationUtils.cpp

@@ -57,6 +57,26 @@ void animation::from_json(const nlohmann::json& j, VectorKey<FloatKey>& k) {
     }
 }
 
+void animation::to_json(nlohmann::json& j, const ScriptedFloatKey& k) {
+    j = nlohmann::json{{"time", k.time}, {"value", k.value}, {"script", k.script}};
+}
+
+void animation::from_json(const nlohmann::json& j, ScriptedFloatKey& k) {
+    j["time"].get_to(k.time);
+    j["value"].get_to(k.value);
+    j["script"].get_to(k.script);
+}
+
+void animation::to_json(nlohmann::json& j, const ScriptedStringKey& k) {
+    j = nlohmann::json{{"time", k.time}, {"value", k.value}, {"script", k.script}};
+}
+
+void animation::from_json(const nlohmann::json& j, ScriptedStringKey& k) {
+    j["time"].get_to(k.time);
+    j["value"].get_to(k.value);
+    j["script"].get_to(k.script);
+}
+
 
 void animation::to_json(nlohmann::json& j, const FloatAnimation& f) {
     j = nlohmann::json{{"name", f.GetName()}, {"type", "float"}};
@@ -116,6 +136,44 @@ void animation::from_json(const nlohmann::json& j, FloatVectorAnimation& v) {
     }
 }
 
+void animation::to_json(nlohmann::json& j, const ScriptedFloatAnimation& f) {
+    j = nlohmann::json{{"name", f.GetName()}, {"type", "scripted_float"}};
+    auto v_array = nlohmann::json::array();
+    for (auto& k : f.GetAllKeys()) {
+        v_array.push_back(f[k]);
+    }
+    j["keys"] = v_array;
+}
+
+void animation::from_json(const nlohmann::json& j, ScriptedFloatAnimation& f) {
+    f = ScriptedFloatAnimation{j.at("name")};
+    assert(j.at("type") == "scripted_float");
+    for (auto& j : j["keys"]) {
+        ScriptedFloatKey k;
+        j.get_to(k);
+        f.AddKey(k);
+    }
+}
+
+void animation::to_json(nlohmann::json& j, const ScriptedStringAnimation& s) {
+    j = nlohmann::json{{"name", s.GetName()}, {"type", "scripted_string"}};
+    auto v_array = nlohmann::json::array();
+    for (auto& k : s.GetAllKeys()) {
+        v_array.push_back(s[k]);
+    }
+    j["keys"] = v_array;
+}
+
+void animation::from_json(const nlohmann::json& j, ScriptedStringAnimation& s) {
+    s = ScriptedStringAnimation{j.at("name")};
+    assert(j.at("type") == "scripted_string");
+    for (auto& j : j["keys"]) {
+        ScriptedStringKey k;
+        j.get_to(k);
+        s.AddKey(k);
+    }
+}
+
 // this does not seem okay
 #if 0
 static ImVector<ImRect> s_GroupPanelLabelStack;

frontend/main/src/CLIConfigParsing.cpp

@@ -9,10 +9,10 @@
 #include <cstdio>
 #include <cstdlib>
 #include <filesystem>
+#include <fstream>
 
 #define CXXOPTS_VECTOR_DELIMITER '\0'
 #include <cxxopts.hpp>
-#include <fstream>
 
 // find user home
 static std::filesystem::path getHomeDir() {
@@ -809,8 +809,6 @@ megamol::frontend_resources::RuntimeConfig megamol::frontend::handle_config(
             accepted_log_level_strings,
         make_option_callback(echolevel_option));
 
-    //lua.AddCallbacks(lua_config_callbacks);
-
     for (auto& file : config.configuration_files) {
         cli_options_from_configs.clear();
         std::ifstream stream(file);
@@ -868,8 +866,6 @@ megamol::frontend_resources::RuntimeConfig megamol::frontend::handle_config(
                 [](std::string const& init, std::string const& elem) { return init + elem + " "; }));
     }
 
-    //lua.ClearCallbacks();
-
     return config;
 }