Merge remote-tracking branch 'origin/master' into thesis/2021/skybrowser

# Conflicts:
#	data/assets/util/asset_helper.asset
#	data/assets/util/webgui.asset

include/openspace/camera/camera.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -31,6 +31,7 @@
 
 namespace openspace {
 
+struct CameraPose;
 class SceneGraphNode;
 
 /**
@@ -67,6 +68,7 @@ public:
     ~Camera() = default;
 
     // Mutators
+    void setPose(CameraPose pose);
     void setPositionVec3(glm::dvec3 pos);
     void setRotation(glm::dquat rotation);
     void setScaling(float scaling);

include/openspace/camera/camerapose.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/documentation/core_registration.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/documentation/documentation.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/documentation/documentationengine.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/documentation/documentationgenerator.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/documentation/verifier.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -525,10 +525,6 @@ struct LessVerifier : public OperatorVerifier<T, std::less<typename T::Type>> {
         !std::is_base_of<StringVerifier, T>::value, "T cannot be StringVerifier"
     );
     static_assert(!std::is_base_of<TableVerifier, T>::value, "T cannot be TableVerifier");
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     using OperatorVerifier<T, std::less<typename T::Type>>::OperatorVerifier;
 
@@ -550,10 +546,6 @@ struct LessEqualVerifier : public OperatorVerifier<T, std::less_equal<typename T
         "T cannot be StringVerifier"
     );
     static_assert(!std::is_base_of<TableVerifier, T>::value, "T cannot be TableVerifier");
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     using OperatorVerifier<T, std::less_equal<typename T::Type>>::OperatorVerifier;
 
@@ -575,10 +567,6 @@ struct GreaterVerifier : public OperatorVerifier<T, std::greater<typename T::Typ
         "T cannot be StringVerifier"
     );
     static_assert(!std::is_base_of<TableVerifier, T>::value, "T cannot be TableVerifier");
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     using OperatorVerifier<T, std::greater<typename T::Type>>::OperatorVerifier;
 
@@ -602,10 +590,6 @@ struct GreaterEqualVerifier : public OperatorVerifier<T,
         "T cannot be StringVerifier"
     );
     static_assert(!std::is_base_of<TableVerifier, T>::value, "T cannot be TableVerifier");
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     using OperatorVerifier<T, std::greater_equal<typename T::Type>>::OperatorVerifier;
 
@@ -754,10 +738,6 @@ struct InRangeVerifier : public T {
         !std::is_base_of<TableVerifier, T>::value,
         "T cannot be TableVerifier"
     );
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     /**
      * Constructs a InRangeVerifier that checks whether the incoming value is of the
@@ -816,10 +796,6 @@ struct NotInRangeVerifier : public T {
         !std::is_base_of<TableVerifier, T>::value,
         "T cannot be TableVerifier"
     );
-    static_assert(
-        !std::is_base_of<VectorVerifier, T>::value,
-        "T cannot be VectorVerifier"
-    );
 
     /**
      * Constructs a InRangeVerifier that checks whether the incoming value is of the
@@ -1145,6 +1121,8 @@ using StringNotInListVerifier = NotInListVerifier<StringVerifier>;
 using IntInRangeVerifier = InRangeVerifier<IntVerifier>;
 /// A short-hand definition for a InRangeVerifier with a type check for \c double
 using DoubleInRangeVerifier = InRangeVerifier<DoubleVerifier>;
+/// A short-hand definition for a InRangeVerifier with a type check for \c vec2
+using Vec2InRangeVerifier = InRangeVerifier<DoubleVector2Verifier>;
 /// A short-hand definition for a NotInRangeVerifier with a type check for \c int
 using IntNotInRangeVerifier = NotInRangeVerifier<IntVerifier>;
 /// A short-hand definition for a NotInRangeVerifier with a type check for \c double

include/openspace/documentation/verifier.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -24,9 +24,388 @@
 
 #include <ghoul/misc/dictionary.h>
 
+#include <ghoul/misc/assert.h>
 #include <iterator>
 #include <sstream>
 
+template <>
+struct std::less<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x < b.x && a.x < b.y;
+    }
+};
+
+template <>
+struct std::less<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z;
+    }
+};
+
+template <>
+struct std::less<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z && a.w < b.w;
+    }
+};
+
+template <>
+struct std::less<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x < b.x && a.x < b.y;
+    }
+};
+
+template <>
+struct std::less<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z;
+    }
+};
+
+template <>
+struct std::less<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z && a.w < b.w;
+    }
+};
+
+template <>
+struct std::less<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x < b.x && a.x < b.y;
+    }
+};
+
+template <>
+struct std::less<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z;
+    }
+};
+
+template <>
+struct std::less<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x < b.x && a.x < b.y && a.z < b.z && a.w < b.w;
+    }
+};
+
+template <>
+struct std::less_equal<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x <= b.x && a.x <= b.y;
+    }
+};
+
+template <>
+struct std::less_equal<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z;
+    }
+};
+
+template <>
+struct std::less_equal<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z && a.w <= b.w;
+    }
+};
+
+template <>
+struct std::less_equal<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x <= b.x && a.x <= b.y;
+    }
+};
+
+template <>
+struct std::less_equal<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z;
+    }
+};
+
+template <>
+struct std::less_equal<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z && a.w <= b.w;
+    }
+};
+
+template <>
+struct std::less_equal<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x <= b.x && a.x <= b.y;
+    }
+};
+
+template <>
+struct std::less_equal<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z;
+    }
+};
+
+template <>
+struct std::less_equal<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x <= b.x && a.x <= b.y && a.z <= b.z && a.w <= b.w;
+    }
+};
+
+template <>
+struct std::greater<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x > b.x && a.x > b.y;
+    }
+};
+
+template <>
+struct std::greater<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z;
+    }
+};
+
+template <>
+struct std::greater<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z && a.w > b.w;
+    }
+};
+
+template <>
+struct std::greater<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x > b.x && a.x > b.y;
+    }
+};
+
+template <>
+struct std::greater<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z;
+    }
+};
+
+template <>
+struct std::greater<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z && a.w > b.w;
+    }
+};
+
+template <>
+struct std::greater<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x > b.x && a.x > b.y;
+    }
+};
+
+template <>
+struct std::greater<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z;
+    }
+};
+
+template <>
+struct std::greater<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x > b.x && a.x > b.y && a.z > b.z && a.w > b.w;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x >= b.x && a.x >= b.y;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z && a.w >= b.w;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x >= b.x && a.x >= b.y;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z && a.w >= b.w;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x >= b.x && a.x >= b.y;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z;
+    }
+};
+
+template <>
+struct std::greater_equal<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x >= b.x && a.x >= b.y && a.z >= b.z && a.w >= b.w;
+    }
+};
+
+template <>
+struct std::equal_to<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x == b.x && a.x == b.y;
+    }
+};
+
+template <>
+struct std::equal_to<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z;
+    }
+};
+
+template <>
+struct std::equal_to<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z && a.w == b.w;
+    }
+};
+
+template <>
+struct std::equal_to<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x == b.x && a.x == b.y;
+    }
+};
+
+template <>
+struct std::equal_to<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z;
+    }
+};
+
+template <>
+struct std::equal_to<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z && a.w == b.w;
+    }
+};
+
+template <>
+struct std::equal_to<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x == b.x && a.x == b.y;
+    }
+};
+
+template <>
+struct std::equal_to<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z;
+    }
+};
+
+template <>
+struct std::equal_to<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x == b.x && a.x == b.y && a.z == b.z && a.w == b.w;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::vec2> {
+    bool operator()(const glm::vec2& a, const glm::vec2& b) const {
+        return a.x != b.x && a.x != b.y;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::vec3> {
+    bool operator()(const glm::vec3& a, const glm::vec3& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::vec4> {
+    bool operator()(const glm::vec4& a, const glm::vec4& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z && a.w != b.w;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::ivec2> {
+    bool operator()(const glm::ivec2& a, const glm::ivec2& b) const {
+        return a.x != b.x && a.x != b.y;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::ivec3> {
+    bool operator()(const glm::ivec3& a, const glm::ivec3& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::ivec4> {
+    bool operator()(const glm::ivec4& a, const glm::ivec4& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z && a.w != b.w;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::dvec2> {
+    bool operator()(const glm::dvec2& a, const glm::dvec2& b) const {
+        return a.x != b.x && a.x != b.y;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::dvec3> {
+    bool operator()(const glm::dvec3& a, const glm::dvec3& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z;
+    }
+};
+
+template <>
+struct std::not_equal_to<glm::dvec4> {
+    bool operator()(const glm::dvec4& a, const glm::dvec4& b) const {
+        return a.x != b.x && a.x != b.y && a.z != b.z && a.w != b.w;
+    }
+};
+
 namespace openspace::documentation {
 
 template <>
@@ -75,62 +454,158 @@ std::string TemplateVerifier<T>::documentation() const {
 
 template <typename T>
 std::string Vector2Verifier<T>::type() const {
-    return std::string("Vector2<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Vector2<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Vector2<double>";
+    }
+    else {
+        return std::string("Vector2<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Vector3Verifier<T>::type() const {
-    return std::string("Vector3<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Vector3<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Vector3<double>";
+    }
+    else {
+        return std::string("Vector3<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Vector4Verifier<T>::type() const {
-    return std::string("Vector4<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Vector4<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Vector4<double>";
+    }
+    else {
+        return std::string("Vector4<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix2x2Verifier<T>::type() const {
-    return std::string("Matrix2x2<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix2x2<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix2x2<double>";
+    }
+    else {
+        return std::string("Matrix2x2<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix2x3Verifier<T>::type() const {
-    return std::string("Matrix2x3<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix2x3<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix2x3<double>";
+    }
+    else {
+        return std::string("Matrix2x3<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix2x4Verifier<T>::type() const {
-    return std::string("Matrix2x4<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix2x4<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix2x4<double>";
+    }
+    else {
+        return std::string("Matrix2x4<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix3x2Verifier<T>::type() const {
-    return std::string("Matrix3x2<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix3x2<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix3x2<double>";
+    }
+    else {
+        return std::string("Matrix3x2<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix3x3Verifier<T>::type() const {
-    return std::string("Matrix3x3<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix3x3<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix3x3<double>";
+    }
+    else {
+        return std::string("Matrix3x3<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix3x4Verifier<T>::type() const {
-    return std::string("Matrix3x4<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix3x4<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix3x4<double>";
+    }
+    else {
+        return std::string("Matrix3x4<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix4x2Verifier<T>::type() const {
-    return std::string("Matrix4x2<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix4x2<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix4x2<double>";
+    }
+    else {
+        return std::string("Matrix4x2<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix4x3Verifier<T>::type() const {
-    return std::string("Matrix4x3<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix4x3<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix4x3<double>";
+    }
+    else {
+        return std::string("Matrix4x3<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T>
 std::string Matrix4x4Verifier<T>::type() const {
-    return std::string("Matrix4x4<") + typeid(T).name() + ">";
+    if constexpr (std::is_same_v<T, int>) {
+        return "Matrix4x4<int>";
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        return "Matrix4x4<double>";
+    }
+    else {
+        return std::string("Matrix4x4<") + typeid(T).name() + ">";
+    }
 }
 
 template <typename T, typename Operator>
@@ -145,7 +620,16 @@ TestResult OperatorVerifier<T, Operator>::operator()(const ghoul::Dictionary& di
     TestResult res = T::operator()(dict, key);
     if (res.success) {
         typename T::Type val;
-        if constexpr (std::is_same_v<typename T::Type, int>) {
+        if constexpr (std::is_same_v<typename T::Type, glm::ivec2>) {
+            val = dict.value<glm::dvec2>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec3>) {
+            val = dict.value<glm::dvec3>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec4>) {
+            val = dict.value<glm::dvec4>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, int>) {
             const double d = dict.value<double>(key);
             double intPart;
             bool isInt = modf(d, &intPart) == 0.0;
@@ -165,6 +649,7 @@ TestResult OperatorVerifier<T, Operator>::operator()(const ghoul::Dictionary& di
         else {
             val = dict.value<typename T::Type>(key);
         }
+
         if (Operator()(val, value)) {
             return { true, {}, {} };
         }
@@ -224,10 +709,38 @@ TestResult InListVerifier<T>::operator()(const ghoul::Dictionary& dict,
 {
     TestResult res = T::operator()(dict, key);
     if (res.success) {
-        typename T::Type value = dict.value<typename T::Type>(key);
-
-        auto it = std::find(values.begin(), values.end(), value);
+        typename T::Type val;
+        if constexpr (std::is_same_v<typename T::Type, glm::ivec2>) {
+            val = dict.value<glm::dvec2>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec3>) {
+            val = dict.value<glm::dvec3>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec4>) {
+            val = dict.value<glm::dvec4>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, int>) {
+            const double d = dict.value<double>(key);
+            double intPart;
+            bool isInt = modf(d, &intPart) == 0.0;
+            if (isInt) {
+                val = static_cast<int>(d);
+            }
+            else {
+                TestResult r;
+                r.success = false;
+                TestResult::Offense o;
+                o.offender = key;
+                o.reason = TestResult::Offense::Reason::WrongType;
+                r.offenses.push_back(o);
+                return r;
+            }
+        }
+        else {
+            val = dict.value<typename T::Type>(key);
+        }
 
+        auto it = std::find(values.begin(), values.end(), val);
         if (it != values.end()) {
             return { true, {}, {} };
         }
@@ -276,10 +789,38 @@ TestResult NotInListVerifier<T>::operator()(const ghoul::Dictionary& dict,
 {
     TestResult res = T::operator()(dict, key);
     if (res.success) {
-        typename T::Type value = dict.value<typename T::Type>(key);
-
-        auto it = std::find(values.begin(), values.end(), value);
+        typename T::Type val;
+        if constexpr (std::is_same_v<typename T::Type, glm::ivec2>) {
+            val = dict.value<glm::dvec2>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec3>) {
+            val = dict.value<glm::dvec3>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec4>) {
+            val = dict.value<glm::dvec4>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, int>) {
+            const double d = dict.value<double>(key);
+            double intPart;
+            bool isInt = modf(d, &intPart) == 0.0;
+            if (isInt) {
+                val = static_cast<int>(d);
+            }
+            else {
+                TestResult r;
+                r.success = false;
+                TestResult::Offense o;
+                o.offender = key;
+                o.reason = TestResult::Offense::Reason::WrongType;
+                r.offenses.push_back(o);
+                return r;
+            }
+        }
+        else {
+            val = dict.value<typename T::Type>(key);
+        }
 
+        auto it = std::find(values.begin(), values.end(), val);
         if (it == values.end()) {
             return { true, {}, {} };
         }
@@ -322,7 +863,30 @@ InRangeVerifier<T>::InRangeVerifier(typename T::Type l, typename T::Type u)
     : lower(std::move(l))
     , upper(std::move(u))
 {
-    ghoul_assert(lower <= upper, "lower must be smaller or equal to upper");
+    if constexpr (std::is_same_v<IntVector2Verifier, T> ||
+                  std::is_same_v<DoubleVector2Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+    }
+    else if constexpr (std::is_same_v<IntVector3Verifier, T> ||
+                       std::is_same_v<DoubleVector3Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+        ghoul_assert(lower.z <= upper.z, "lower must be smaller or equal to upper for z");
+    }
+    else if constexpr (std::is_same_v<IntVector4Verifier, T> ||
+                       std::is_same_v<DoubleVector4Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+        ghoul_assert(lower.z <= upper.z, "lower must be smaller or equal to upper for z");
+        ghoul_assert(lower.w <= upper.w, "lower must be smaller or equal to upper for w");
+    }
+    else {
+        ghoul_assert(lower <= upper, "lower must be smaller or equal to upper");
+    }
 }
 
 template <typename T>
@@ -332,7 +896,16 @@ TestResult InRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
     TestResult res = T::operator()(dict, key);
     if (res.success) {
         typename T::Type val;
-        if constexpr (std::is_same_v<typename T::Type, int>) {
+        if constexpr (std::is_same_v<typename T::Type, glm::ivec2>) {
+            val = dict.value<glm::dvec2>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec3>) {
+            val = dict.value<glm::dvec3>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec4>) {
+            val = dict.value<glm::dvec4>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, int>) {
             const double d = dict.value<double>(key);
             double intPart;
             bool isInt = modf(d, &intPart) == 0.0;
@@ -353,7 +926,9 @@ TestResult InRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
             val = dict.value<typename T::Type>(key);
         }
 
-        if (val >= lower && val <= upper) {
+        if (std::greater_equal<typename T::Type>()(val, lower) &&
+            std::less_equal<typename T::Type>()(val, upper))
+        {
             return { true, {}, {} };
         }
         else {
@@ -382,7 +957,30 @@ NotInRangeVerifier<T>::NotInRangeVerifier(typename T::Type l, typename T::Type u
     : lower(std::move(l))
     , upper(std::move(u))
 {
-    ghoul_assert(lower <= upper, "lower must be smaller or equal to upper");
+    if constexpr (std::is_same_v<IntVector2Verifier, T> ||
+                  std::is_same_v<DoubleVector2Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+    }
+    else if constexpr (std::is_same_v<IntVector3Verifier, T> ||
+                       std::is_same_v<DoubleVector3Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+        ghoul_assert(lower.z <= upper.z, "lower must be smaller or equal to upper for z");
+    }
+    else if constexpr (std::is_same_v<IntVector4Verifier, T> ||
+                       std::is_same_v<DoubleVector4Verifier, T>)
+    {
+        ghoul_assert(lower.x <= upper.x, "lower must be smaller or equal to upper for x");
+        ghoul_assert(lower.y <= upper.y, "lower must be smaller or equal to upper for y");
+        ghoul_assert(lower.z <= upper.z, "lower must be smaller or equal to upper for z");
+        ghoul_assert(lower.w <= upper.w, "lower must be smaller or equal to upper for w");
+    }
+    else {
+        ghoul_assert(lower <= upper, "lower must be smaller or equal to upper");
+    }
 }
 
 template <typename T>
@@ -391,7 +989,16 @@ TestResult NotInRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
     TestResult res = T::operator()(dict, key);
     if (res.success) {
         typename T::Type val;
-        if constexpr (std::is_same_v<typename T::Type, int>) {
+        if constexpr (std::is_same_v<typename T::Type, glm::ivec2>) {
+            val = dict.value<glm::dvec2>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec3>) {
+            val = dict.value<glm::dvec3>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, glm::ivec4>) {
+            val = dict.value<glm::dvec4>(key);
+        }
+        else if constexpr (std::is_same_v<typename T::Type, int>) {
             const double d = dict.value<double>(key);
             double intPart;
             bool isInt = modf(d, &intPart) == 0.0;
@@ -412,7 +1019,12 @@ TestResult NotInRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
             val = dict.value<typename T::Type>(key);
         }
 
-        if (val >= lower && val <= upper) {
+        if (std::less<typename T::Type>()(val, lower) ||
+            std::greater<typename T::Type>()(val, upper))
+        {
+            return { true, {}, {} };
+        }
+        else {
             TestResult r;
             r.success = false;
             TestResult::Offense o;
@@ -421,9 +1033,6 @@ TestResult NotInRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
             r.offenses.push_back(o);
             return r;
         }
-        else {
-            return { true, {}, {} };
-        }
     }
     else {
         return res;

include/openspace/engine/configuration.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -141,7 +141,7 @@ struct Configuration {
 std::filesystem::path findConfiguration(const std::string& filename = "openspace.cfg");
 
 Configuration loadConfigurationFromFile(const std::filesystem::path& filename,
-    const std::string& overrideScript);
+    const glm::ivec2& primaryMonitorResolution, const std::string& overrideScript);
 
 } // namespace openspace::configuration
 

include/openspace/engine/downloadmanager.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/globals.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -49,7 +49,6 @@ class ScreenSpaceRenderable;
 class SyncEngine;
 class TimeManager;
 class VersionChecker;
-class VirtualPropertyManager;
 struct WindowDelegate;
 namespace configuration { struct Configuration; }
 namespace interaction {
@@ -88,7 +87,6 @@ inline std::vector<std::unique_ptr<ScreenSpaceRenderable>>* screenSpaceRenderabl
 inline SyncEngine* syncEngine;
 inline TimeManager* timeManager;
 inline VersionChecker* versionChecker;
-inline VirtualPropertyManager* virtualPropertyManager;
 inline WindowDelegate* windowDelegate;
 inline configuration::Configuration* configuration;
 inline interaction::ActionManager* actionManager;

include/openspace/engine/globalscallbacks.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/logfactory.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/moduleengine.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/moduleengine.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/openspaceengine.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -65,6 +65,15 @@ struct CommandlineArguments {
 
 class OpenSpaceEngine {
 public:
+    // A mode that specifies which part of the system is currently in control.
+    // The mode can be used to limit certain features, like setting time, navigation
+    // or triggering scripts
+    enum class Mode {
+        UserControl = 0,
+        SessionRecordingPlayback,
+        CameraPath
+    };
+
     OpenSpaceEngine();
     ~OpenSpaceEngine();
 
@@ -92,9 +101,12 @@ public:
     std::vector<std::byte> encode();
     void decode(std::vector<std::byte> data);
 
-    void scheduleLoadSingleAsset(std::string assetPath);
     void toggleShutdownMode();
 
+    Mode currentMode() const;
+    bool setMode(Mode newMode);
+    void resetMode();
+
     // Guaranteed to return a valid pointer
     AssetManager& assetManager();
     LoadingScreen* loadingScreen();
@@ -110,11 +122,10 @@ public:
     static scripting::LuaLibrary luaLibrary();
 
 private:
-    void loadAsset(const std::string& assetName);
+    void loadAssets();
     void loadFonts();
 
     void runGlobalCustomizationScripts();
-    void configureLogging();
     std::string generateFilePath(std::string openspaceRelativePath);
     void resetPropertyChangeFlagsOfSubowners(openspace::properties::PropertyOwner* po);
 
@@ -126,9 +137,6 @@ private:
     std::unique_ptr<LoadingScreen> _loadingScreen;
     std::unique_ptr<VersionChecker> _versionChecker;
 
-    bool _hasScheduledAssetLoading = false;
-    std::string _scheduledAssetPathToLoad;
-
     glm::vec2 _mousePosition = glm::vec2(0.f);
 
     //grabs json from each module to pass to the documentation engine.
@@ -141,6 +149,8 @@ private:
     // The first frame might take some more time in the update loop, so we need to know to
     // disable the synchronization; otherwise a hardware sync will kill us after 1 minute
     bool _isRenderingFirstFrame = true;
+
+    Mode _currentMode = Mode::UserControl;
 };
 
 /**

include/openspace/engine/syncengine.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/engine/windowdelegate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -76,7 +76,8 @@ struct WindowDelegate {
 
     bool (*isFisheyeRendering)() = []() { return false; };
 
-    unsigned int (*takeScreenshot)(bool applyWarping) = [](bool) { return 0u; };
+    unsigned int (*takeScreenshot)(bool applyWarping, std::vector<int> windowIds) =
+        [](bool, std::vector<int>) { return 0u; };
 
     void (*swapBuffer)() = []() {};
 

include/openspace/events/event.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/events/eventengine.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/events/eventengine.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/action.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/actionmanager.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/camerainteractionstates.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -30,8 +30,6 @@
 
 namespace openspace::interaction {
 
-class InputState;
-
 class CameraInteractionStates {
 public:
     /**
@@ -42,8 +40,6 @@ public:
     CameraInteractionStates(double sensitivity, double velocityScaleFactor);
     virtual ~CameraInteractionStates() = default;
 
-    virtual void updateStateFromInput(const InputState& inputState, double deltaTime) = 0;
-
     void setRotationalFriction(double friction);
     void setHorizontalFriction(double friction);
     void setVerticalFriction(double friction);

include/openspace/interaction/delayedvariable.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/delayedvariable.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/externinteraction.h

@@ -1,82 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
- *                                                                                       *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
- * software and associated documentation files (the "Software"), to deal in the Software *
- * without restriction, including without limitation the rights to use, copy, modify,    *
- * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
- * permit persons to whom the Software is furnished to do so, subject to the following   *
- * conditions:                                                                           *
- *                                                                                       *
- * The above copyright notice and this permission notice shall be included in all copies *
- * or substantial portions of the Software.                                              *
- *                                                                                       *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
- * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
- ****************************************************************************************/
-
-#ifndef __OPENSPACE_CORE___EXTERNINTERACTION___H__
-#define __OPENSPACE_CORE___EXTERNINTERACTION___H__
-
-#include <openspace/network/messagestructures.h>
-#include <openspace/properties/propertyowner.h>
-#include <ghoul/io/socket/tcpsocket.h>
-
-#include <vector>
-
-namespace openspace {
-
-class ExternInteraction : public properties::PropertyOwner {
-public:
-    ExternInteraction();
-    /**
-    * Method that generates a keyframeNavigator CameraPose from a CameraKeyframe
-    * object, and then adds this to the navigationHandler's keyframe navigator.
-    * \param kf The camera keyframe to add.
-    */
-    void cameraInteraction(datamessagestructures::CameraKeyframe kf);
-    /**
-    * Method that generates a TimeKeyframeData from a TimeKeyframe object, and
-    * then adds this to the timeManager.
-    * \param kf The time keyframe to add.
-    */
-    void timeInteraction(datamessagestructures::TimeKeyframe kf);
-    /**
-    * Method that passes a ScriptMessage object to the script engine, calling its
-    * queueScript method to add it for execution.
-    * \param sm The ScriptMessage object to queue in the script engine.
-    */
-    void scriptInteraction(datamessagestructures::ScriptMessage sm);
-    /**
-    * Method that accepts a reference to a CameraKeyframe object, and populates
-    * it with the current properties of the camera from the navigation handler.
-    * \returns CameraKeyframe with current state from NavigationHandler.
-    */
-    datamessagestructures::CameraKeyframe generateCameraKeyframe();
-    /**
-    * Method that accepts a reference to a TimeKeyframe object, and populates
-    * it with the current time values from the application time manager.
-    * \returns TimeKeyframe The time keyframe.
-    */
-    datamessagestructures::TimeKeyframe generateTimeKeyframe();
-    /**
-    * Method that accepts a reference to a ScriptMessage object and a script
-    * string, and populates the ScriptMessage with the script and timestamp
-    * of the current application time.
-    * \param script The script to execute in std::string form.
-    * \returns ScriptMessage The ScriptMessage data structure with script.
-    */
-    datamessagestructures::ScriptMessage generateScriptMessage(std::string script);
-private:
-};
-
-} // namespace openspace
-
-#endif // __OPENSPACE_CORE___EXTERNINTERACTION___H__

include/openspace/interaction/interactionmonitor.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/interpolator.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/interpolator.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/joystickcamerastates.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -49,17 +49,22 @@ public:
         GlobalRollX,
         GlobalRollY,
         PanX,
-        PanY
+        PanY,
+        Property
+    };
+
+    enum class JoystickType {
+        JoystickLike,
+        TriggerLike
     };
 
     BooleanType(AxisInvert);
-    BooleanType(AxisNormalize);
     BooleanType(ButtonCommandRemote);
 
     struct AxisInformation {
         AxisType type = AxisType::None;
         AxisInvert invert = AxisInvert::No;
-        AxisNormalize normalize = AxisNormalize::No;
+        JoystickType joystickType = JoystickType::JoystickLike;
 
         // The axis values can either go back to 0 when the joystick is released or it can
         // stay at the value it was before the joystick was released.
@@ -70,49 +75,83 @@ public:
 
         // Every axis can have their own sensitivity
         double sensitivity = 0.0;
+
+        // The property info if the type is Property
+        std::string propertyUri;
+        float minValue = 0.f;
+        float maxValue = 1.f;
+        bool isRemote = true;
     };
 
     JoystickCameraStates(double sensitivity, double velocityScaleFactor);
 
-    void updateStateFromInput(const InputState& inputState, double deltaTime) override;
+    void updateStateFromInput(
+        const JoystickInputStates& joystickInputStates, double deltaTime);
 
-    void setAxisMapping(int axis, AxisType mapping,
+    void setAxisMapping(std::string joystickName, int axis, AxisType mapping,
         AxisInvert shouldInvert = AxisInvert::No,
-        AxisNormalize shouldNormalize = AxisNormalize::No,
+        JoystickType joystickType = JoystickType::JoystickLike,
         bool isSticky = false, double sensitivity = 0.0
     );
 
-    AxisInformation axisMapping(int axis) const;
+    void setAxisMappingProperty(std::string joystickName, int axis,
+        std::string propertyUri, float min = 0.f, float max = 1.f,
+        AxisInvert shouldInvert = AxisInvert::No, bool isRemote = true
+    );
 
-    void setDeadzone(int axis, float deadzone);
-    float deadzone(int axis) const;
+    AxisInformation axisMapping(const std::string& joystickName, int axis) const;
 
+    void setDeadzone(const std::string& joystickName, int axis, float deadzone);
+    float deadzone(const std::string& joystickName, int axis) const;
 
-    void bindButtonCommand(int button, std::string command, JoystickAction action,
-        ButtonCommandRemote remote, std::string documentation);
-    void clearButtonCommand(int button);
-    std::vector<std::string> buttonCommand(int button) const;
+    void bindButtonCommand(const std::string& joystickName, int button,
+        std::string command, JoystickAction action, ButtonCommandRemote remote,
+        std::string documentation);
+    void clearButtonCommand(const std::string& joystickName, int button);
+    std::vector<std::string> buttonCommand(const std::string& joystickName,
+        int button) const;
 
 private:
-    // We use an array for the axes and a map for the buttons since the axis are going to
-    // be accessed much more often and thus have to be more efficient. And storing a few
-    // extra AxisInformation that are not used will not matter that much; finding an axis
-    // location in a potential map each frame, however, would
+    struct JoystickCameraState {
+        std::string joystickName;
 
-    std::array<AxisInformation, JoystickInputState::MaxAxes> _axisMapping;
+        // We use an array for the axes and a map for the buttons since the axis are going to
+        // be accessed much more often and thus have to be more efficient. And storing a few
+        // extra AxisInformation that are not used will not matter that much; finding an axis
+        // location in a potential map each frame, however, would
+        std::array<AxisInformation, JoystickInputState::MaxAxes> axisMapping;
 
-    // This array is used to store the old axis values from the previous frame,
-    // it is used to calculate the difference in the values in the case of a sticky axis
-    std::array<float, JoystickInputState::MaxAxes> _prevAxisValues;
+        // This array is used to store the old axis values from the previous frame,
+        // it is used to calculate the difference in the values in the case of a sticky axis
+        std::array<float, JoystickInputState::MaxAxes> prevAxisValues;
 
-    struct ButtonInformation {
-        std::string command;
-        JoystickAction action;
-        ButtonCommandRemote synchronization;
-        std::string documentation;
+        struct ButtonInformation {
+            // The script that is run when the button is activated
+            std::string command;
+
+            // When is the button considered activated
+            JoystickAction action;
+
+            // If the script should be syncronised to other remote sessions or not
+            ButtonCommandRemote synchronization;
+
+            // Short documentation on what the script of this button does
+            std::string documentation;
+        };
+
+        std::multimap<int, ButtonInformation> buttonMapping;
     };
 
-    std::multimap<int, ButtonInformation> _buttonMapping;
+    std::vector<JoystickCameraState> _joystickCameraStates;
+
+    // Find the item in _joystickCameraStates that corresponds to the given joystickName
+    // return a pointer to the item, if not found then return nullptr
+    JoystickCameraState* joystickCameraState(const std::string& joystickName);
+    const JoystickCameraState* joystickCameraState(const std::string& joystickName) const;
+
+    // Ues getJoystickCameraState(name) to find the joystickCameraState that
+    // corresponds to the given joystickName. If not found then add a new item if possible
+    JoystickCameraState* findOrAddJoystickCameraState(const std::string& joystickName);
 };
 
 } // namespace openspace::interaction
@@ -137,6 +176,7 @@ inline std::string to_string(
         case T::GlobalRollY: return "GlobalRoll Y";
         case T::PanX:        return "Pan X";
         case T::PanY:        return "Pan Y";
+        case T::Property:    return "Property";
         default:             return "";
         }
 }
@@ -159,10 +199,35 @@ from_string(std::string_view string)
     if (string == "GlobalRoll Y") { return T::GlobalRollY; }
     if (string == "Pan X") { return T::PanX; }
     if (string == "Pan Y") { return T::PanY; }
+    if (string == "Property") { return T::Property; }
 
     throw RuntimeError("Unkonwn axis type '" + std::string(string) + "'");
 }
 
+template <>
+inline std::string to_string(
+    const openspace::interaction::JoystickCameraStates::JoystickType& value)
+{
+    using T = openspace::interaction::JoystickCameraStates::JoystickType;
+    switch (value) {
+        case T::JoystickLike: return "JoystickLike";
+        case T::TriggerLike:  return "TriggerLike";
+        default:              return "";
+    }
+}
+
+template <>
+constexpr openspace::interaction::JoystickCameraStates::JoystickType
+from_string(std::string_view string)
+{
+    using T = openspace::interaction::JoystickCameraStates::JoystickType;
+
+    if (string == "JoystickLike") { return T::JoystickLike; }
+    if (string == "TriggerLike") { return T::TriggerLike; }
+
+    throw RuntimeError("Unkonwn joystick type '" + std::string(string) + "'");
+}
+
 } // namespace ghoul
 
 #endif // __OPENSPACE_CORE___JOYSTICKCAMERASTATES___H__

include/openspace/interaction/joystickinputstate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -54,10 +54,11 @@ enum class JoystickAction : uint8_t {
  * The input state of a single joystick.
  */
 struct JoystickInputState {
+    /// These two are just randomly selected numbers that can be increased if needed
     /// The maximum number of supported axes
     static constexpr const int MaxAxes = 8;
     /// The maximum number of supported buttons
-    static constexpr const int MaxButtons = 32;
+    static constexpr const int MaxButtons = 48;
 
     /// Marks whether this joystick is connected. If this value is \c false, all other
     /// members of this struct are undefined
@@ -72,11 +73,6 @@ struct JoystickInputState {
     /// \c nAxes values are defined values, the rest are undefined
     std::array<float, MaxAxes> axes;
 
-    /// The axis values can either go back to 0 when the joystick is released or it can
-    /// stay at the value it was before the joystick was released.
-    /// The latter is called a sticky axis, when the values don't go back to 0.
-    bool isSticky = false;
-
     /// The number of buttons that this joystick possesses
     int nButtons = 0;
     /// The status of each button. Only the first \c nButtons values are defined, the rest
@@ -88,6 +84,10 @@ struct JoystickInputState {
 /// derived from the available GLFW constants
 constexpr const int MaxJoysticks = 16;
 struct JoystickInputStates : public std::array<JoystickInputState, MaxJoysticks> {
+    /// The maximum number of joysticks that are supported by this system. This number is
+    /// derived from the available GLFW constants
+    static constexpr const int MaxNumJoysticks = 16;
+
     /**
      * This function adds the contributions of all connected joysticks for the provided
      * \p axis. After adding each joysticks contribution, the result is clamped to [-1,1].
@@ -99,7 +99,7 @@ struct JoystickInputStates : public std::array<JoystickInputState, MaxJoysticks>
      *
      * \pre \p axis must be 0 or positive
      */
-    float axis(int axis) const;
+    float axis(const std::string& joystickName, int axis) const;
 
     /**
      * This functions checks whether any connected joystick has its \p button in the
@@ -113,7 +113,7 @@ struct JoystickInputStates : public std::array<JoystickInputState, MaxJoysticks>
      *
      * \pre \p button must be 0 or positive
      */
-    bool button(int button, JoystickAction action) const;
+    bool button(const std::string& joystickName, int button, JoystickAction action) const;
 };
 
 } // namespace openspace::interaction

include/openspace/interaction/keybindingmanager.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/keyboardinputstate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -22,29 +22,30 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#ifndef __OPENSPACE_CORE___VIRTUALPROPERTYMANAGER___H__
-#define __OPENSPACE_CORE___VIRTUALPROPERTYMANAGER___H__
+#ifndef __OPENSPACE_CORE___KEYBOARDINPUTSTATE___H__
+#define __OPENSPACE_CORE___KEYBOARDINPUTSTATE___H__
 
-#include <openspace/properties/propertyowner.h>
-
-#include <memory>
+#include <openspace/util/keys.h>
 #include <vector>
 
-namespace openspace {
+namespace openspace::interaction {
 
-class Property;
-
-class VirtualPropertyManager : public properties::PropertyOwner {
+// This class represents the global input state of interaction devices
+class KeyboardInputState {
 public:
-    VirtualPropertyManager();
+    // Callback functions
+    void keyboardCallback(Key key, KeyModifier modifier, KeyAction action);
 
-    void addProperty(std::unique_ptr<properties::Property> prop);
-    void removeProperty(properties::Property* prop);
+    // Accessors
+    const std::vector<std::pair<Key, KeyModifier>>& pressedKeys() const;
+    bool isKeyPressed(std::pair<Key, KeyModifier> keyModPair) const;
+    bool isKeyPressed(Key key) const;
 
 private:
-    std::vector<std::unique_ptr<properties::Property>> _properties;
+    // Input from keyboard
+    std::vector<std::pair<Key, KeyModifier>> _keysDown;
 };
 
-} // namespace openspace
+} // namespace openspace::interaction
 
-#endif // __OPENSPACE_CORE___VIRTUALPROPERTYMANAGER___H__
+#endif // __OPENSPACE_CORE___KEYBOARDINPUTSTATE___H__

include/openspace/interaction/mousecamerastates.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -29,11 +29,15 @@
 
 namespace openspace::interaction {
 
+class MouseInputState;
+class KeyboardInputState;
+
 class MouseCameraStates : public CameraInteractionStates {
 public:
     MouseCameraStates(double sensitivity, double velocityScaleFactor);
 
-    void updateStateFromInput(const InputState& inputState, double deltaTime) override;
+    void updateStateFromInput(const MouseInputState& mouseinputState,
+        const KeyboardInputState& keyboardinputState, double deltaTime);
 
     void setInvertMouseButton(bool value);
 

include/openspace/interaction/mouseinputstate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -22,52 +22,30 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#ifndef __OPENSPACE_CORE___INPUTSTATE___H__
-#define __OPENSPACE_CORE___INPUTSTATE___H__
+#ifndef __OPENSPACE_CORE___MOUSEINPUTSTATE___H__
+#define __OPENSPACE_CORE___MOUSEINPUTSTATE___H__
 
-#include <openspace/interaction/websocketinputstate.h>
-#include <openspace/util/keys.h>
 #include <openspace/util/mouse.h>
 #include <ghoul/glm.h>
 #include <vector>
 
 namespace openspace::interaction {
 
-struct JoystickInputStates;
-struct WebsocketInputStates;
-
 // This class represents the global input state of interaction devices
-class InputState {
+class MouseInputState {
 public:
     // Callback functions
-    void keyboardCallback(Key key, KeyModifier modifier, KeyAction action);
     void mouseButtonCallback(MouseButton button, MouseAction action);
     void mousePositionCallback(double mouseX, double mouseY);
     void mouseScrollWheelCallback(double mouseScrollDelta);
 
     // Accessors
-    const std::vector<std::pair<Key, KeyModifier>>& pressedKeys() const;
-    bool isKeyPressed(std::pair<Key, KeyModifier> keyModPair) const;
-    bool isKeyPressed(Key key) const;
-
     const std::vector<MouseButton>& pressedMouseButtons() const;
     glm::dvec2 mousePosition() const;
     double mouseScrollDelta() const;
     bool isMouseButtonPressed(MouseButton mouseButton) const;
 
-    float joystickAxis(int i) const;
-    bool joystickButton(int i) const;
-
-    WebsocketInputStates& websocketInputStates();
-    float websocketAxis(int i) const;
-    bool websocketButton(int i) const;
-    bool hasWebsocketStates() const;
-    void resetWebsockets();
-
 private:
-    // Input from keyboard
-    std::vector<std::pair<Key, KeyModifier>> _keysDown;
-
     // Input from mouse
     std::vector<MouseButton> _mouseButtonsDown;
     glm::dvec2 _mousePosition = glm::dvec2(0.0);
@@ -76,4 +54,4 @@ private:
 
 } // namespace openspace::interaction
 
-#endif // __OPENSPACE_CORE___INPUTSTATE___H__
+#endif // __OPENSPACE_CORE___MOUSEINPUTSTATE___H__

include/openspace/interaction/scriptcamerastates.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -33,7 +33,7 @@ class ScriptCameraStates : public CameraInteractionStates {
 public:
     ScriptCameraStates();
 
-    void updateStateFromInput(const InputState& inputState, double deltaTime) override;
+    void updateStateFromInput(double deltaTime);
 
     void addLocalRotation(const glm::dvec2& delta);
     void addGlobalRotation(const glm::dvec2& delta);

include/openspace/interaction/sessionrecording.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -25,7 +25,8 @@
 #ifndef __OPENSPACE_CORE___SESSIONRECORDING___H__
 #define __OPENSPACE_CORE___SESSIONRECORDING___H__
 
-#include <openspace/interaction/externinteraction.h>
+#include <openspace/properties/propertyowner.h>
+
 #include <openspace/navigation/keyframenavigator.h>
 #include <openspace/properties/scalar/boolproperty.h>
 #include <openspace/scripting/lualibrary.h>
@@ -489,12 +490,12 @@ public:
     static std::string readHeaderElement(std::ifstream& stream, size_t readLen_chars);
 
     /**
- * Reads header information from a session recording file
- *
- * \param stringstream reference to ifstream that contains the session recording file data
- * \param readLen_chars number of characters to be read, which may be the expected
- *        length of the header line, or an arbitrary number of characters within it
- */
+     * Reads header information from a session recording file
+     *
+     * \param stringstream reference to ifstream that contains the session recording file data
+     * \param readLen_chars number of characters to be read, which may be the expected
+     *        length of the header line, or an arbitrary number of characters within it
+     */
     static std::string readHeaderElement(std::stringstream& stream, size_t readLen_chars);
 
     /**
@@ -596,12 +597,11 @@ protected:
         Script,
         Invalid
     };
-    struct timelineEntry {
+    struct TimelineEntry {
         RecordedType keyframeType;
         unsigned int idxIntoKeyframeTypeArray;
         Timestamps t3stamps;
     };
-    ExternInteraction _externInteract;
     double _timestampRecordStarted = 0.0;
     Timestamps _timestamps3RecordStarted;
     double _timestampPlaybackStarted_application = 0.0;
@@ -622,6 +622,8 @@ protected:
     bool playbackScript();
     bool playbackAddEntriesToTimeline();
     void signalPlaybackFinishedForComponent(RecordedType type);
+    void handlePlaybackEnd();
+
     bool findFirstCameraKeyframeInTimeline();
     Timestamps generateCurrentTimestamp3(double keyframeTime);
     static void saveStringToFile(const std::string& s, unsigned char* kfBuffer,
@@ -635,7 +637,7 @@ protected:
         datamessagestructures::TimeKeyframe keyframe, int lineNum);
     bool addKeyframe(Timestamps t3stamps,
         std::string scriptToQueue, int lineNum);
-    bool addKeyframeToTimeline(std::vector<timelineEntry>& timeline, RecordedType type,
+    bool addKeyframeToTimeline(std::vector<TimelineEntry>& timeline, RecordedType type,
             size_t indexIntoTypeKeyframes, Timestamps t3stamps, int lineNum);
 
     void initializePlayback_time(double now);
@@ -744,10 +746,10 @@ protected:
     std::vector<interaction::KeyframeNavigator::CameraPose> _keyframesCamera;
     std::vector<datamessagestructures::TimeKeyframe> _keyframesTime;
     std::vector<std::string> _keyframesScript;
-    std::vector<timelineEntry> _timeline;
+    std::vector<TimelineEntry> _timeline;
 
     std::vector<std::string> _keyframesSavePropertiesBaseline_scripts;
-    std::vector<timelineEntry> _keyframesSavePropertiesBaseline_timeline;
+    std::vector<TimelineEntry> _keyframesSavePropertiesBaseline_timeline;
     std::vector<std::string> _propertyBaselinesSaved;
     const std::vector<std::string> _propertyBaselineRejects = {
         "NavigationHandler.OrbitalNavigator.Anchor",

include/openspace/interaction/sessionrecording.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/tasks/convertrecfileversiontask.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/tasks/convertrecformattask.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/touchbar.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/interaction/websocketcamerastates.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -65,7 +65,8 @@ public:
 
     WebsocketCameraStates(double sensitivity, double velocityScaleFactor);
 
-    void updateStateFromInput(const InputState& inputState, double deltaTime) override;
+    void updateStateFromInput(
+        const WebsocketInputStates& websocketInputStates, double deltaTime);
 
     void setAxisMapping(int axis, AxisType mapping,
         AxisInvert shouldInvert = AxisInvert::No,

include/openspace/interaction/websocketinputstate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/json.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/mission/mission.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/mission/missionmanager.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/keyframenavigator.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -76,7 +76,6 @@ public:
     void removeKeyframesAfter(double timestamp, Inclusive inclusive = Inclusive::No);
     void clearKeyframes();
     size_t nKeyframes() const;
-    const std::vector<datamessagestructures::CameraKeyframe>& keyframes() const;
     double currentTime() const;
     void setTimeReferenceMode(KeyframeTimeRef refType, double referenceTimestamp);
 

include/openspace/navigation/navigationhandler.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -26,8 +26,9 @@
 #define __OPENSPACE_CORE___NAVIGATIONHANDLER___H__
 
 #include <openspace/documentation/documentation.h>
-#include <openspace/interaction/inputstate.h>
 #include <openspace/interaction/joystickcamerastates.h>
+#include <openspace/interaction/keyboardinputstate.h>
+#include <openspace/interaction/mouseinputstate.h>
 #include <openspace/interaction/websocketcamerastates.h>
 #include <openspace/navigation/keyframenavigator.h>
 #include <openspace/navigation/navigationstate.h>
@@ -67,21 +68,18 @@ public:
 
     // Mutators
     void setFocusNode(SceneGraphNode* node);
-    void resetCameraDirection();
-
     void setCamera(Camera* camera);
     void setInterpolationTime(float durationInSeconds);
 
     void updateCamera(double deltaTime);
-    void setEnableKeyFrameInteraction();
-    void setDisableKeyFrameInteraction();
-    void triggerPlaybackStart();
-    void stopPlayback();
+
+    void resetNavigationUpdateVariables();
 
     // Accessors
     Camera* camera() const;
     const SceneGraphNode* anchorNode() const;
-    const InputState& inputState() const;
+    const MouseInputState& mouseInputState() const;
+    const KeyboardInputState& keyboardInputState() const;
     const OrbitalNavigator& orbitalNavigator() const;
     OrbitalNavigator& orbitalNavigator();
     KeyframeNavigator& keyframeNavigator();
@@ -96,24 +94,36 @@ public:
     void mousePositionCallback(double x, double y);
     void mouseScrollWheelCallback(double pos);
 
-    void setJoystickAxisMapping(int axis, JoystickCameraStates::AxisType mapping,
+    void setJoystickAxisMapping(std::string joystickName,
+        int axis, JoystickCameraStates::AxisType mapping,
         JoystickCameraStates::AxisInvert shouldInvert =
             JoystickCameraStates::AxisInvert::No,
-        JoystickCameraStates::AxisNormalize shouldNormalize =
-            JoystickCameraStates::AxisNormalize::No,
+        JoystickCameraStates::JoystickType joystickType =
+            JoystickCameraStates::JoystickType::JoystickLike,
         bool isSticky = false, double sensitivity = 0.0
     );
 
-    JoystickCameraStates::AxisInformation joystickAxisMapping(int axis) const;
+    void setJoystickAxisMappingProperty(std::string joystickName,
+        int axis, std::string propertyUri,
+        float min = 0.f, float max = 1.f,
+        JoystickCameraStates::AxisInvert shouldInvert =
+        JoystickCameraStates::AxisInvert::No, bool isRemote = true
+    );
 
-    void setJoystickAxisDeadzone(int axis, float deadzone);
-    float joystickAxisDeadzone(int axis) const;
+    JoystickCameraStates::AxisInformation joystickAxisMapping(
+        const std::string& joystickName, int axis) const;
 
-    void bindJoystickButtonCommand(int button, std::string command, JoystickAction action,
+    void setJoystickAxisDeadzone(const std::string& joystickName, int axis,
+        float deadzone);
+    float joystickAxisDeadzone(const std::string& joystickName, int axis) const;
+
+    void bindJoystickButtonCommand(const std::string& joystickName, int button,
+        std::string command, JoystickAction action,
         JoystickCameraStates::ButtonCommandRemote remote, std::string documentation);
 
-    void clearJoystickButtonCommand(int button);
-    std::vector<std::string> joystickButtonCommand(int button) const;
+    void clearJoystickButtonCommand(const std::string& joystickName, int button);
+    std::vector<std::string> joystickButtonCommand(const std::string& joystickName,
+        int button) const;
 
     // Websockets
     void setWebsocketAxisMapping(int axis, WebsocketCameraStates::AxisType mapping,
@@ -141,10 +151,10 @@ public:
 private:
     void applyNavigationState(const NavigationState& ns);
     void updateCameraTransitions();
+    void clearGlobalJoystickStates();
 
-    bool _playbackModeEnabled = false;
-
-    InputState _inputState;
+    MouseInputState _mouseInputState;
+    KeyboardInputState _keyboardInputState;
     Camera* _camera = nullptr;
     std::function<void()> _playbackEndCallback;
 

include/openspace/navigation/navigationstate.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/orbitalnavigator.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -41,7 +41,6 @@
 #include <openspace/properties/triggerproperty.h>
 #include <ghoul/glm.h>
 #include <glm/gtx/quaternion.hpp>
-
 #include <optional>
 
 namespace openspace {
@@ -53,13 +52,15 @@ namespace openspace {
 
 namespace openspace::interaction {
 
-class InputState;
+class MouseInputState;
+class KeyboardInputState;
 
 class OrbitalNavigator : public properties::PropertyOwner {
 public:
     OrbitalNavigator();
 
-    void updateStatesFromInput(const InputState& inputState, double deltaTime);
+    void updateStatesFromInput(const MouseInputState& mouseInputState,
+        const KeyboardInputState& keyboardInputState, double deltaTime);
     void updateCameraStateFromStates(double deltaTime);
     void updateCameraScalingFromAnchor(double deltaTime);
     void resetVelocities();
@@ -85,7 +86,7 @@ public:
     void startRetargetAim();
     float retargetInterpolationTime() const;
     void setRetargetInterpolationTime(float durationInSeconds);
-    void resetNodeMovements();
+    void updatePreviousStateVariables();
 
     JoystickCameraStates& joystickStates();
     const JoystickCameraStates& joystickStates() const;
@@ -130,6 +131,9 @@ private:
         bool resetVelocitiesOnChange = true);
     void setAimNode(const SceneGraphNode* aimNode);
 
+    void updatePreviousAnchorState();
+    void updatePreviousAimState();
+
     Camera* _camera;
 
     Friction _friction;
@@ -147,6 +151,7 @@ private:
     // Reset camera direction to the aim node.
     properties::TriggerProperty _retargetAim;
 
+    properties::BoolProperty _followAnchorNodeRotation;
     properties::FloatProperty _followAnchorNodeRotationDistance;
     properties::FloatProperty _minimumAllowedDistance;
 

include/openspace/navigation/path.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/pathcurve.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/pathcurves/avoidcollisioncurve.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/pathcurves/zoomoutoverviewcurve.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/navigation/pathnavigator.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -81,6 +81,8 @@ public:
     static scripting::LuaLibrary luaLibrary();
 
 private:
+    void handlePathEnd();
+
     /**
     * Populate list of nodes that are relevant for collision checks, etc
     */
@@ -90,6 +92,7 @@ private:
 
     std::unique_ptr<Path> _currentPath = nullptr;
     bool _isPlaying = false;
+    bool _startSimulationTimeOnFinish = false;
 
     properties::OptionProperty _defaultPathType;
     properties::BoolProperty _includeRoll;

include/openspace/navigation/waypoint.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/network/messagestructures.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/network/messagestructureshelper.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -22,21 +22,36 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#ifndef __OPENSPACE_CORE___ASSETLISTENER___H__
-#define __OPENSPACE_CORE___ASSETLISTENER___H__
+#ifndef __OPENSPACE_CORE___MESSAGESTRUCTURESHELPER___H__
+#define __OPENSPACE_CORE___MESSAGESTRUCTURESHELPER___H__
 
-#include <openspace/scene/asset.h>
+#include <openspace/network/messagestructures.h>
 
-namespace openspace {
+namespace openspace::datamessagestructures {
 
-class AssetListener {
-public:
-    virtual ~AssetListener() = default;
-    virtual void assetStateChanged(Asset* asset, Asset::State state) = 0;
-    virtual void assetRequested(Asset* parent, std::shared_ptr<Asset> child) = 0;
-    virtual void assetUnrequested(Asset* parent, std::shared_ptr<Asset> child) = 0;
-};
+/**
+ * Method that creates a CameraKeyframe object and populates
+ * it with the current properties of the camera from the navigation handler.
+ * \returns CameraKeyframe with current state from NavigationHandler
+*/
+CameraKeyframe generateCameraKeyframe();
 
-} // namespace openspace
+/**
+ * Method that creates a TimeKeyframe object and populates
+ * it with the current time values from the application time manager.
+ * \returns TimeKeyframe The time keyframe
+ */
+TimeKeyframe generateTimeKeyframe();
 
-#endif // __OPENSPACE_CORE___ASSETLISTENER___H__
+/**
+ * Method that creates a ScriptMessage object from a given script
+ * string, and populates the ScriptMessage with the script and timestamp
+ * of the current application time.
+ * \param script The script to execute in std::string form
+ * \returns ScriptMessage The ScriptMessage data structure with script
+ */
+ScriptMessage generateScriptMessage(std::string script);
+
+} // namespace openspace::datamessagestructures
+
+#endif // __OPENSPACE_CORE___MESSAGESTRUCTURESHELPER___H__

include/openspace/network/parallelconnection.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/network/parallelpeer.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *
@@ -25,16 +25,13 @@
 #ifndef __OPENSPACE_CORE___PARALLELPEER___H__
 #define __OPENSPACE_CORE___PARALLELPEER___H__
 
-#include <openspace/network/parallelconnection.h>
-#include <openspace/interaction/externinteraction.h>
-#include <openspace/network/messagestructures.h>
-#include <openspace/util/timemanager.h>
-
 #include <openspace/properties/propertyowner.h>
 
+#include <openspace/network/messagestructures.h>
 #include <openspace/network/parallelconnection.h>
-#include <openspace/properties/stringproperty.h>
 #include <openspace/properties/scalar/floatproperty.h>
+#include <openspace/properties/stringproperty.h>
+#include <openspace/util/timemanager.h>
 #include <ghoul/designpattern/event.h>
 #include <atomic>
 #include <deque>
@@ -133,8 +130,6 @@ private:
     std::unique_ptr<std::thread> _receiveThread = nullptr;
     std::shared_ptr<ghoul::Event<>> _connectionEvent;
 
-    ExternInteraction _externInteract;
-
     ParallelConnection _connection;
 
     TimeManager::CallbackHandle _timeJumpCallback = -1;

include/openspace/network/parallelserver.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/list/doublelistproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/list/intlistproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/list/stringlistproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/listproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/listproperty.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/dmat2property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/dmat3property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/dmat4property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/mat2property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/mat3property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/matrix/mat4property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/numericalproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/numericalproperty.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/optionproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/propertyowner.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/boolproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/doubleproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/floatproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/intproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/longproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/shortproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/uintproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/ulongproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/scalar/ushortproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/selectionproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/stringproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/templateproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/templateproperty.inl

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/triggerproperty.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/dvec2property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/dvec3property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/dvec4property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/ivec2property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/ivec3property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/ivec4property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/uvec2property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *

include/openspace/properties/vector/uvec3property.h

@@ -2,7 +2,7 @@
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
- * Copyright (c) 2014-2021                                                               *
+ * Copyright (c) 2014-2022                                                               *
  *                                                                                       *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
  * software and associated documentation files (the "Software"), to deal in the Software *