diff --git a/examples/controllers/hydra/gun.js b/examples/controllers/hydra/gun.js
index 7d024e2fd3..26eee029af 100644
--- a/examples/controllers/hydra/gun.js
+++ b/examples/controllers/hydra/gun.js
@@ -181,7 +181,7 @@ function entityCollisionWithEntity(entity1, entity2, collision) {
 }
 
 function shootBullet(position, velocity, grenade) {
-    var BULLET_SIZE = 0.10;
+    var BULLET_SIZE = .09;
     var BULLET_LIFETIME = 10.0;
     var BULLET_GRAVITY = -0.25;
     var GRENADE_VELOCITY = 15.0;
diff --git a/examples/paint.js b/examples/paint.js
index c0cc93afc7..31ffd02506 100644
--- a/examples/paint.js
+++ b/examples/paint.js
@@ -10,17 +10,16 @@
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-Script.include('lineRider.js')
-var MAX_POINTS_PER_LINE = 30;
-var LINE_LIFETIME =  60 * 5  //5 minute lifetime
+
+var LINE_DIMENSIONS = 5;
+var LIFETIME = 6000;
 
 var colorPalette = [{
   red: 236,
   green: 208,
   blue: 120
 }, {
-  red: 217,
+  red: 214,
   green: 91,
   blue: 67
 }, {
@@ -40,15 +39,6 @@ var colorPalette = [{
 var currentColorIndex = 0;
 var currentColor = colorPalette[currentColorIndex];
 
-
-
-if (hydraCheck() === true) {
-  HydraPaint();
-} else {
-  MousePaint();
-}
-
-
 function cycleColor() {
   currentColor = colorPalette[++currentColorIndex];
   if (currentColorIndex === colorPalette.length - 1) {
@@ -57,42 +47,17 @@ function cycleColor() {
 
 }
 
-function hydraCheck() {
-  var numberOfButtons = Controller.getNumberOfButtons();
-  var numberOfTriggers = Controller.getNumberOfTriggers();
-  var numberOfSpatialControls = Controller.getNumberOfSpatialControls();
-  var controllersPerTrigger = numberOfSpatialControls / numberOfTriggers;
-  hydrasConnected = (numberOfButtons == 12 && numberOfTriggers == 2 && controllersPerTrigger == 2);
-  return hydrasConnected; //hydrasConnected;
-}
-
-//************ Mouse Paint **************************
+MousePaint();
 
 function MousePaint() {
-  var DRAWING_DISTANCE = 2;
+  var DRAWING_DISTANCE = 5;
   var lines = [];
-  var deletedLines = [];
   var isDrawing = false;
-  var path = [];
-
-  var lineRider = new LineRider();
-  lineRider.addStartHandler(function() {
-    var points = [];
-    //create points array from list of all points in path
-    path.forEach(function(point) {
-      points.push(point);
-    });
-    lineRider.setPath(points);
-  });
-
-
 
   var LINE_WIDTH = 7;
-  var line;
-  var points = [];
+  var line, linePosition;
 
-
-  var BRUSH_SIZE = 0.02;
+  var BRUSH_SIZE = .05;
 
   var brush = Entities.addEntity({
     type: 'Sphere',
@@ -110,51 +75,42 @@ function MousePaint() {
   });
 
 
-  function newLine(point) {
+  function newLine(position) {
+    linePosition = position;
     line = Entities.addEntity({
-      position: MyAvatar.position,
+      position: position,
       type: "Line",
       color: currentColor,
       dimensions: {
-        x: 10,
-        y: 10,
-        z: 10
+        x: LINE_DIMENSIONS,
+        y: LINE_DIMENSIONS,
+        z: LINE_DIMENSIONS
       },
+      linePoints: [],
       lineWidth: LINE_WIDTH,
-      lifetime: LINE_LIFETIME
+      lifetime: LIFETIME
     });
-    points = [];
-    if (point) {
-
-      points.push(point);
-      path.push(point);
-    }
     lines.push(line);
   }
 
 
   function mouseMoveEvent(event) {
 
+    var worldPoint = computeWorldPoint(event);
+    Entities.editEntity(brush, {
+      position: worldPoint
+    });
+
     if (!isDrawing) {
       return;
     }
 
-    var pickRay = Camera.computePickRay(event.x, event.y);
-    var addVector = Vec3.multiply(Vec3.normalize(pickRay.direction), DRAWING_DISTANCE);
-    var point = Vec3.sum(Camera.getPosition(), addVector);
-    points.push(point);
-    path.push(point);
-    Entities.editEntity(line, {
-      linePoints: points
-    });
-    Entities.editEntity(brush, {
-      position: point
-    });
+    var localPoint = computeLocalPoint(event)
+    var success = Entities.appendPoint(line, localPoint);
 
-
-    if (points.length === MAX_POINTS_PER_LINE) {
-      //We need to start a new line!
-      newLine(point);
+    if (!success) {
+      newLine(worldPoint);
+      Entities.appendPoint(line, computeLocalPoint(event));
     }
   }
 
@@ -171,17 +127,26 @@ function MousePaint() {
     lines.push(restoredLine);
   }
 
+  function computeWorldPoint(event) {
+    var pickRay = Camera.computePickRay(event.x, event.y);
+    var addVector = Vec3.multiply(Vec3.normalize(pickRay.direction), DRAWING_DISTANCE);
+    return Vec3.sum(Camera.getPosition(), addVector);
+  }
+
+  function computeLocalPoint(event) {
+
+    var localPoint = Vec3.subtract(computeWorldPoint(event), linePosition);
+    return localPoint;
+  }
+
   function mousePressEvent(event) {
-    if(!event.isLeftButton) {
+    if (!event.isLeftButton) {
       isDrawing = false;
       return;
     }
-    lineRider.mousePressEvent(event);
-    path = [];
-    newLine();
+    newLine(computeWorldPoint(event));
     isDrawing = true;
 
-
   }
 
   function mouseReleaseEvent() {
@@ -198,21 +163,21 @@ function MousePaint() {
     if (event.text === "z") {
       undoStroke();
     }
-    if(event.text === "x") {
+    if (event.text === "x") {
       redoStroke();
     }
   }
 
+
+
   function cleanup() {
     lines.forEach(function(line) {
-      Entities.deleteEntity(line);
+      // Entities.deleteEntity(line);
     });
     Entities.deleteEntity(brush);
-    lineRider.cleanup();
 
   }
 
-
   Controller.mousePressEvent.connect(mousePressEvent);
   Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
   Controller.mouseMoveEvent.connect(mouseMoveEvent);
@@ -222,266 +187,6 @@ function MousePaint() {
 }
 
 
-
-//*****************HYDRA PAINT *******************************************
-
-
-
-function HydraPaint() {
-
-
-
-  var lineRider = new LineRider();
-  lineRider.addStartHandler(function() {
-    var points = [];
-    //create points array from list of all points in path
-    rightController.path.forEach(function(point) {
-      points.push(point);
-    });
-    lineRider.setPath(points);
-  });
-
-  var LEFT = 0;
-  var RIGHT = 1;
-
-  var currentTime = 0;
-
-
-  var minBrushSize = .02;
-  var maxBrushSize = .04
-
-
-  var minLineWidth = 5;
-  var maxLineWidth = 10;
-  var currentLineWidth = minLineWidth;
-  var MIN_PAINT_TRIGGER_THRESHOLD = .01;
-  var COLOR_CHANGE_TIME_FACTOR = 0.1;
-
-  var RIGHT_BUTTON_1 = 7
-  var RIGHT_BUTTON_2 = 8
-  var RIGHT_BUTTON_3 = 9;
-  var RIGHT_BUTTON_4 = 10
-
-  var LEFT_BUTTON_1 = 1;
-  var LEFT_BUTTON_2 = 2;
-  var LEFT_BUTTON_3 = 3;
-  var LEFT_BUTTON_4 = 4;
-
-  var STROKE_SMOOTH_FACTOR = 1;
-
-  var MIN_DRAW_DISTANCE = 0.2;
-  var MAX_DRAW_DISTANCE = 0.4;
-
-  function controller(side, undoButton, redoButton, cycleColorButton, startRideButton) {
-    this.triggerHeld = false;
-    this.triggerThreshold = 0.9;
-    this.side = side;
-    this.palm = 2 * side;
-    this.tip = 2 * side + 1;
-    this.trigger = side;
-    this.lines = [];
-    this.deletedLines = [] //just an array of properties objects
-    this.isPainting = false;
-
-    this.undoButton = undoButton;
-    this.undoButtonPressed = false;
-    this.prevUndoButtonPressed = false;
-
-    this.redoButton = redoButton;
-    this.redoButtonPressed = false;
-    this.prevRedoButtonPressed = false;
-
-    this.cycleColorButton = cycleColorButton;
-    this.cycleColorButtonPressed = false;
-    this.prevColorCycleButtonPressed = false;
-
-    this.startRideButton = startRideButton;
-    this.startRideButtonPressed = false;
-    this.prevStartRideButtonPressed = false;
-
-    this.strokeCount = 0;
-    this.currentBrushSize = minBrushSize;
-    this.points = [];
-    this.path = [];
-
-    this.brush = Entities.addEntity({
-      type: 'Sphere',
-      position: {
-        x: 0,
-        y: 0,
-        z: 0
-      },
-      color: currentColor,
-      dimensions: {
-        x: minBrushSize,
-        y: minBrushSize,
-        z: minBrushSize
-      }
-    });
-
-
-    this.newLine = function(point) {
-      this.line = Entities.addEntity({
-        position: MyAvatar.position,
-        type: "Line",
-        color: currentColor,
-        dimensions: {
-          x: 10,
-          y: 10,
-          z: 10
-        },
-        lineWidth: 5,
-        lifetime: LINE_LIFETIME
-      });
-      this.points = [];
-      if (point) {
-        this.points.push(point);
-        this.path.push(point);
-      }
-      this.lines.push(this.line);
-    }
-
-    this.update = function(deltaTime) {
-      this.updateControllerState();
-      this.avatarPalmOffset = Vec3.subtract(this.palmPosition, MyAvatar.position);
-      this.projectedForwardDistance = Vec3.dot(Quat.getFront(Camera.getOrientation()), this.avatarPalmOffset);
-      this.mappedPalmOffset = map(this.projectedForwardDistance, -.5, .5, MIN_DRAW_DISTANCE, MAX_DRAW_DISTANCE);
-      this.tipDirection = Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition));
-      this.offsetVector = Vec3.multiply(this.mappedPalmOffset, this.tipDirection);
-      this.drawPoint = Vec3.sum(this.palmPosition, this.offsetVector);
-      this.currentBrushSize = map(this.triggerValue, 0, 1, minBrushSize, maxBrushSize);
-      Entities.editEntity(this.brush, {
-        position: this.drawPoint,
-        dimensions: {
-          x: this.currentBrushSize,
-          y: this.currentBrushSize,
-          z: this.currentBrushSize
-        },
-        color: currentColor
-      });
-      if (this.triggerValue > MIN_PAINT_TRIGGER_THRESHOLD) {
-        if (!this.isPainting) {
-          this.isPainting = true;
-          this.newLine();
-          this.path = [];
-        }
-        if (this.strokeCount % STROKE_SMOOTH_FACTOR === 0) {
-          this.paint(this.drawPoint);
-        }
-        this.strokeCount++;
-      } else if (this.triggerValue < MIN_PAINT_TRIGGER_THRESHOLD && this.isPainting) {
-        this.releaseTrigger();
-      }
-
-      this.oldPalmPosition = this.palmPosition;
-      this.oldTipPosition = this.tipPosition;
-    }
-
-    this.releaseTrigger = function() {
-      this.isPainting = false;
-
-    }
-
-
-    this.updateControllerState = function() {
-      this.undoButtonPressed = Controller.isButtonPressed(this.undoButton);
-      this.redoButtonPressed = Controller.isButtonPressed(this.redoButton);
-      this.cycleColorButtonPressed = Controller.isButtonPressed(this.cycleColorButton);
-      this.startRideButtonPressed = Controller.isButtonPressed(this.startRideButton);
-
-      //This logic gives us button release
-      if (this.prevUndoButtonPressed === true && this.undoButtonPressed === false) {
-        //User released undo button, so undo
-        this.undoStroke();
-      }
-      if (this.prevRedoButtonPressed === true && this.redoButtonPressed === false) {
-        this.redoStroke();
-      }
-
-      if (this.prevCycleColorButtonPressed === true && this.cycleColorButtonPressed === false) {
-        cycleColor();
-        Entities.editEntity(this.brush, {
-          color: currentColor
-        });
-      }
-      if (this.prevStartRideButtonPressed === true && this.startRideButtonPressed === false) {
-        lineRider.toggleRide();
-      }
-      this.prevRedoButtonPressed = this.redoButtonPressed;
-      this.prevUndoButtonPressed = this.undoButtonPressed;
-      this.prevCycleColorButtonPressed = this.cycleColorButtonPressed;
-      this.prevStartRideButtonPressed = this.startRideButtonPressed;
-
-      this.palmPosition = Controller.getSpatialControlPosition(this.palm);
-      this.tipPosition = Controller.getSpatialControlPosition(this.tip);
-      this.triggerValue = Controller.getTriggerValue(this.trigger);
-    }
-
-    this.undoStroke = function() {
-      var deletedLine = this.lines.pop();
-      var deletedLineProps = Entities.getEntityProperties(deletedLine);
-      this.deletedLines.push(deletedLineProps);
-      Entities.deleteEntity(deletedLine);
-    }
-
-    this.redoStroke = function() {
-      var restoredLine = Entities.addEntity(this.deletedLines.pop());
-      Entities.addEntity(restoredLine);
-      this.lines.push(restoredLine);
-    }
-
-    this.paint = function(point) {
-
-      currentLineWidth = map(this.triggerValue, 0, 1, minLineWidth, maxLineWidth);
-      this.points.push(point);
-      this.path.push(point);
-      Entities.editEntity(this.line, {
-        linePoints: this.points,
-        lineWidth: currentLineWidth,
-      });
-      if (this.points.length > MAX_POINTS_PER_LINE) {
-        this.newLine(point);
-      }
-    }
-
-    this.cleanup = function() {
-      Entities.deleteEntity(this.brush);
-      this.lines.forEach(function(line) {
-        Entities.deleteEntity(line);
-      });
-    }
-  }
-
-  function update(deltaTime) {
-    rightController.update(deltaTime);
-    leftController.update(deltaTime);
-    currentTime += deltaTime;
-  }
-
-  function cleanup() {
-    rightController.cleanup();
-    leftController.cleanup();
-    lineRider.cleanup();
-  }
-
-  function mousePressEvent(event) {
-    lineRider.mousePressEvent(event);
-  }
-
-  function vectorIsZero(v) {
-    return v.x === 0 && v.y === 0 && v.z === 0;
-  }
-
-
-  var rightController = new controller(RIGHT, RIGHT_BUTTON_3, RIGHT_BUTTON_4, RIGHT_BUTTON_1, RIGHT_BUTTON_2);
-  var leftController = new controller(LEFT, LEFT_BUTTON_3, LEFT_BUTTON_4, LEFT_BUTTON_1, LEFT_BUTTON_2);
-
-  Script.update.connect(update);
-  Script.scriptEnding.connect(cleanup);
-  Controller.mousePressEvent.connect(mousePressEvent);
-
-}
-
 function randFloat(low, high) {
   return low + Math.random() * (high - low);
 }
diff --git a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp
index 65407c74e7..4b94992d59 100644
--- a/libraries/entities-renderer/src/RenderableLineEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableLineEntityItem.cpp
@@ -43,9 +43,9 @@ void RenderableLineEntityItem::render(RenderArgs* args) {
     
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
-    // TODO: Figure out clean , efficient way to do relative line positioning. For now we'll just use absolute positioning.
-    //batch.setModelTransform(getTransformToCenter());
-    batch.setModelTransform(Transform());
+    Transform transform = Transform();
+    transform.setTranslation(getPosition());
+    batch.setModelTransform(transform);
     
     batch._glLineWidth(getLineWidth());
     if (getLinePoints().size() > 1) {
diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h
index 068bc98f7e..5f33da52f8 100644
--- a/libraries/entities/src/EntityItemProperties.h
+++ b/libraries/entities/src/EntityItemProperties.h
@@ -197,6 +197,8 @@ public:
     QString getSimulatorIDAsString() const { return _simulatorID.toString().mid(1,36).toUpper(); }
 
     void setVoxelDataDirty() { _voxelDataChanged = true; }
+    
+    void setLinePointsDirty() {_linePointsChanged = true; }
 
     void setCreated(QDateTime& v);
 
diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp
index a091c786b7..c9f7378bc8 100644
--- a/libraries/entities/src/EntityScriptingInterface.cpp
+++ b/libraries/entities/src/EntityScriptingInterface.cpp
@@ -442,6 +442,43 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID,
     return true;
 }
 
+bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor) {
+    if (!_entityTree) {
+        return false;
+    }
+    
+    EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
+    if (!entity) {
+        qCDebug(entities) << "EntityScriptingInterface::setPoints no entity with ID" << entityID;
+    }
+    
+    EntityTypes::EntityType entityType = entity->getType();
+    
+    if (entityType != EntityTypes::Line) {
+        return false;
+    }
+    
+    auto now = usecTimestampNow();
+    
+    LineEntityItem* lineEntity = static_cast<LineEntityItem*>(entity.get());
+    _entityTree->lockForWrite();
+    bool success = actor(*lineEntity);
+    entity->setLastEdited(now);
+    entity->setLastBroadcast(now);
+    _entityTree->unlock();
+    
+    _entityTree->lockForRead();
+    EntityItemProperties properties = entity->getProperties();
+    _entityTree->unlock();
+    
+    properties.setLinePointsDirty();
+    properties.setLastEdited(now);
+    
+    
+    queueEntityMessage(PacketTypeEntityEdit, entityID, properties);
+    return success;
+}
+
 bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {
     return setVoxels(entityID, [center, radius, value](PolyVoxEntityItem& polyVoxEntity) {
             polyVoxEntity.setSphere(center, radius, value);
@@ -460,6 +497,21 @@ bool EntityScriptingInterface::setAllVoxels(QUuid entityID, int value) {
         });
 }
 
+bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<glm::vec3>& points) {
+    return setPoints(entityID, [points](LineEntityItem& lineEntity) -> bool
+    {
+        return lineEntity.setLinePoints(points);
+    });
+}
+
+bool EntityScriptingInterface::appendPoint(QUuid entityID, const glm::vec3& point) {
+    return setPoints(entityID, [point](LineEntityItem& lineEntity) -> bool
+    {
+        return lineEntity.appendPoint(point);
+    });
+    
+}
+
 
 bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
                                             std::function<bool(EntitySimulation*, EntityItemPointer)> actor) {
diff --git a/libraries/entities/src/EntityScriptingInterface.h b/libraries/entities/src/EntityScriptingInterface.h
index c6bc43c8c6..12c8688816 100644
--- a/libraries/entities/src/EntityScriptingInterface.h
+++ b/libraries/entities/src/EntityScriptingInterface.h
@@ -22,6 +22,7 @@
 #include <OctreeScriptingInterface.h>
 #include <RegisteredMetaTypes.h>
 #include "PolyVoxEntityItem.h"
+#include "LineEntityItem.h"
 
 #include "EntityEditPacketSender.h"
 
@@ -121,6 +122,9 @@ public slots:
     Q_INVOKABLE bool setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value);
     Q_INVOKABLE bool setVoxel(QUuid entityID, const glm::vec3& position, int value);
     Q_INVOKABLE bool setAllVoxels(QUuid entityID, int value);
+    
+    Q_INVOKABLE bool setAllPoints(QUuid entityID, const QVector<glm::vec3>& points);
+    Q_INVOKABLE bool appendPoint(QUuid entityID, const glm::vec3& point);
 
     Q_INVOKABLE void dumpTree() const;
 
@@ -157,6 +161,7 @@ signals:
 private:
     bool actionWorker(const QUuid& entityID, std::function<bool(EntitySimulation*, EntityItemPointer)> actor);
     bool setVoxels(QUuid entityID, std::function<void(PolyVoxEntityItem&)> actor);
+    bool setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor);
     void queueEntityMessage(PacketType packetType, EntityItemID entityID, const EntityItemProperties& properties);
 
     /// actually does the work of finding the ray intersection, can be called in locking mode or tryLock mode
diff --git a/libraries/entities/src/LineEntityItem.cpp b/libraries/entities/src/LineEntityItem.cpp
index 094536f63a..fccf57c7c7 100644
--- a/libraries/entities/src/LineEntityItem.cpp
+++ b/libraries/entities/src/LineEntityItem.cpp
@@ -23,6 +23,7 @@
 
 
 const float LineEntityItem::DEFAULT_LINE_WIDTH = 2.0f;
+const int LineEntityItem::MAX_POINTS_PER_LINE = 70;
 
 
 EntityItemPointer LineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
@@ -85,24 +86,38 @@ bool LineEntityItem::setProperties(const EntityItemProperties& properties) {
     return somethingChanged;
 }
 
-void LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
-    QVector<glm::vec3> sanitizedPoints;
-    int invalidPoints = 0;
+bool LineEntityItem::appendPoint(const glm::vec3& point) {
+    if (_points.size() > MAX_POINTS_PER_LINE - 1) {
+        qDebug() << "MAX POINTS REACHED!";
+        return false;
+    }
+    glm::vec3 halfBox = getDimensions() * 0.5f;
+    if ( (point.x < - halfBox.x || point.x > halfBox.x) || (point.y < -halfBox.y || point.y > halfBox.y) || (point.z < - halfBox.z || point.z > halfBox.z) ) {
+        qDebug() << "Point is outside entity's bounding box";
+        return false;
+    }
+    _points << point;
+    _pointsChanged = true;
+    return true;
+}
+
+bool LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
+    if (points.size() > MAX_POINTS_PER_LINE) {
+        return false;
+    }
     for (int i = 0; i < points.size(); i++) {
         glm::vec3 point = points.at(i);
-        // Make sure all of our points are valid numbers.
-        // Must be greater than 0 because vector component is set to 0 if it is invalid data. Also should never be greater than TREE_SCALE
-        if ( (point.x > 0 && point.x < TREE_SCALE) && (point.y > 0 && point.y < TREE_SCALE) && (point.z > 0 && point.z < TREE_SCALE) ) {
-            sanitizedPoints << point;
-        } else {
-            ++invalidPoints;
+        glm::vec3 pos = getPosition();
+        glm::vec3 halfBox = getDimensions() * 0.5f;
+        if ( (point.x < - halfBox.x || point.x > halfBox.x) || (point.y < -halfBox.y || point.y > halfBox.y) || (point.z < - halfBox.z || point.z > halfBox.z) ) {
+            qDebug() << "Point is outside entity's bounding box";
+            return false;
         }
+        
     }
-    if (invalidPoints > 0) {
-        qDebug() << "Line with" << invalidPoints << "INVALID POINTS";
-    }
-    _points = sanitizedPoints;
+    _points = points;
     _pointsChanged = true;
+    return true;
 }
 
 int LineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
diff --git a/libraries/entities/src/LineEntityItem.h b/libraries/entities/src/LineEntityItem.h
index 5151244b3c..6d0f00ef04 100644
--- a/libraries/entities/src/LineEntityItem.h
+++ b/libraries/entities/src/LineEntityItem.h
@@ -54,7 +54,8 @@ class LineEntityItem : public EntityItem {
     void setLineWidth(float lineWidth){ _lineWidth = lineWidth; }
     float getLineWidth() const{ return _lineWidth; }
     
-    void setLinePoints(const QVector<glm::vec3>& points);
+    bool setLinePoints(const QVector<glm::vec3>& points);
+    bool appendPoint(const glm::vec3& point);
     
     const QVector<glm::vec3>& getLinePoints() const{ return _points; }
     
@@ -68,6 +69,7 @@ class LineEntityItem : public EntityItem {
 
     virtual void debugDump() const;
     static const float DEFAULT_LINE_WIDTH;
+    static const int MAX_POINTS_PER_LINE;
 
  protected:
     rgbColor _color;
diff --git a/libraries/entities/src/QuadEntityItem.cpp b/libraries/entities/src/QuadEntityItem.cpp
new file mode 100644
index 0000000000..0ac04129be
--- /dev/null
+++ b/libraries/entities/src/QuadEntityItem.cpp
@@ -0,0 +1,9 @@
+//
+//  QuadEntityItem.cpp
+//  hifi
+//
+//  Created by eric levin on 6/22/15.
+//
+//
+
+#include "QuadEntityItem.h"
diff --git a/libraries/entities/src/QuadEntityItem.h b/libraries/entities/src/QuadEntityItem.h
new file mode 100644
index 0000000000..64f733d6b5
--- /dev/null
+++ b/libraries/entities/src/QuadEntityItem.h
@@ -0,0 +1,14 @@
+//
+//  QuadEntityItem.h
+//  hifi
+//
+//  Created by eric levin on 6/22/15.
+//
+//
+
+#ifndef __hifi__QuadEntityItem__
+#define __hifi__QuadEntityItem__
+
+#include <stdio.h>
+
+#endif /* defined(__hifi__QuadEntityItem__) */
diff --git a/libraries/shared/src/RegisteredMetaTypes.cpp b/libraries/shared/src/RegisteredMetaTypes.cpp
index 241f835a46..50f87fe258 100644
--- a/libraries/shared/src/RegisteredMetaTypes.cpp
+++ b/libraries/shared/src/RegisteredMetaTypes.cpp
@@ -20,6 +20,7 @@
 
 static int vec4MetaTypeId = qRegisterMetaType<glm::vec4>();
 static int vec3MetaTypeId = qRegisterMetaType<glm::vec3>();
+static int qVectorVec3MetaTypeId = qRegisterMetaType<QVector<glm::vec3>>();
 static int vec2MetaTypeId = qRegisterMetaType<glm::vec2>();
 static int quatMetaTypeId = qRegisterMetaType<glm::quat>();
 static int xColorMetaTypeId = qRegisterMetaType<xColor>();
@@ -31,6 +32,7 @@ static int collisionMetaTypeId = qRegisterMetaType<Collision>();
 void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue);
     qScriptRegisterMetaType(engine, vec3toScriptValue, vec3FromScriptValue);
+    qScriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue);
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
@@ -93,6 +95,16 @@ QVector<glm::vec3> qVectorVec3FromScriptValue(const QScriptValue& array){
     return newVector;
 }
 
+void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector ) {
+    int length = array.property("length").toInteger();
+    
+    for (int i = 0; i < length; i++) {
+        glm::vec3 newVec3 = glm::vec3();
+        vec3FromScriptValue(array.property(i), newVec3);
+        vector << newVec3;
+    }
+}
+
 QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("x", vec2.x);
diff --git a/libraries/shared/src/RegisteredMetaTypes.h b/libraries/shared/src/RegisteredMetaTypes.h
index 1dcc85107a..f5f39cd3f6 100644
--- a/libraries/shared/src/RegisteredMetaTypes.h
+++ b/libraries/shared/src/RegisteredMetaTypes.h
@@ -57,6 +57,7 @@ QScriptValue qURLToScriptValue(QScriptEngine* engine, const QUrl& url);
 void qURLFromScriptValue(const QScriptValue& object, QUrl& url);
 
 QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector<glm::vec3>& vector);
+void qVectorVec3FromScriptValue(const QScriptValue& array, QVector<glm::vec3>& vector);
 QVector<glm::vec3> qVectorVec3FromScriptValue( const QScriptValue& array);
 
 class PickRay {