latest pointer

libraries/entities-renderer/src/RenderableLineEntityItem.cpp

@@ -38,10 +38,10 @@ void RenderableLineEntityItem::render(RenderArgs* args) {
         if(_lineVerticesID == GeometryCache::UNKNOWN_ID){
             _lineVerticesID = geometryCache ->allocateID();
         }
-        glTranslatef(position.x, position.y, position.z);
+//        glTranslatef(position.x, position.y, position.z);
         glm::vec3 axis = glm::axis(rotation);
         glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
-        geometryCache->updateVertices(_lineVerticesID, getPoints(), lineColor);
+        geometryCache->updateVertices(_lineVerticesID, getLinePoints(), lineColor);
     
       geometryCache->renderVertices(gpu::LINES, _lineVerticesID);
     glPopMatrix();

libraries/entities/src/EntityItemProperties.cpp

@@ -92,6 +92,7 @@ CONSTRUCT_PROPERTY(name, ENTITY_ITEM_DEFAULT_NAME),
 CONSTRUCT_PROPERTY(backgroundMode, BACKGROUND_MODE_INHERIT),
 CONSTRUCT_PROPERTY(sourceUrl, ""),
 CONSTRUCT_PROPERTY(lineWidth, LineEntityItem::DEFAULT_LINE_WIDTH),
+CONSTRUCT_PROPERTY(linePoints, 0),
 
 _id(UNKNOWN_ENTITY_ID),
 _idSet(false),
@@ -339,6 +340,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
     CHECK_PROPERTY_CHANGE(PROP_BACKGROUND_MODE, backgroundMode);
     CHECK_PROPERTY_CHANGE(PROP_SOURCE_URL, sourceUrl);
     CHECK_PROPERTY_CHANGE(PROP_LINE_WIDTH, lineWidth);
+    CHECK_PROPERTY_CHANGE(PROP_LINE_POINTS, linePoints);
     
     changedProperties += _stage.getChangedProperties();
     changedProperties += _atmosphere.getChangedProperties();
@@ -422,6 +424,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(backgroundMode, getBackgroundModeAsString());
     COPY_PROPERTY_TO_QSCRIPTVALUE(sourceUrl);
     COPY_PROPERTY_TO_QSCRIPTVALUE(lineWidth);
+    COPY_PROPERTY_TO_QSCRIPTVALUE(linePoints);
     
     // Sitting properties support
     if (!skipDefaults) {
@@ -528,6 +531,9 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object) {
     COPY_PROPERTY_FROM_QSCRITPTVALUE_ENUM(backgroundMode, BackgroundMode);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(sourceUrl, QString, setSourceUrl);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(lineWidth, float, setLineWidth);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(linePoints, qVector, setLinePoints);
+    
+
     
     _stage.copyFromScriptValue(object, _defaultSettings);
     _atmosphere.copyFromScriptValue(object, _defaultSettings);
@@ -748,6 +754,7 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem
             
             if(properties.getType() == EntityTypes::Line){
                 APPEND_ENTITY_PROPERTY(PROP_LINE_WIDTH, properties.getLineWidth());
+                APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, properties.getLinePoints());
             }
             
             APPEND_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, properties.getMarketplaceID());
@@ -986,6 +993,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     
     if(properties.getType() == EntityTypes::Line) {
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_WIDTH, float, setLineWidth);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
     }
     
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MARKETPLACE_ID, QString, setMarketplaceID);

libraries/entities/src/EntityItemProperties.h

@@ -142,6 +142,7 @@ public:
     DEFINE_PROPERTY_GROUP(Skybox, skybox, SkyboxPropertyGroup);
     DEFINE_PROPERTY_REF(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString);
     DEFINE_PROPERTY(LINE_WIDTH, LineWidth, lineWidth, float);
+    DEFINE_PROPERTY_REF(LINE_POINTS, LinePoints, linePoints, QVector<glm::vec3>);
 
     static QString getBackgroundModeString(BackgroundMode mode);
 

libraries/entities/src/EntityItemPropertiesMacros.h

@@ -94,6 +94,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const QString& v) { ret
 inline QScriptValue convertScriptValue(QScriptEngine* e, const xColor& v) { return xColorToScriptValue(e, v); }
 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 qVectorToScriptValue(e, v); }
 
 #define COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(G,g,P,p) \
     if (!skipDefaults || defaultEntityProperties.get##G().get##P() != get##P()) { \
@@ -123,6 +124,7 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const QScriptValue& v)
     
 typedef glm::vec3 glmVec3;
 typedef glm::quat glmQuat;
+typedef QVector<glm::vec3> qVector;
 inline float float_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toFloat(&isValid); }
 inline uint16_t uint16_t_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toInt(&isValid); }
 inline int int_convertFromScriptValue(const QScriptValue& v, bool& isValid) { return v.toVariant().toInt(&isValid); }
@@ -149,6 +151,11 @@ inline glmVec3 glmVec3_convertFromScriptValue(const QScriptValue& v, bool& isVal
     return glm::vec3(0);
 }
 
+inline qVector qVector_convertFromScriptValue(const QScriptValue& v, bool& isValid){
+    isValid = true;
+    return qVectorFromScriptValue(v);
+}
+
 inline glmQuat glmQuat_convertFromScriptValue(const QScriptValue& v, bool& isValid) { 
     isValid = false; /// assume it can't be converted
     QScriptValue x = v.property("x");

libraries/entities/src/EntityPropertyFlags.h

@@ -110,8 +110,9 @@ enum EntityPropertyList {
     PROP_RESTITUTION,
     PROP_FRICTION,
     
-    PROP_LINE_WIDTH, //for lines
+    //for lines
-
+    PROP_LINE_WIDTH,
+    PROP_LINE_POINTS,
     ////////////////////////////////////////////////////////////////////////////////////////////////////
     // ATTENTION: add new properties ABOVE this line
     PROP_AFTER_LAST_ITEM,

libraries/entities/src/LineEntityItem.cpp

@@ -23,6 +23,7 @@
 const float LineEntityItem::DEFAULT_LINE_WIDTH = 2.0f;
 
 
+
 EntityItem* LineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     EntityItem* result = new LineEntityItem(entityID, properties);
     return result;
@@ -31,21 +32,22 @@ EntityItem* LineEntityItem::factory(const EntityItemID& entityID, const EntityIt
 LineEntityItem::LineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
     EntityItem(entityItemID) ,
     _lineWidth(DEFAULT_LINE_WIDTH),
-    _points(QVector<glm::vec3>(100))
+    _points(QVector<glm::vec3>(5))
 {
     _type = EntityTypes::Line;
     _created = properties.getCreated();
-    setProperties(properties);
     glm::vec3 p1 = {0.0f, 0.0f, 0.0f};
     glm::vec3 p2 = {1.0f, 1.0f, 0.0f};
-    _points << p1;
+    setProperties(properties);
-    _points << p2;
+    
+    
 }
 
 EntityItemProperties LineEntityItem::getProperties() const {
     EntityItemProperties properties = EntityItem::getProperties(); // get the properties from our base class
 
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineWidth, getLineWidth);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(linePoints, getLinePoints);
     
     properties._color = getXColor();
     properties._colorChanged = false;
@@ -63,6 +65,9 @@ bool LineEntityItem::setProperties(const EntityItemProperties& properties) {
 
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(color, setColor);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(lineWidth, setLineWidth);
+    qDebug()<<"LINE POINTS" << properties._linePoints.size();
+    
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(linePoints, setLinePoints);
 
     if (somethingChanged) {
         bool wantDebug = false;
@@ -86,6 +91,8 @@ int LineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
 
     READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
     READ_ENTITY_PROPERTY(PROP_LINE_WIDTH, float, setLineWidth);
+    READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
+    
 
     return bytesRead;
 }

libraries/entities/src/LineEntityItem.h

@@ -60,7 +60,13 @@ class LineEntityItem : public EntityItem {
         return _lineWidth;
     }
     
-    QVector<glm::vec3> getPoints() const{
+    
+    void setLinePoints(const QVector<glm::vec3>& points){
+        qDebug()<<"WE ARE SETTTTING POINTS *******************";
+        _points = points;
+    }
+    
+    const QVector<glm::vec3>& getLinePoints() const{
         return _points;
     }
     

libraries/octree/src/OctreePacketData.cpp

@@ -381,7 +381,14 @@ bool OctreePacketData::appendValue(const glm::vec3& value) {
 }
 
 bool OctreePacketData::appendValue(const QVector<glm::vec3>& value){
-    
+    const unsigned char* data = (const unsigned char*)&value;
+    int length = sizeof(value);
+    bool success = append(data, length);
+    if (success){
+        _bytesOfValues += length;
+        _totalBytesOfValues += length;
+    }
+    return success;
 }
 
 bool OctreePacketData::appendValue(const glm::quat& value) {

libraries/octree/src/OctreePacketData.h

@@ -231,6 +231,7 @@ public:
     
     static int uppackDataFromBytes(const unsigned char* dataBytes, float& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int uppackDataFromBytes(const unsigned char* dataBytes, glm::vec3& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
+    static int uppackDataFromBytes(const unsigned char* dataBytes, QVector<glm::vec3>& result) {memcpy(&result, dataBytes, sizeof(result)); return sizeof(result);}
     static int uppackDataFromBytes(const unsigned char* dataBytes, bool& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int uppackDataFromBytes(const unsigned char* dataBytes, quint64& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int uppackDataFromBytes(const unsigned char* dataBytes, uint32_t& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
@@ -244,6 +245,7 @@ public:
     static int uppackDataFromBytes(const unsigned char* dataBytes, QUuid& result);
     static int uppackDataFromBytes(const unsigned char* dataBytes, xColor& result);
 
+
 private:
     /// appends raw bytes, might fail if byte would cause packet to be too large
     bool append(const unsigned char* data, int length);

libraries/render-utils/src/Model.h

@@ -515,7 +515,6 @@ private:
 
 Q_DECLARE_METATYPE(QPointer<Model>)
 Q_DECLARE_METATYPE(QWeakPointer<NetworkGeometry>)
-Q_DECLARE_METATYPE(QVector<glm::vec3>)
 
 /// Handle management of pending models that need blending
 class ModelBlender : public QObject, public Dependency {

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -72,6 +72,16 @@ void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
     vec3.z = object.property("z").toVariant().toFloat();
 }
 
+QScriptValue qVectorToScriptValue(QScriptEngine* engine, const QVector<glm::vec3> &vector){
+    QScriptValue array = engine->newArray();
+    return array;
+}
+
+QVector<glm::vec3> qVectorFromScriptValue(const QScriptValue &array){
+    qDebug()<<"Point 2 x"<<array.property(1).property("y").toString();
+    return QVector<glm::vec3>(7);
+}
+
 QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("x", vec2.x);

libraries/shared/src/RegisteredMetaTypes.h

@@ -28,6 +28,7 @@ Q_DECLARE_METATYPE(glm::vec3)
 Q_DECLARE_METATYPE(glm::vec2)
 Q_DECLARE_METATYPE(glm::quat)
 Q_DECLARE_METATYPE(xColor)
+Q_DECLARE_METATYPE(QVector<glm::vec3>)
 
 void registerMetaTypes(QScriptEngine* engine);
 
@@ -55,6 +56,9 @@ void qColorFromScriptValue(const QScriptValue& object, QColor& color);
 QScriptValue qURLToScriptValue(QScriptEngine* engine, const QUrl& url);
 void qURLFromScriptValue(const QScriptValue& object, QUrl& url);
 
+QScriptValue qVectorToScriptValue(QScriptEngine*, const QVector<glm::vec3>& vector);
+QVector<glm::vec3> qVectorFromScriptValue( const QScriptValue &array);
+
 class PickRay {
 public:
     PickRay() : origin(0.0f), direction(0.0f)  { }