vec2 conversion

libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp

@@ -31,8 +31,8 @@ void MaterialEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer&
     withWriteLock([&] {
         _drawMaterial = entity->getMaterial();
         _parentID = entity->getParentID();
-        _materialMappingPos = entity->getMaterialMappingPos();
-        _materialMappingScale = entity->getMaterialMappingScale();
+        _materialMappingPos = entity->getMaterialMappingPosGlm();
+        _materialMappingScale = entity->getMaterialMappingScaleGlm();
         _materialMappingRot = entity->getMaterialMappingRot();
         _renderTransform = getModelTransform();
         const float MATERIAL_ENTITY_SCALE = 0.5f;

libraries/entities/src/EntityItemProperties.cpp

@@ -1578,8 +1578,8 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(materialMappingMode, MaterialMappingMode);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(priority, quint16, setPriority);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(parentMaterialName, QString, setParentMaterialName);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingPos, vec2, setMaterialMappingPos);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingScale, vec2, setMaterialMappingScale);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingPos, ScriptVec2Float, setMaterialMappingPos);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingScale, ScriptVec2Float, setMaterialMappingScale);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingRot, float, setMaterialMappingRot);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(materialData, QString, setMaterialData);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(isVisibleInSecondaryCamera, bool, setIsVisibleInSecondaryCamera);
@@ -1957,8 +1957,8 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode);
         ADD_PROPERTY_TO_MAP(PROP_MATERIAL_PRIORITY, Priority, priority, quint16);
         ADD_PROPERTY_TO_MAP(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString);
-        ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, vec2);
-        ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, vec2);
+        ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, ScriptVec2Float);
+        ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, ScriptVec2Float);
         ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float);
         ADD_PROPERTY_TO_MAP(PROP_MATERIAL_DATA, MaterialData, materialData, QString);
 
@@ -2734,8 +2734,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_PRIORITY, quint16, setPriority);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_POS, vec2, setMaterialMappingPos);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_SCALE, vec2, setMaterialMappingScale);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_POS, ScriptVec2Float, setMaterialMappingPos);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_SCALE, ScriptVec2Float, setMaterialMappingScale);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_DATA, QString, setMaterialData);
     }

libraries/entities/src/EntityItemProperties.h

@@ -228,8 +228,8 @@ public:
     DEFINE_PROPERTY_REF_ENUM(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode, UV);
     DEFINE_PROPERTY_REF(PROP_MATERIAL_PRIORITY, Priority, priority, quint16, 0);
     DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString, "0");
-    DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, vec2, glm::vec2(0, 0));
-    DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, vec2, glm::vec2(1, 1));
+    DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, ScriptVec2Float, ScriptVec2Float(0.0f));
+    DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, ScriptVec2Float, ScriptVec2Float(1.0f));
     DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float, 0);
     DEFINE_PROPERTY_REF(PROP_MATERIAL_DATA, MaterialData, materialData, QString, "");
 

libraries/entities/src/EntityItemPropertiesMacros.h

@@ -101,7 +101,7 @@
         changedProperties += P;    \
     }
 
-inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec2& v) { return vec2toScriptValue(e, v); }
+inline QScriptValue convertScriptValue(QScriptEngine* e, const ScriptVec2Float& v) { return vec2toScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec3& v) { return vec3toScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, float v) { return QScriptValue(v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, int v) { return QScriptValue(v); }
@@ -221,21 +221,11 @@ inline QByteArray QByteArray_convertFromScriptValue(const QScriptValue& v, bool&
     return QByteArray::fromBase64(b64.toUtf8());
 }
 
-inline glm::vec2 vec2_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
-    isValid = false; /// assume it can't be converted
-    QScriptValue x = v.property("x");
-    QScriptValue y = v.property("y");
-    if (x.isValid() && y.isValid()) {
-        glm::vec4 newValue(0);
-        newValue.x = x.toVariant().toFloat();
-        newValue.y = y.toVariant().toFloat();
-        isValid = !glm::isnan(newValue.x) &&
-            !glm::isnan(newValue.y);
-        if (isValid) {
-            return newValue;
-        }
-    }
-    return glm::vec2(0);
+inline ScriptVec2Float ScriptVec2Float_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
+    isValid = true;
+    ScriptVec2Float vec2;
+    vec2FromScriptValue(v, vec2);
+    return vec2;
 }
 
 inline glm::vec3 vec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {

libraries/entities/src/MaterialEntityItem.cpp

@@ -81,8 +81,8 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
     READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
     READ_ENTITY_PROPERTY(PROP_MATERIAL_PRIORITY, quint16, setPriority);
     READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
-    READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, glm::vec2, setMaterialMappingPos);
-    READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, glm::vec2, setMaterialMappingScale);
+    READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, ScriptVec2Float, setMaterialMappingPos);
+    READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, ScriptVec2Float, setMaterialMappingScale);
     READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
     READ_ENTITY_PROPERTY(PROP_MATERIAL_DATA, QString, setMaterialData);
 
@@ -208,18 +208,18 @@ void MaterialEntityItem::setMaterialData(const QString& materialData) {
     }
 }
 
-void MaterialEntityItem::setMaterialMappingPos(const glm::vec2& materialMappingPos) {
+void MaterialEntityItem::setMaterialMappingPos(const ScriptVec2Float& materialMappingPos) {
     if (_materialMappingPos != materialMappingPos) {
         removeMaterial();
-        _materialMappingPos = materialMappingPos;
+        _materialMappingPos = glm::vec2(materialMappingPos.x, materialMappingPos.y);
         applyMaterial();
     }
 }
 
-void MaterialEntityItem::setMaterialMappingScale(const glm::vec2& materialMappingScale) {
+void MaterialEntityItem::setMaterialMappingScale(const ScriptVec2Float& materialMappingScale) {
     if (_materialMappingScale != materialMappingScale) {
         removeMaterial();
-        _materialMappingScale = materialMappingScale;
+        _materialMappingScale = glm::vec2(materialMappingScale.x, materialMappingScale.y);
         applyMaterial();
     }
 }
@@ -290,9 +290,9 @@ void MaterialEntityItem::applyMaterial() {
         return;
     }
     Transform textureTransform;
-    textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0));
-    textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot)));
-    textureTransform.setScale(glm::vec3(_materialMappingScale, 1));
+    textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0.0f));
+    textureTransform.setRotation(glm::vec3(0.0f, 0.0f, glm::radians(_materialMappingRot)));
+    textureTransform.setScale(glm::vec3(_materialMappingScale, 1.0f));
     material->setTextureTransforms(textureTransform);
 
     graphics::MaterialLayer materialLayer = graphics::MaterialLayer(material, getPriority());

libraries/entities/src/MaterialEntityItem.h

@@ -66,10 +66,12 @@ public:
     QString getParentMaterialName() const { return _parentMaterialName; }
     void setParentMaterialName(const QString& parentMaterialName);
 
-    glm::vec2 getMaterialMappingPos() const { return _materialMappingPos; }
-    void setMaterialMappingPos(const glm::vec2& materialMappingPos);
-    glm::vec2 getMaterialMappingScale() const { return _materialMappingScale; }
-    void setMaterialMappingScale(const glm::vec2& materialMappingScale);
+    ScriptVec2Float getMaterialMappingPos() const { return _materialMappingPos; }
+    glm::vec2 getMaterialMappingPosGlm() const { return _materialMappingPos; }
+    void setMaterialMappingPos(const ScriptVec2Float& materialMappingPos);
+    ScriptVec2Float getMaterialMappingScale() const { return _materialMappingScale; }
+    glm::vec2 getMaterialMappingScaleGlm() const { return _materialMappingScale; }
+    void setMaterialMappingScale(const ScriptVec2Float& materialMappingScale);
     float getMaterialMappingRot() const { return _materialMappingRot; }
     void setMaterialMappingRot(const float& materialMappingRot);
 

libraries/networking/src/udt/PacketHeaders.cpp

@@ -33,7 +33,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::EntityEdit:
         case PacketType::EntityData:
         case PacketType::EntityPhysics:
-            return static_cast<PacketVersion>(EntityVersion::ParticleEntityFix);
+            return static_cast<PacketVersion>(EntityVersion::ScriptGlmVectors);
         case PacketType::EntityQuery:
             return static_cast<PacketVersion>(EntityQueryPacketVersion::ConicalFrustums);
         case PacketType::AvatarIdentity:

libraries/networking/src/udt/PacketHeaders.h

@@ -238,7 +238,8 @@ enum class EntityVersion : PacketVersion {
     CloneableData,
     CollisionMask16Bytes,
     YieldSimulationOwnership,
-    ParticleEntityFix
+    ParticleEntityFix,
+    ScriptGlmVectors
 };
 
 enum class EntityScriptCallMethodVersion : PacketVersion {

libraries/octree/src/OctreePacketData.cpp

@@ -382,7 +382,7 @@ bool OctreePacketData::appendValue(float value) {
     return success;
 }
 
-bool OctreePacketData::appendValue(const glm::vec2& value) {
+bool OctreePacketData::appendValue(const ScriptVec2Float& value) {
     const unsigned char* data = (const unsigned char*)&value;
     int length = sizeof(value);
     bool success = append(data, length);

libraries/octree/src/OctreePacketData.h

@@ -165,7 +165,7 @@ public:
     bool appendValue(float value);
 
     /// appends a vec2 to the end of the stream, may fail if new data stream is too long to fit in packet
-    bool appendValue(const glm::vec2& value);
+    bool appendValue(const ScriptVec2Float& value);
 
     /// appends a non-position vector to the end of the stream, may fail if new data stream is too long to fit in packet
     bool appendValue(const glm::vec3& value);
@@ -253,7 +253,7 @@ public:
     static quint64 getTotalBytesOfColor() { return _totalBytesOfColor; } /// total bytes of color
     
     static int unpackDataFromBytes(const unsigned char* dataBytes, float& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
-    static int unpackDataFromBytes(const unsigned char* dataBytes, glm::vec2& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
+    static int unpackDataFromBytes(const unsigned char* dataBytes, ScriptVec2Float& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int unpackDataFromBytes(const unsigned char* dataBytes, glm::vec3& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int unpackDataFromBytes(const unsigned char* dataBytes, bool& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int unpackDataFromBytes(const unsigned char* dataBytes, quint64& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }

libraries/script-engine/src/ScriptEngine.cpp

@@ -666,9 +666,9 @@ void ScriptEngine::init() {
     qScriptRegisterSequenceMetaType<QVector<QUuid>>(this);
     qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this);
 
-    qScriptRegisterSequenceMetaType<QVector<glm::vec2> >(this);
-    qScriptRegisterSequenceMetaType<QVector<glm::quat> >(this);
-    qScriptRegisterSequenceMetaType<QVector<QString> >(this);
+    qScriptRegisterSequenceMetaType<QVector<ScriptVec2Float>>(this);
+    qScriptRegisterSequenceMetaType<QVector<glm::quat>>(this);
+    qScriptRegisterSequenceMetaType<QVector<QString>>(this);
 
     QScriptValue xmlHttpRequestConstructorValue = newFunction(XMLHttpRequestClass::constructor);
     globalObject().setProperty("XMLHttpRequest", xmlHttpRequestConstructorValue);

libraries/script-engine/src/TouchEvent.cpp

@@ -14,7 +14,6 @@
 #include <qscriptengine.h>
 #include <qscriptvalue.h>
 
-#include <RegisteredMetaTypes.h>
 #include <NumericalConstants.h>
 
 TouchEvent::TouchEvent() :
@@ -80,7 +79,7 @@ void TouchEvent::initWithQTouchEvent(const QTouchEvent& event) {
             touchAvgY += (float)tPoints[i].pos().y();
 
             // add it to our points vector
-            glm::vec2 thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());
+            ScriptVec2Float thisPoint(tPoints[i].pos().x(), tPoints[i].pos().y());
             points << thisPoint;
         }
         touchAvgX /= (float)(touchPoints);
@@ -219,7 +218,7 @@ QScriptValue TouchEvent::toScriptValue(QScriptEngine* engine, const TouchEvent&
 
     QScriptValue pointsObj = engine->newArray();
     int index = 0;
-    foreach (glm::vec2 point, event.points) {
+    foreach (ScriptVec2Float point, event.points) {
         QScriptValue thisPoint = vec2toScriptValue(engine, point);
         pointsObj.setProperty(index, thisPoint);
         index++;

libraries/script-engine/src/TouchEvent.h

@@ -17,6 +17,8 @@
 #include <QVector>
 #include <QTouchEvent>
 
+#include <RegisteredMetaTypes.h>
+
 class QScriptValue;
 class QScriptEngine;
 
@@ -40,7 +42,7 @@ public:
     bool isMeta;
     bool isAlt;
     int touchPoints;
-    QVector<glm::vec2> points;
+    QVector<ScriptVec2Float> points;
     float radius;
     bool isPinching;
     bool isPinchOpening;

libraries/script-engine/src/Vec3.h

@@ -21,24 +21,6 @@
 
 #include "GLMHelpers.h"
 
-/**jsdoc
- * A 3-dimensional vector. See also the {@link Vec3(0)|Vec3} object.
- *
- * @typedef {object} Vec3
- * @property {number} x - X-coordinate of the vector.
- * @property {number} y - Y-coordinate of the vector.
- * @property {number} z - Z-coordinate of the vector.
- */
-
-/**jsdoc
- * A color vector. See also the {@link Vec3(0)|Vec3} object.
- *
- * @typedef {object} Vec3Color
- * @property {number} x - Red component value. Integer in the range <code>0</code> - <code>255</code>.
- * @property {number} y - Green component value. Integer in the range <code>0</code> - <code>255</code>.
- * @property {number} z - Blue component value. Integer in the range <code>0</code> - <code>255</code>.
- */
-
 /**jsdoc
  * The Vec3 API facilities for generating and manipulating 3-dimensional vectors. High Fidelity uses a right-handed 
  * Cartesian coordinate system where the y-axis is the "up" and the negative z-axis is the "front" direction.

libraries/shared/src/PointerEvent.cpp

@@ -229,8 +229,7 @@ void PointerEvent::fromScriptValue(const QScriptValue& object, PointerEvent& eve
         QScriptValue id = object.property("id");
         event._id = id.isNumber() ? (uint32_t)id.toNumber() : 0;
 
-        glm::vec2 pos2D;
-        vec2FromScriptValue(object.property("pos2D"), event._pos2D);
+        glm::vec2 pos2D = vec2FromVariant(object.property("pos2D").toVariant());
 
         glm::vec3 pos3D;
         vec3FromScriptValue(object.property("pos3D"), event._pos3D);

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -30,7 +30,8 @@ int vec3MetaTypeId = qRegisterMetaType<glm::vec3>();
 int qVectorVec3MetaTypeId = qRegisterMetaType<QVector<glm::vec3>>();
 int qVectorQuatMetaTypeId = qRegisterMetaType<QVector<glm::quat>>();
 int qVectorBoolMetaTypeId = qRegisterMetaType<QVector<bool>>();
-int vec2MetaTypeId = qRegisterMetaType<glm::vec2>();
+int glmVec2MetaTypeId = qRegisterMetaType<glm::vec2>();
+int vec2FloatMetaTypeId = qRegisterMetaType<ScriptVec2Float>();
 int quatMetaTypeId = qRegisterMetaType<glm::quat>();
 int xColorMetaTypeId = qRegisterMetaType<xColor>();
 int pickRayMetaTypeId = qRegisterMetaType<PickRay>();
@@ -49,6 +50,7 @@ void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, qVectorBoolToScriptValue, qVectorBoolFromScriptValue);
     qScriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue);
     qScriptRegisterMetaType(engine, qVectorIntToScriptValue, qVectorIntFromScriptValue);
+    qScriptRegisterMetaType(engine, glmVec2toScriptValue, glmVec2FromScriptValue);
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
@@ -495,14 +497,49 @@ void qVectorBoolFromScriptValue(const QScriptValue& array, QVector<bool>& vector
     }
 }
 
-QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2) {
+QScriptValue vec2toScriptValue(QScriptEngine* engine, const ScriptVec2Float& vec2) {
+    return engine->newQObject(new ScriptVec2Float(vec2), QScriptEngine::ScriptOwnership);
+}
+
+void vec2FromScriptValue(const QScriptValue& object, ScriptVec2Float& vec2) {
+    if (object.isQObject()) {
+        auto qObject = object.toQObject();
+        if (qObject) {
+            vec2 = *qobject_cast<ScriptVec2Float*>(qObject);
+            return;
+        }
+    } else {
+        QScriptValue x = object.property("x");
+        if (!x.isValid()) {
+            x = object.property("u");
+        }
+        if (!x.isValid()) {
+            x = object.property("width");
+        }
+
+        QScriptValue y = object.property("y");
+        if (!y.isValid()) {
+            y = object.property("v");
+        }
+        if (!y.isValid()) {
+            y = object.property("height");
+        }
+
+        vec2.x = x.toVariant().toFloat();
+        vec2.y = y.toVariant().toFloat();
+        return;
+    }
+    vec2 = ScriptVec2Float();
+}
+
+QScriptValue glmVec2toScriptValue(QScriptEngine* engine, const glm::vec2& vec2) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("x", vec2.x);
     obj.setProperty("y", vec2.y);
     return obj;
 }
 
-void vec2FromScriptValue(const QScriptValue &object, glm::vec2 &vec2) {
+void glmVec2FromScriptValue(const QScriptValue& object, glm::vec2& vec2) {
     vec2.x = object.property("x").toVariant().toFloat();
     vec2.y = object.property("y").toVariant().toFloat();
 }

libraries/shared/src/RegisteredMetaTypes.h

@@ -23,12 +23,15 @@
 #include "SharedUtil.h"
 #include "shared/Bilateral.h"
 
+#include <QJsonDocument>
+#include <QJsonObject>
+#include "shared/JSONHelpers.h"
+
 class QColor;
 class QUrl;
 
 Q_DECLARE_METATYPE(glm::vec4)
 Q_DECLARE_METATYPE(glm::vec3)
-Q_DECLARE_METATYPE(glm::vec2)
 Q_DECLARE_METATYPE(glm::quat)
 Q_DECLARE_METATYPE(glm::mat4)
 Q_DECLARE_METATYPE(xColor)
@@ -44,6 +47,82 @@ void registerMetaTypes(QScriptEngine* engine);
 QScriptValue mat4toScriptValue(QScriptEngine* engine, const glm::mat4& mat4);
 void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4);
 
+/**jsdoc
+* A 2-dimensional vector.
+*
+* @typedef {object} Vec2
+* @property {number} x - X-coordinate of the vector.
+* @property {number} y - Y-coordinate of the vector.
+*/
+class ScriptVec2Float : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(float x MEMBER x)
+    Q_PROPERTY(float y MEMBER y)
+    Q_PROPERTY(float u MEMBER x)
+    Q_PROPERTY(float v MEMBER y)
+    Q_PROPERTY(float width MEMBER x)
+    Q_PROPERTY(float height MEMBER y)
+public:
+    ScriptVec2Float() {}
+    ScriptVec2Float(float xy) : x(xy), y(xy) {}
+    ScriptVec2Float(float x, float y) : x(x), y(y) {}
+    ScriptVec2Float(const ScriptVec2Float& other) : x(other.x), y(other.y) {}
+    ScriptVec2Float(const glm::vec2& other) : x(other.x), y(other.y) {}
+    void operator=(const ScriptVec2Float& other) { x = other.x; y = other.y; }
+    inline bool operator==(const ScriptVec2Float& other) { return (x == other.x && y == other.y); }
+    inline bool operator!=(const ScriptVec2Float& other) { return !(*this == other); }
+    inline bool operator==(const glm::vec2& other) { return (x == other.x && y == other.y); }
+    inline bool operator!=(const glm::vec2& other) { return !(*this == other); }
+
+    Q_INVOKABLE QVariantMap toJSON() { return toJsonValue(*this, { "x", "y" }).toObject().toVariantMap(); }
+
+    float x { 0.0f };
+    float y { 0.0f };
+private:
+    friend QDebug operator<<(QDebug debug, const ScriptVec2Float& vec2);
+    friend bool operator==(glm::vec2 glmVec2, const ScriptVec2Float& vec2);
+    friend bool operator!=(glm::vec2 glmVec2, const ScriptVec2Float& vec2);
+};
+inline QDebug operator<<(QDebug debug, const ScriptVec2Float& vec2) {
+    debug << "(" << vec2.x << "," << vec2.y << ")";
+    return debug;
+}
+inline bool operator==(glm::vec2 glmVec2, const ScriptVec2Float& vec2) { return (glmVec2.x == vec2.x && glmVec2.y == vec2.y); }
+inline bool operator!=(glm::vec2 glmVec2, const ScriptVec2Float& vec2) { return !(glmVec2 == vec2); }
+Q_DECLARE_METATYPE(ScriptVec2Float)
+QScriptValue vec2toScriptValue(QScriptEngine* engine, const ScriptVec2Float& vec2);
+void vec2FromScriptValue(const QScriptValue& object, ScriptVec2Float& vec2);
+
+QVariant vec2toVariant(const glm::vec2& vec2);
+glm::vec2 vec2FromVariant(const QVariant& object, bool& valid);
+glm::vec2 vec2FromVariant(const QVariant& object);
+
+Q_DECLARE_METATYPE(glm::vec2)
+QScriptValue glmVec2toScriptValue(QScriptEngine* engine, const glm::vec2& vec2);
+void glmVec2FromScriptValue(const QScriptValue& object, glm::vec2& vec2);
+
+/**jsdoc
+* A 3-dimensional vector. See also the {@link Vec3(0)|Vec3} object.
+*
+* @typedef {object} Vec3
+* @property {number} x - X-coordinate of the vector.
+* @property {number} y - Y-coordinate of the vector.
+* @property {number} z - Z-coordinate of the vector.
+*/
+/**jsdoc
+* A color vector. See also the {@link Vec3(0)|Vec3} object.
+*
+* @typedef {object} Vec3Color
+* @property {number} x - Red component value. Integer in the range <code>0</code> - <code>255</code>.
+* @property {number} y - Green component value. Integer in the range <code>0</code> - <code>255</code>.
+* @property {number} z - Blue component value. Integer in the range <code>0</code> - <code>255</code>.
+*/
+QScriptValue vec3toScriptValue(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 4-dimensional vector.
  *
@@ -53,36 +132,12 @@ void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4);
  * @property {number} z - Z-coordinate of the vector.
  * @property {number} w - W-coordinate of the vector.
  */
-// Vec4
 QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4);
 void vec4FromScriptValue(const QScriptValue& object, glm::vec4& vec4);
 QVariant vec4toVariant(const glm::vec4& vec4);
 glm::vec4 vec4FromVariant(const QVariant &object, bool& valid);
 glm::vec4 vec4FromVariant(const QVariant &object);
 
-// Vec3
-QScriptValue vec3toScriptValue(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 2-dimensional vector.
- *
- * @typedef {object} Vec2
- * @property {number} x - X-coordinate of the vector.
- * @property {number} y - Y-coordinate of the vector.
- */
-// Vec2
-QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2);
-void vec2FromScriptValue(const QScriptValue &object, glm::vec2 &vec2);
-
-QVariant vec2toVariant(const glm::vec2 &vec2);
-glm::vec2 vec2FromVariant(const QVariant &object, bool& valid);
-glm::vec2 vec2FromVariant(const QVariant &object);
-
 // Quaternions
 QScriptValue quatToScriptValue(QScriptEngine* engine, const glm::quat& quat);
 void quatFromScriptValue(const QScriptValue &object, glm::quat& quat);

libraries/shared/src/shared/JSONHelpers.cpp

@@ -106,6 +106,36 @@ QJsonValue toJsonValue(const QObject& o) {
     return json;
 }
 
+QJsonValue toJsonValue(const QObject& o, const std::vector<QString>& props) {
+    QJsonObject json {};
+
+    const auto& meta = o.metaObject();
+    // Only add the properties in props
+    for (auto& prop : props) {
+        int i = meta->indexOfProperty(prop.toStdString().c_str());
+        QString name = QString::fromLatin1(meta->property(i).name());
+        auto type = meta->property(i).userType();
+        QVariant variant { meta->property(i).read(&o) };
+        QJsonValue value;
+
+        // User-registered types need explicit conversion
+        if (type == qMetaTypeId<quat>()) {
+            value = toJsonValue(variant.value<quat>());
+        } else if (type == qMetaTypeId<vec3>()) {
+            value = toJsonValue(variant.value<vec3>());
+        } else if (type == qMetaTypeId<vec4>()) {
+            value = toJsonValue(variant.value<vec4>());
+        } else {
+            // Qt types are converted automatically
+            value = QJsonValue::fromVariant(variant);
+        }
+
+        json.insert(name, value);
+    }
+
+    return json;
+}
+
 void qObjectFromJsonValue(const QJsonValue& j, QObject& o) {
     const QJsonObject object = j.toObject();
     for (auto it = object.begin(); it != object.end(); it++) {

libraries/shared/src/shared/JSONHelpers.h

@@ -16,6 +16,7 @@ QJsonValue toJsonValue(const quat& q);
 QJsonValue toJsonValue(const vec3& v);
 QJsonValue toJsonValue(const vec4& v);
 QJsonValue toJsonValue(const QObject& o);
+QJsonValue toJsonValue(const QObject& o, const std::vector<QString>& props);
 
 quat quatFromJsonValue(const QJsonValue& q);
 vec3 vec3FromJsonValue(const QJsonValue& v);