variant conversions

interface/src/raypick/ParabolaPointer.cpp

@@ -52,8 +52,7 @@ void ParabolaPointer::editRenderStatePath(const std::string& state, const QVaria
         if (!pathMap.isEmpty()) {
             enabled = true;
             if (pathMap["color"].isValid()) {
-                bool valid;
+                color = toGlm(u8vec3FromVariant(pathMap["color"]));
-                color = toGlm(vec3FromVariant(pathMap["color"], valid));
             }
             if (pathMap["alpha"].isValid()) {
                 alpha = pathMap["alpha"].toFloat();
@@ -250,8 +249,7 @@ std::shared_ptr<StartEndRenderState> ParabolaPointer::buildRenderState(const QVa
         enabled = true;
         QVariantMap pathMap = propMap["path"].toMap();
         if (pathMap["color"].isValid()) {
-            bool valid;
+            color = toGlm(u8vec3FromVariant(pathMap["color"]));
-            color = toGlm(vec3FromVariant(pathMap["color"], valid));
         }
 
         if (pathMap["alpha"].isValid()) {

interface/src/scripting/SelectionScriptingInterface.cpp

@@ -421,7 +421,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
     auto colorVariant = properties["outlineUnoccludedColor"];
     if (colorVariant.isValid()) {
         bool isValid;
-        auto color = vec3FromVariant(colorVariant, isValid);
+        auto color = u8vec3FromVariant(colorVariant, isValid);
         if (isValid) {
             _style._outlineUnoccluded.color = toGlm(color);
         }
@@ -429,7 +429,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
     colorVariant = properties["outlineOccludedColor"];
     if (colorVariant.isValid()) {
         bool isValid;
-        auto color = vec3FromVariant(colorVariant, isValid);
+        auto color = u8vec3FromVariant(colorVariant, isValid);
         if (isValid) {
             _style._outlineOccluded.color = toGlm(color);
         }
@@ -437,7 +437,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
     colorVariant = properties["fillUnoccludedColor"];
     if (colorVariant.isValid()) {
         bool isValid;
-        auto color = vec3FromVariant(colorVariant, isValid);
+        auto color = u8vec3FromVariant(colorVariant, isValid);
         if (isValid) {
             _style._fillUnoccluded.color = toGlm(color);
         }
@@ -445,7 +445,7 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
     colorVariant = properties["fillOccludedColor"];
     if (colorVariant.isValid()) {
         bool isValid;
-        auto color = vec3FromVariant(colorVariant, isValid);
+        auto color = u8vec3FromVariant(colorVariant, isValid);
         if (isValid) {
             _style._fillOccluded.color = toGlm(color);
         }
@@ -498,10 +498,10 @@ QVariantMap SelectionHighlightStyle::toVariantMap() const {
     QVariantMap properties;
 
     const float MAX_COLOR = 255.0f;
-    properties["outlineUnoccludedColor"] = vec3toVariant(_style._outlineUnoccluded.color * MAX_COLOR);
+    properties["outlineUnoccludedColor"] = u8vec3ColortoVariant(_style._outlineUnoccluded.color * MAX_COLOR);
-    properties["outlineOccludedColor"] = vec3toVariant(_style._outlineOccluded.color * MAX_COLOR);
+    properties["outlineOccludedColor"] = u8vec3ColortoVariant(_style._outlineOccluded.color * MAX_COLOR);
-    properties["fillUnoccludedColor"] = vec3toVariant(_style._fillUnoccluded.color * MAX_COLOR);
+    properties["fillUnoccludedColor"] = u8vec3ColortoVariant(_style._fillUnoccluded.color * MAX_COLOR);
-    properties["fillOccludedColor"] = vec3toVariant(_style._fillOccluded.color * MAX_COLOR);
+    properties["fillOccludedColor"] = u8vec3ColortoVariant(_style._fillOccluded.color * MAX_COLOR);
 
     properties["outlineUnoccludedAlpha"] = _style._outlineUnoccluded.alpha;
     properties["outlineOccludedAlpha"] = _style._outlineOccluded.alpha;

interface/src/ui/overlays/Circle3DOverlay.cpp

@@ -275,7 +275,7 @@ template<typename T> T fromVariant(const QVariant& v, bool& valid) {
 }
 
 template<> glm::u8vec3 fromVariant(const QVariant& v, bool& valid) {
-    return vec3FromVariant(v, valid);
+    return u8vec3FromVariant(v, valid);
 }
 
 template<typename T>
@@ -472,16 +472,16 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
         return _innerRadius;
     }
     if (property == "innerStartColor") {
-        return vec3toVariant(_innerStartColor);
+        return u8vec3ColortoVariant(_innerStartColor);
     }
     if (property == "innerEndColor") {
-        return vec3toVariant(_innerEndColor);
+        return u8vec3ColortoVariant(_innerEndColor);
     }
     if (property == "outerStartColor") {
-        return vec3toVariant(_outerStartColor);
+        return u8vec3ColortoVariant(_outerStartColor);
     }
     if (property == "outerEndColor") {
-        return vec3toVariant(_outerEndColor);
+        return u8vec3ColortoVariant(_outerEndColor);
     }
     if (property == "innerStartAlpha") {
         return _innerStartAlpha;
@@ -511,10 +511,10 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
         return _minorTickMarksLength;
     }
     if (property == "majorTickMarksColor") {
-        return vec3toVariant(_majorTickMarksColor);
+        return u8vec3ColortoVariant(_majorTickMarksColor);
     }
     if (property == "minorTickMarksColor") {
-        return vec3toVariant(_minorTickMarksColor);
+        return u8vec3ColortoVariant(_minorTickMarksColor);
     }
 
     return Planar3DOverlay::getProperty(property);

interface/src/ui/overlays/Overlay.cpp

@@ -57,7 +57,7 @@ Overlay::~Overlay() {
 
 void Overlay::setProperties(const QVariantMap& properties) {
     bool valid;
-    auto color = vec3FromVariant(properties["color"], valid);
+    auto color = u8vec3FromVariant(properties["color"], valid);
     if (valid) {
         _color = color;
     }
@@ -116,7 +116,7 @@ QVariant Overlay::getProperty(const QString& property) {
         return QVariant(getType());
     }
     if (property == "color") {
-        return vec3toVariant(_color);
+        return u8vec3ColortoVariant(_color);
     }
     if (property == "alpha") {
         return _alpha;

interface/src/ui/overlays/Text3DOverlay.cpp

@@ -161,7 +161,7 @@ void Text3DOverlay::setProperties(const QVariantMap& properties) {
     bool valid;
     auto backgroundColor = properties["backgroundColor"];
     if (backgroundColor.isValid()) {
-        auto color = vec3FromVariant(backgroundColor, valid);
+        auto color = u8vec3FromVariant(backgroundColor, valid);
         if (valid) {
             _backgroundColor = color;
         }
@@ -257,7 +257,7 @@ QVariant Text3DOverlay::getProperty(const QString& property) {
         return _textAlpha;
     }
     if (property == "backgroundColor") {
-        return vec3toVariant(_backgroundColor);
+        return u8vec3ColortoVariant(_backgroundColor);
     }
     if (property == "backgroundAlpha") {
         return Billboard3DOverlay::getProperty("alpha");

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -442,6 +442,93 @@ glm::vec3 vec3FromVariant(const QVariant& object) {
     return vec3FromVariant(object, valid);
 }
 
+QVariant u8vec3toVariant(const glm::u8vec3& vec3) {
+    QVariantMap result;
+    result["x"] = vec3.x;
+    result["y"] = vec3.y;
+    result["z"] = vec3.z;
+    return result;
+}
+
+QVariant u8vec3ColortoVariant(const glm::u8vec3& vec3) {
+    QVariantMap result;
+    result["red"] = vec3.x;
+    result["green"] = vec3.y;
+    result["blue"] = vec3.z;
+    return result;
+}
+
+glm::u8vec3 u8vec3FromVariant(const QVariant& object, bool& valid) {
+    glm::u8vec3 v;
+    valid = false;
+    if (!object.isValid() || object.isNull()) {
+        return v;
+    } else if (object.canConvert<uint>()) {
+        v = glm::vec3(object.toUInt());
+        valid = true;
+    } else if (object.canConvert<QVector3D>()) {
+        auto qvec3 = qvariant_cast<QVector3D>(object);
+        v.x = (uint8_t)qvec3.x();
+        v.y = (uint8_t)qvec3.y();
+        v.z = (uint8_t)qvec3.z();
+        valid = true;
+    } else if (object.canConvert<QString>()) {
+        QColor qColor(object.toString());
+        if (qColor.isValid()) {
+            v.x = (uint8_t)qColor.red();
+            v.y = (uint8_t)qColor.green();
+            v.z = (uint8_t)qColor.blue();
+            valid = true;
+        }
+    } else if (object.canConvert<QColor>()) {
+        QColor qColor = qvariant_cast<QColor>(object);
+        if (qColor.isValid()) {
+            v.x = (uint8_t)qColor.red();
+            v.y = (uint8_t)qColor.green();
+            v.z = (uint8_t)qColor.blue();
+            valid = true;
+        }
+    } else {
+        auto map = object.toMap();
+        auto x = map["x"];
+        if (!x.isValid()) {
+            x = map["r"];
+        }
+        if (!x.isValid()) {
+            x = map["red"];
+        }
+
+        auto y = map["y"];
+        if (!y.isValid()) {
+            y = map["g"];
+        }
+        if (!y.isValid()) {
+            y = map["green"];
+        }
+
+        auto z = map["z"];
+        if (!z.isValid()) {
+            z = map["b"];
+        }
+        if (!z.isValid()) {
+            z = map["blue"];
+        }
+
+        if (x.canConvert<uint>() && y.canConvert<uint>() && z.canConvert<uint>()) {
+            v.x = x.toUInt();
+            v.y = y.toUInt();
+            v.z = z.toUInt();
+            valid = true;
+        }
+    }
+    return v;
+}
+
+glm::u8vec3 u8vec3FromVariant(const QVariant& object) {
+    bool valid = false;
+    return u8vec3FromVariant(object, valid);
+}
+
 QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("x", vec4.x);

libraries/shared/src/RegisteredMetaTypes.h

@@ -90,6 +90,10 @@ QScriptValue vec3ToScriptValue(QScriptEngine* engine, const glm::vec3& vec3);
 QScriptValue vec3ColorToScriptValue(QScriptEngine* engine, const glm::vec3& vec3);
 void vec3FromScriptValue(const QScriptValue& object, glm::vec3& vec3);
 
+QVariant vec3toVariant(const glm::vec3& vec3);
+glm::vec3 vec3FromVariant(const QVariant &object, bool& valid);
+glm::vec3 vec3FromVariant(const QVariant &object);
+
 /**jsdoc
 * A color vector. See also the {@link Vec3(0)|Vec3} object.
 *
@@ -132,9 +136,10 @@ QScriptValue u8vec3ToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3)
 QScriptValue u8vec3ColorToScriptValue(QScriptEngine* engine, const glm::u8vec3& vec3);
 void u8vec3FromScriptValue(const QScriptValue& object, glm::u8vec3& vec3);
 
-QVariant vec3toVariant(const glm::vec3& vec3);
+QVariant u8vec3toVariant(const glm::u8vec3& vec3);
-glm::vec3 vec3FromVariant(const QVariant &object, bool& valid);
+QVariant u8vec3ColortoVariant(const glm::u8vec3& vec3);
-glm::vec3 vec3FromVariant(const QVariant &object);
+glm::u8vec3 u8vec3FromVariant(const QVariant &object, bool& valid);
+glm::u8vec3 u8vec3FromVariant(const QVariant &object);
 
 /**jsdoc
  * A 4-dimensional vector.