Add model scale that can be set in asset file for each model

* Add cm and dm as units in DistanceUnits

* Scale the model according to the set unit

modules/base/dashboard/dashboarditemdistance.cpp

@@ -368,7 +368,7 @@ void DashboardItemDistance::render(glm::vec2& penPosition) {
     }
     else {
         const DistanceUnit unit = static_cast<DistanceUnit>(_requestedUnit.value());
-        const double convertedD = convertDistance(d, unit);
+        const double convertedD = convertMeters(d, unit);
         dist = { convertedD, nameForDistanceUnit(unit, convertedD != 1.0) };
     }
 
@@ -399,7 +399,7 @@ glm::vec2 DashboardItemDistance::size() const {
     }
     else {
         DistanceUnit unit = static_cast<DistanceUnit>(_requestedUnit.value());
-        double convertedD = convertDistance(d, unit);
+        double convertedD = convertMeters(d, unit);
         dist = { convertedD, nameForDistanceUnit(unit, convertedD != 1.0) };
     }
 

modules/base/dashboard/dashboarditemvelocity.cpp

@@ -133,7 +133,7 @@ void DashboardItemVelocity::render(glm::vec2& penPosition) {
     }
     else {
         const DistanceUnit unit = static_cast<DistanceUnit>(_requestedUnit.value());
-        const double convertedD = convertDistance(speedPerSecond, unit);
+        const double convertedD = convertMeters(speedPerSecond, unit);
         dist = { convertedD, nameForDistanceUnit(unit, convertedD != 1.0) };
     }
 
@@ -159,7 +159,7 @@ glm::vec2 DashboardItemVelocity::size() const {
     }
     else {
         DistanceUnit unit = static_cast<DistanceUnit>(_requestedUnit.value());
-        double convertedD = convertDistance(d, unit);
+        double convertedD = convertMeters(d, unit);
         dist = { convertedD, nameForDistanceUnit(unit, convertedD != 1.0) };
     }
 

modules/base/rendering/renderablemodel.cpp

@@ -148,6 +148,20 @@ namespace {
         // This specifies the model that is rendered by the Renderable.
         std::variant<std::string, std::vector<std::string>> geometryFile;
 
+        enum class ScaleUnit {
+            Nanometer [[codegen::key("nm")]],
+            Micrometer [[codegen::key("um")]],
+            Millimeter [[codegen::key("mm")]],
+            Centimeter [[codegen::key("cm")]],
+            Decimeter [[codegen::key("dm")]],
+            Meter [[codegen::key("m")]],
+            Kilometer [[codegen::key("km")]]
+        };
+
+        // The scale of the model. For example if the model is in centimeters
+        // then ModelScale=cm
+        std::optional<ScaleUnit> modelScale;
+
         // Set if invisible parts (parts with no textures or materials) of the model
         // should be forced to render or not.
         std::optional<bool> forceRenderInvisible;
@@ -320,6 +334,38 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
         }*/
     }
 
+    if (p.modelScale.has_value()) {
+        Parameters::ScaleUnit scaleUnit = *p.modelScale;
+
+        switch (scaleUnit) {
+            case Parameters::ScaleUnit::Nanometer:
+                _modelScale = DistanceUnit::Nanometer;
+                break;
+            case Parameters::ScaleUnit::Micrometer:
+                _modelScale = DistanceUnit::Micrometer;
+                break;
+            case Parameters::ScaleUnit::Millimeter:
+                _modelScale = DistanceUnit::Millimeter;
+                break;
+            case Parameters::ScaleUnit::Centimeter:
+                _modelScale = DistanceUnit::Centimeter;
+                break;
+            case Parameters::ScaleUnit::Decimeter:
+                _modelScale = DistanceUnit::Decimeter;
+                break;
+            case Parameters::ScaleUnit::Meter:
+                _modelScale = DistanceUnit::Meter;
+                break;
+            case Parameters::ScaleUnit::Kilometer:
+                _modelScale = DistanceUnit::Kilometer;
+                break;
+            default:
+                throw ghoul::MissingCaseException();
+        }
+
+        _scaleVector = glm::dvec3(convertUnit(_modelScale, DistanceUnit::Meter));
+    }
+
     if (p.animationStartTime.has_value()) {
         if (!_geometry->hasAnimation()) {
             LWARNING("Animation start time given to model without animation");
@@ -546,9 +592,8 @@ void RenderableModel::render(const RenderData& data, RendererTasks&) {
     const glm::dmat4 modelTransform =
         glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
         glm::dmat4(data.modelTransform.rotation) *  // Spice rotation
-        glm::scale(
-            glm::dmat4(_modelTransform.value()), glm::dvec3(data.modelTransform.scale)
-        );
+        glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
+        glm::scale(glm::dmat4(_modelTransform.value()), _scaleVector); // Model scale unit
     const glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() *
                                           modelTransform;
 

modules/base/rendering/renderablemodel.h

@@ -33,6 +33,7 @@
 #include <openspace/properties/scalar/boolproperty.h>
 #include <openspace/properties/scalar/floatproperty.h>
 #include <openspace/properties/vector/vec3property.h>
+#include <openspace/util/distanceconversion.h>
 #include <ghoul/misc/managedmemoryuniqueptr.h>
 #include <ghoul/io/model/modelreader.h>
 #include <ghoul/opengl/uniformcache.h>
@@ -79,6 +80,8 @@ private:
     };
 
     std::unique_ptr<ghoul::modelgeometry::ModelGeometry> _geometry;
+    DistanceUnit _modelScale;
+    glm::dvec3 _scaleVector = glm::dvec3(1.0, 1.0, 1.0);
     bool _forceRenderInvisible = false;
     bool _notifyInvisibleDropped = true;
     std::string _animationStart = "";