added stroke width entity

libraries/entities-renderer/src/RenderableQuadEntityItem.cpp

@@ -72,7 +72,7 @@ int generateColor() {
 }
 
 void RenderableQuadEntityItem::updateGeometry() {
-
+    QReadLocker lock(&_quadReadWriteLock);
     int compactColor = generateColor();
     _numVertices = 0;
     _verticesBuffer.reset(new gpu::Buffer());

libraries/entities/src/EntityItemProperties.cpp

@@ -356,6 +356,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
     CHECK_PROPERTY_CHANGE(PROP_DESCRIPTION, description);
     CHECK_PROPERTY_CHANGE(PROP_FACE_CAMERA, faceCamera);
     CHECK_PROPERTY_CHANGE(PROP_NORMALS, normals);
+    CHECK_PROPERTY_CHANGE(PROP_STROKE_WIDTHS, strokeWidths);
 
     changedProperties += _stage.getChangedProperties();
     changedProperties += _atmosphere.getChangedProperties();
@@ -454,6 +455,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     COPY_PROPERTY_TO_QSCRIPTVALUE(description);
     COPY_PROPERTY_TO_QSCRIPTVALUE(faceCamera);
     COPY_PROPERTY_TO_QSCRIPTVALUE(normals);
+    COPY_PROPERTY_TO_QSCRIPTVALUE(strokeWidths);
 
     // Sitting properties support
     if (!skipDefaults) {
@@ -568,6 +570,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE(description, QString, setDescription);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(faceCamera, bool, setFaceCamera);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(normals, qVectorVec3, setNormals);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(strokeWidths,qVectorFloat, setStrokeWidths);
 
     if (!honorReadOnly) {
         // this is used by the json reader to set things that we don't want javascript to able to affect.

libraries/entities/src/EntityItemPropertiesMacros.h

@@ -99,6 +99,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const xColor& v) { retu
 inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::quat& v) { return quatToScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QScriptValue& v) { return v; }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<glm::vec3>& v) {return qVectorVec3ToScriptValue(e, v); }
+inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<float>& v) { return qVectorFloatToScriptValue(e, v); }
 
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QByteArray& v) {
     QByteArray b64 = v.toBase64();
@@ -134,6 +135,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const QByteArray& v) {
 typedef glm::vec3 glmVec3;
 typedef glm::quat glmQuat;
 typedef QVector<glm::vec3> qVectorVec3;
+typedef QVector<float> qVectorFloat;
 inline float float_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toFloat(&isValid); }
 inline quint64 quint64_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toULongLong(&isValid); }
 inline uint16_t uint16_t_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toInt(&isValid); }
@@ -177,6 +179,11 @@ inline glmVec3 glmVec3_convertFromScriptValue(const QScriptValue& v, bool& isVal
     return glm::vec3(0);
 }
 
+inline qVectorFloat qVectorFloat_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
+    isValid = true;
+    return qVectorFloatFromScriptValue(v);
+}
+
 inline qVectorVec3 qVectorVec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
     isValid = true;
     return qVectorVec3FromScriptValue(v);

libraries/entities/src/QuadEntityItem.cpp

@@ -36,7 +36,9 @@ EntityItem(entityItemID) ,
 _lineWidth(DEFAULT_LINE_WIDTH),
 _pointsChanged(true),
 _points(QVector<glm::vec3>(0)),
-_vertices(QVector<glm::vec3>(0))
+_vertices(QVector<glm::vec3>(0)),
+_normals(QVector<glm::vec3>(0)),
+_strokeWidths(QVector<float>(0))
 {
     _type = EntityTypes::Quad;
     _created = properties.getCreated();
@@ -55,6 +57,7 @@ EntityItemProperties QuadEntityItem::getProperties() const {
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineWidth, getLineWidth);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(linePoints, getLinePoints);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(normals, getNormals);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(strokeWidths, getStrokeWidths);
     
     
     properties._glowLevel = getGlowLevel();
@@ -72,6 +75,8 @@ bool QuadEntityItem::setProperties(const EntityItemProperties& properties) {
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(lineWidth, setLineWidth);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(linePoints, setLinePoints);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(normals, setNormals);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(strokeWidths, setStrokeWidths);
+
     
     
     if (somethingChanged) {
@@ -105,7 +110,12 @@ bool QuadEntityItem::appendPoint(const glm::vec3& point) {
     return true;
 }
 
-bool QuadEntityItem::setNormals(const QVector<glm::vec3> &normals) {
+bool QuadEntityItem::setStrokeWidths(const QVector<float>& strokeWidths ) {
+    _strokeWidths = strokeWidths;
+    return true;
+}
+
+bool QuadEntityItem::setNormals(const QVector<glm::vec3>& normals) {
     if (_points.size () < 2) {
         return false;
     }
@@ -184,6 +194,7 @@ int QuadEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     READ_ENTITY_PROPERTY(PROP_LINE_WIDTH, float, setLineWidth);
     READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
     READ_ENTITY_PROPERTY(PROP_NORMALS, QVector<glm::vec3>,  setNormals);
+    READ_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
     
     _quadReadWriteLock.unlock();
     return bytesRead;
@@ -214,6 +225,7 @@ void QuadEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
     APPEND_ENTITY_PROPERTY(PROP_LINE_WIDTH, getLineWidth());
     APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, getLinePoints());
     APPEND_ENTITY_PROPERTY(PROP_NORMALS, getNormals());
+    APPEND_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, getStrokeWidths());
 }
 
 void QuadEntityItem::debugDump() const {

libraries/entities/src/QuadEntityItem.h

@@ -61,6 +61,9 @@ class QuadEntityItem : public EntityItem {
     bool setNormals(const QVector<glm::vec3>& normals);
     const QVector<glm::vec3>& getNormals() const{ return _normals; }
     
+    bool setStrokeWidths(const QVector<float>& strokeWidths);
+    const QVector<float>& getStrokeWidths() const{ return _strokeWidths; }
+    
     
     virtual ShapeType getShapeType() const { return SHAPE_TYPE_LINE; }
 
@@ -81,6 +84,7 @@ class QuadEntityItem : public EntityItem {
     QVector<glm::vec3> _points;
     QVector<glm::vec3> _vertices;
     QVector<glm::vec3> _normals;
+    QVector<float> _strokeWidths;
     mutable QReadWriteLock _quadReadWriteLock;
 };
 

libraries/networking/src/PacketHeaders.h

@@ -187,5 +187,6 @@ const PacketVersion VERSION_ENTITIES_FACE_CAMERA = 30;
 const PacketVersion VERSION_ENTITIES_SCRIPT_TIMESTAMP = 31;
 const PacketVersion VERSION_ENTITIES_SCRIPT_TIMESTAMP_FIX = 32;
 const PacketVersion VERSION_ENTITIES_NORMALS = 33;
+const PacketVersion VERSION_ENTITIES_STROKE_WIDTHS = 34;
 
 #endif // hifi_PacketHeaders_h

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -33,6 +33,7 @@ void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue);
     qScriptRegisterMetaType(engine, vec3toScriptValue, vec3FromScriptValue);
     qScriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue);
+    qScriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue);
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
@@ -43,6 +44,7 @@ void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, collisionToScriptValue, collisionFromScriptValue);
     qScriptRegisterMetaType(engine, quuidToScriptValue, quuidFromScriptValue);
     qScriptRegisterMetaType(engine, qSizeFToScriptValue, qSizeFFromScriptValue);
+
 }
 
 QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4) {
@@ -79,7 +81,7 @@ void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
     vec3.z = object.property("z").toVariant().toFloat();
 }
 
-QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector){
+QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector) {
     QScriptValue array = engine->newArray();
     for (int i = 0; i < vector.size(); i++) {
         array.setProperty(i, vec3toScriptValue(engine, vector.at(i)));
@@ -87,6 +89,37 @@ QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::
     return array;
 }
 
+QVector<float> qVectorFloatFromScriptValue(const QScriptValue& array) {
+    QVector<float> newVector;
+    int length = array.property("length").toInteger();
+    for (int i = 0; i < length; i++) {
+        newVector << array.property(i).toVariant().toFloat();
+    }
+    
+    return newVector;
+}
+
+QScriptValue qVectorFloatToScriptValue(QScriptEngine* engine, const QVector<float>& vector) {
+    QScriptValue array = engine->newArray();
+    for (int i = 0; i < vector.size(); i++) {
+        float num = vector.at(i);
+        if(num != num) {
+            //if num is NaN don't convert it
+            return array;
+        }
+        array.setProperty(i, QScriptValue(num));
+    }
+    return array;
+}
+
+void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vector) {
+    int length = array.property("length").toInteger();
+    
+    for (int i = 0; i < length; i++) {
+        vector << array.property(i).toVariant().toFloat();
+    }
+}
+//
 QVector<glm::vec3> qVectorVec3FromScriptValue(const QScriptValue& array){
     QVector<glm::vec3> newVector;
     int length = array.property("length").toInteger();

libraries/shared/src/RegisteredMetaTypes.h

@@ -29,6 +29,7 @@ Q_DECLARE_METATYPE(glm::vec2)
 Q_DECLARE_METATYPE(glm::quat)
 Q_DECLARE_METATYPE(xColor)
 Q_DECLARE_METATYPE(QVector<glm::vec3>)
+Q_DECLARE_METATYPE(QVector<float>)
 
 void registerMetaTypes(QScriptEngine* engine);
 
@@ -60,6 +61,10 @@ QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::
 void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector);
 QVector<glm::vec3> qVectorVec3FromScriptValue( const QScriptValue& array);
 
+QScriptValue qVectorFloatToScriptValue(QScriptEngine* engine, const QVector<float>& vector);
+void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vector);
+QVector<float> qVectorFloatFromScriptValue(const QScriptValue& array);
+
 class PickRay {
 public:
     PickRay() : origin(0.0f), direction(0.0f)  { }