Merge branch 'master' of https://github.com/highfidelity/hifi into entityListTypeFilter

android/gradle.properties

@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xms2g -Xmx4g

assignment-client/src/audio/AudioMixerClientData.cpp

@@ -497,7 +497,7 @@ void AudioMixerClientData::processStreamPacket(ReceivedMessage& message, Concurr
 
     if (newStream) {
         // whenever a stream is added, push it to the concurrent vector of streams added this frame
-        addedStreams.emplace_back(getNodeID(), getNodeLocalID(), matchingStream->getStreamIdentifier(), matchingStream.get());
+        addedStreams.push_back(AddedStream(getNodeID(), getNodeLocalID(), matchingStream->getStreamIdentifier(), matchingStream.get()));
     }
 }
 

interface/resources/qml/hifi/commerce/common/sendAsset/SendAsset.qml

@@ -39,6 +39,7 @@ Item {
     property string sendingPubliclyEffectImage;
     property var http;
     property var listModelName;
+    property var keyboardContainer: nil;
         
     // This object is always used in a popup or full-screen Wallet section.
     // This MouseArea is used to prevent a user from being
@@ -1125,8 +1126,7 @@ Item {
             checked: Settings.getValue("sendAssetsNearbyPublicly", true);
             text: "Show Effect"
             // Anchors
-            anchors.top: messageContainer.bottom;
-            anchors.topMargin: 16;
+            anchors.verticalCenter: bottomBarContainer.verticalCenter;
             anchors.left: parent.left;
             anchors.leftMargin: 20;
             width: 130;
@@ -1168,6 +1168,9 @@ Item {
                         lightboxPopup.visible = false;
                     }
                     lightboxPopup.visible = true;
+                    if (keyboardContainer) {
+                        keyboardContainer.keyboardRaised = false;
+                    }
                 }
             }
         }
@@ -1178,8 +1181,8 @@ Item {
             anchors.leftMargin: 20;
             anchors.right: parent.right;
             anchors.rightMargin: 20;
-            anchors.bottom: parent.bottom;
-            anchors.bottomMargin: 20;
+            anchors.top: messageContainer.bottom;
+            anchors.topMargin: 20;
             height: 60;
 
             // "CANCEL" button
@@ -1187,11 +1190,11 @@ Item {
                 id: cancelButton_sendAssetStep;
                 color: root.assetName === "" ? hifi.buttons.noneBorderlessWhite : hifi.buttons.noneBorderlessGray;
                 colorScheme: hifi.colorSchemes.dark;
-                anchors.left: parent.left;
-                anchors.leftMargin: 24;
+                anchors.right: sendButton.left;
+                anchors.rightMargin: 24;
                 anchors.verticalCenter: parent.verticalCenter;
                 height: 40;
-                width: 150;
+                width: 100;
                 text: "CANCEL";
                 onClicked: {
                     resetSendAssetData();
@@ -1205,10 +1208,10 @@ Item {
                 color: hifi.buttons.blue;
                 colorScheme: root.assetName === "" ? hifi.colorSchemes.dark : hifi.colorSchemes.light;
                 anchors.right: parent.right;
-                anchors.rightMargin: 24;
+                anchors.rightMargin: 0;
                 anchors.verticalCenter: parent.verticalCenter;
                 height: 40;
-                width: 150;
+                width: 100;
                 text: "SUBMIT";
                 onClicked: {
                     if (root.assetName === "" && parseInt(amountTextField.text) > parseInt(balanceText.text)) {

interface/resources/qml/hifi/commerce/purchases/Purchases.qml

@@ -158,6 +158,7 @@ Rectangle {
         listModelName: "Gift Connections";
         z: 998;
         visible: root.activeView === "giftAsset";
+        keyboardContainer: root;
         anchors.fill: parent;
         parentAppTitleBarHeight: 70;
         parentAppNavBarHeight: 0;
@@ -585,7 +586,7 @@ Rectangle {
             visible: purchasesModel.count !== 0;
             clip: true;
             model: purchasesModel;
-            snapMode: ListView.SnapToItem;
+            snapMode: ListView.NoSnap;
             // Anchors
             anchors.top: separator.bottom;
             anchors.left: parent.left;

interface/resources/qml/hifi/commerce/wallet/Wallet.qml

@@ -354,6 +354,7 @@ Rectangle {
         listModelName: "Send Money Connections";
         z: 997;
         visible: root.activeView === "sendMoney";
+        keyboardContainer: root;
         anchors.fill: parent;
         parentAppTitleBarHeight: titleBarContainer.height;
         parentAppNavBarHeight: tabButtonsContainer.height;

interface/src/Application.cpp

@@ -8476,6 +8476,16 @@ QUuid Application::getTabletFrameID() const {
     return HMD->getCurrentTabletFrameID();
 }
 
+QVector<QUuid> Application::getTabletIDs() const {
+    // Most important overlays first. 
+    QVector<QUuid> result;
+    auto HMD = DependencyManager::get<HMDScriptingInterface>();
+    result << HMD->getCurrentTabletScreenID();
+    result << HMD->getCurrentHomeButtonID();
+    result << HMD->getCurrentTabletFrameID();
+    return result;
+}
+
 void Application::setAvatarOverrideUrl(const QUrl& url, bool save) {
     _avatarOverrideUrl = url;
     _saveAvatarOverrideUrl = save;

interface/src/Application.h

@@ -298,6 +298,7 @@ public:
     OverlayID getTabletScreenID() const;
     OverlayID getTabletHomeButtonID() const;
     QUuid getTabletFrameID() const; // may be an entity or an overlay
+    QVector<QUuid> getTabletIDs() const; // In order of most important IDs first.
 
     void setAvatarOverrideUrl(const QUrl& url, bool save);
     void clearAvatarOverrideUrl() { _avatarOverrideUrl = QUrl(); _saveAvatarOverrideUrl = false; }

interface/src/AvatarBookmarks.cpp

@@ -78,8 +78,10 @@ void addAvatarEntities(const QVariantList& avatarEntities) {
                 }
 
                 entity->setLastBroadcast(usecTimestampNow());
-                // since we're creating this object we will immediately volunteer to own its simulation
-                entity->setScriptSimulationPriority(VOLUNTEER_SIMULATION_PRIORITY);
+                if (entityProperties.getDynamic()) {
+                    // since we're creating a dynamic object we volunteer immediately to own its simulation
+                    entity->upgradeScriptSimulationPriority(VOLUNTEER_SIMULATION_PRIORITY);
+                }
                 entityProperties.setLastEdited(entity->getLastEdited());
             } else {
                 qCDebug(entities) << "AvatarEntitiesBookmark failed to add new Entity to local Octree";
@@ -108,6 +110,9 @@ AvatarBookmarks::AvatarBookmarks() {
 
         if (!QFile::copy(defaultBookmarksFilename, _bookmarksFilename)) {
             qDebug() << "failed to copy" << defaultBookmarksFilename << "to" << _bookmarksFilename;
+        } else {
+            QFile bookmarksFile(_bookmarksFilename);
+            bookmarksFile.setPermissions(bookmarksFile.permissions() | QFile::WriteUser);
         }
     }
     readFromFile();

interface/src/avatar/MyAvatar.cpp

@@ -122,7 +122,6 @@ MyAvatar::MyAvatar(QThread* thread) :
     _goToOrientation(),
     _prevShouldDrawHead(true),
     _audioListenerMode(FROM_HEAD),
-    _hmdAtRestDetector(glm::vec3(0), glm::quat()),
     _dominantHandSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "dominantHand", DOMINANT_RIGHT_HAND),
     _headPitchSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "", 0.0f),
     _scaleSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "scale", _targetScale),
@@ -702,6 +701,46 @@ void MyAvatar::simulate(float deltaTime) {
     // before we perform rig animations and IK.
     updateSensorToWorldMatrix();
 
+    // if we detect the hand controller is at rest, i.e. lying on the table, or the hand is too far away from the hmd
+    // disable the associated hand controller input.
+    {
+        // NOTE: all poses are in sensor space.
+        auto leftHandIter = _controllerPoseMap.find(controller::Action::LEFT_HAND);
+        if (leftHandIter != _controllerPoseMap.end() && leftHandIter->second.isValid()) {
+            _leftHandAtRestDetector.update(leftHandIter->second.getTranslation(), leftHandIter->second.getRotation());
+            if (_leftHandAtRestDetector.isAtRest()) {
+                leftHandIter->second.valid = false;
+            }
+        } else {
+            _leftHandAtRestDetector.invalidate();
+        }
+
+        auto rightHandIter = _controllerPoseMap.find(controller::Action::RIGHT_HAND);
+        if (rightHandIter != _controllerPoseMap.end() && rightHandIter->second.isValid()) {
+            _rightHandAtRestDetector.update(rightHandIter->second.getTranslation(), rightHandIter->second.getRotation());
+            if (_rightHandAtRestDetector.isAtRest()) {
+                rightHandIter->second.valid = false;
+            }
+        } else {
+            _rightHandAtRestDetector.invalidate();
+        }
+
+        auto headIter = _controllerPoseMap.find(controller::Action::HEAD);
+
+        // The 99th percentile man has a spine to fingertip to height ratio of 0.45.  Lets increase that by about 10% to 0.5
+        // then measure the distance the center of the eyes to the finger tips.  To come up with this ratio.
+        // From "The Measure of Man and Woman: Human Factors in Design, Revised Edition" by Alvin R. Tilley, Henry Dreyfuss Associates
+        const float MAX_HEAD_TO_HAND_DISTANCE_RATIO = 0.52f;
+
+        float maxHeadHandDistance = getUserHeight() * MAX_HEAD_TO_HAND_DISTANCE_RATIO;
+        if (glm::length(headIter->second.getTranslation() - leftHandIter->second.getTranslation()) > maxHeadHandDistance) {
+            leftHandIter->second.valid = false;
+        }
+        if (glm::length(headIter->second.getTranslation() - rightHandIter->second.getTranslation()) > maxHeadHandDistance) {
+            rightHandIter->second.valid = false;
+        }
+    }
+
     {
         PerformanceTimer perfTimer("skeleton");
 

interface/src/avatar/MyAvatar.h

@@ -629,8 +629,6 @@ public:
 
     const MyHead* getMyHead() const;
 
-    Q_INVOKABLE void toggleSmoothPoleVectors() { _skeletonModel->getRig().toggleSmoothPoleVectors(); };
-
     /**jsdoc
      * Get the current position of the avatar's "Head" joint.
      * @function MyAvatar.getHeadPosition
@@ -951,50 +949,72 @@ public:
     void removeWearableAvatarEntities();
 
     /**jsdoc
+     * Check whether your avatar is flying or not.
      * @function MyAvatar.isFlying
-     * @returns {boolean} 
+     * @returns {boolean} <code>true</code> if your avatar is flying and not taking off or falling, otherwise 
+     *     <code>false</code>.
      */
     Q_INVOKABLE bool isFlying();
 
     /**jsdoc
+     * Check whether your avatar is in the air or not.
      * @function MyAvatar.isInAir
-     * @returns {boolean} 
+     * @returns {boolean} <code>true</code> if your avatar is taking off, flying, or falling, otherwise <code>false</code> 
+     *     because your avatar is on the ground.
      */
     Q_INVOKABLE bool isInAir();
 
     /**jsdoc
+     * Set your preference for flying in your current desktop or HMD display mode. Note that your ability to fly also depends 
+     * on whether the domain you're in allows you to fly.
      * @function MyAvatar.setFlyingEnabled
-     * @param {boolean} enabled
+     * @param {boolean} enabled - Set <code>true</code> if you want to enable flying in your current desktop or HMD display 
+     *     mode, otherwise set <code>false</code>.
      */
     Q_INVOKABLE void setFlyingEnabled(bool enabled);
 
     /**jsdoc
+     * Get your preference for flying in your current desktop or HMD display mode. Note that your ability to fly also depends 
+     * on whether the domain you're in allows you to fly.
      * @function MyAvatar.getFlyingEnabled
-     * @returns {boolean}
+     * @returns {boolean} <code>true</code> if your preference is to enable flying in your current desktop or HMD display mode, 
+     *     otherwise <code>false</code>.
      */
     Q_INVOKABLE bool getFlyingEnabled();
 
     /**jsdoc
+     * Set your preference for flying in desktop display mode. Note that your ability to fly also depends on whether the domain 
+     * you're in allows you to fly.
      * @function MyAvatar.setFlyingDesktopPref
-     * @param {boolean} enabled
+     * @param {boolean} enabled - Set <code>true</code> if you want to enable flying in desktop display mode, otherwise set 
+     *     <code>false</code>.
      */
     Q_INVOKABLE void setFlyingDesktopPref(bool enabled);
 
     /**jsdoc
+     * Get your preference for flying in desktop display mode. Note that your ability to fly also depends on whether the domain
+     * you're in allows you to fly.
      * @function MyAvatar.getFlyingDesktopPref
-     * @returns {boolean}
+     * @returns {boolean} <code>true</code> if your preference is to enable flying in desktop display mode, otherwise 
+     *     <code>false</code>.
      */
     Q_INVOKABLE bool getFlyingDesktopPref();
 
     /**jsdoc
-     * @function MyAvatar.setFlyingDesktopPref
-     * @param {boolean} enabled
+     * Set your preference for flying in HMD display mode. Note that your ability to fly also depends on whether the domain
+     * you're in allows you to fly.
+     * @function MyAvatar.setFlyingHMDPref
+     * @param {boolean} enabled - Set <code>true</code> if you want to enable flying in HMD display mode, otherwise set
+     *     <code>false</code>.
      */
     Q_INVOKABLE void setFlyingHMDPref(bool enabled);
 
     /**jsdoc
-     * @function MyAvatar.getFlyingDesktopPref
-     * @returns {boolean}
+     * Get your preference for flying in HMD display mode. Note that your ability to fly also depends on whether the domain
+     * you're in allows you to fly.
+     * @function MyAvatar.getFlyingHMDPref
+     * @returns {boolean} <code>true</code> if your preference is to enable flying in HMD display mode, otherwise
+     *     <code>false</code>.
      */
     Q_INVOKABLE bool getFlyingHMDPref();
 
@@ -1766,8 +1786,8 @@ private:
     glm::vec3 _customListenPosition;
     glm::quat _customListenOrientation;
 
-    AtRestDetector _hmdAtRestDetector;
-    bool _lastIsMoving { false };
+    AtRestDetector _leftHandAtRestDetector;
+    AtRestDetector _rightHandAtRestDetector;
 
     // all poses are in sensor-frame
     std::map<controller::Action, controller::Pose> _controllerPoseMap;

interface/src/avatar/MySkeletonModel.cpp

@@ -46,7 +46,7 @@ static AnimPose computeHipsInSensorFrame(MyAvatar* myAvatar, bool isFlying) {
     }
 
     glm::mat4 hipsMat;
-    if (myAvatar->getCenterOfGravityModelEnabled() && !isFlying && !(myAvatar->getIsInWalkingState())) {
+    if (myAvatar->getCenterOfGravityModelEnabled() && !isFlying && !(myAvatar->getIsInWalkingState()) && myAvatar->getHMDLeanRecenterEnabled()) {
         // then we use center of gravity model
         hipsMat = myAvatar->deriveBodyUsingCgModel();
     } else {

interface/src/avatar/OtherAvatar.cpp

@@ -11,12 +11,12 @@
 
 #include "AvatarMotionState.h"
 
-static xColor getLoadingOrbColor(Avatar::LoadingStatus loadingStatus) {
+static glm::u8vec3 getLoadingOrbColor(Avatar::LoadingStatus loadingStatus) {
 
-    const xColor NO_MODEL_COLOR(0xe3, 0xe3, 0xe3);
-    const xColor LOAD_MODEL_COLOR(0xef, 0x93, 0xd1);
-    const xColor LOAD_SUCCESS_COLOR(0x1f, 0xc6, 0xa6);
-    const xColor LOAD_FAILURE_COLOR(0xc6, 0x21, 0x47);
+    const glm::u8vec3 NO_MODEL_COLOR(0xe3, 0xe3, 0xe3);
+    const glm::u8vec3 LOAD_MODEL_COLOR(0xef, 0x93, 0xd1);
+    const glm::u8vec3 LOAD_SUCCESS_COLOR(0x1f, 0xc6, 0xa6);
+    const glm::u8vec3 LOAD_FAILURE_COLOR(0xc6, 0x21, 0x47);
     switch (loadingStatus) {
     case Avatar::LoadingStatus::NoModel:
         return NO_MODEL_COLOR;

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(xColorFromVariant(pathMap["color"], valid));
+                color = toGlm(u8vec3FromVariant(pathMap["color"]));
             }
             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(xColorFromVariant(pathMap["color"], valid));
+            color = toGlm(u8vec3FromVariant(pathMap["color"]));
         }
 
         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 = xColorFromVariant(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 = xColorFromVariant(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 = xColorFromVariant(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 = xColorFromVariant(colorVariant, isValid);
+        auto color = u8vec3FromVariant(colorVariant, isValid);
         if (isValid) {
             _style._fillOccluded.color = toGlm(color);
         }
@@ -497,10 +497,11 @@ bool SelectionHighlightStyle::fromVariantMap(const QVariantMap& properties) {
 QVariantMap SelectionHighlightStyle::toVariantMap() const {
     QVariantMap properties;
 
-    properties["outlineUnoccludedColor"] = xColorToVariant(xColorFromGlm(_style._outlineUnoccluded.color));
-    properties["outlineOccludedColor"] = xColorToVariant(xColorFromGlm(_style._outlineOccluded.color));
-    properties["fillUnoccludedColor"] = xColorToVariant(xColorFromGlm(_style._fillUnoccluded.color));
-    properties["fillOccludedColor"] = xColorToVariant(xColorFromGlm(_style._fillOccluded.color));
+    const float MAX_COLOR = 255.0f;
+    properties["outlineUnoccludedColor"] = u8vec3ColortoVariant(_style._outlineUnoccluded.color * MAX_COLOR);
+    properties["outlineOccludedColor"] = u8vec3ColortoVariant(_style._outlineOccluded.color * MAX_COLOR);
+    properties["fillUnoccludedColor"] = u8vec3ColortoVariant(_style._fillUnoccluded.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/Base3DOverlay.cpp

@@ -191,8 +191,6 @@ void Base3DOverlay::setProperties(const QVariantMap& originalProperties) {
 
     if (properties["parentID"].isValid()) {
         setParentID(QUuid(properties["parentID"].toString()));
-        bool success;
-        getParentPointer(success); // call this to hook-up the parent's back-pointers to its child overlays
         needRenderItemUpdate = true;
     }
     if (properties["parentJointIndex"].isValid()) {

interface/src/ui/overlays/Circle3DOverlay.cpp

@@ -75,7 +75,6 @@ void Circle3DOverlay::render(RenderArgs* args) {
     const float FULL_CIRCLE = 360.0f;
     const float SLICES = 180.0f;  // The amount of segment to create the circle
     const float SLICE_ANGLE_RADIANS = glm::radians(FULL_CIRCLE / SLICES);
-    const float MAX_COLOR = 255.0f;
 
     auto geometryCache = DependencyManager::get<GeometryCache>();
 
@@ -246,20 +245,15 @@ void Circle3DOverlay::render(RenderArgs* args) {
                     angle += tickMarkAngle;
                 }
             }
-            
-            xColor majorColorX = getMajorTickMarksColor();
-            glm::vec4 majorColor(majorColorX.red / MAX_COLOR, majorColorX.green / MAX_COLOR, majorColorX.blue / MAX_COLOR, alpha);
-            
+
+            glm::vec4 majorColor(toGlm(getMajorTickMarksColor()), alpha);
             geometryCache->updateVertices(_majorTicksVerticesID, majorPoints, majorColor);
-            
-            xColor minorColorX = getMinorTickMarksColor();
-            glm::vec4 minorColor(minorColorX.red / MAX_COLOR, minorColorX.green / MAX_COLOR, minorColorX.blue / MAX_COLOR, alpha);
-            
+            glm::vec4 minorColor(toGlm(getMinorTickMarksColor()), alpha);
             geometryCache->updateVertices(_minorTicksVerticesID, minorPoints, minorColor);
         }
-        
+
         geometryCache->renderVertices(batch, gpu::LINES, _majorTicksVerticesID);
-        
+
         geometryCache->renderVertices(batch, gpu::LINES, _minorTicksVerticesID);
     }
 }
@@ -280,8 +274,8 @@ template<typename T> T fromVariant(const QVariant& v, bool& valid) {
     return qvariant_cast<T>(v);
 }
 
-template<> xColor fromVariant(const QVariant& v, bool& valid) {
-    return xColorFromVariant(v, valid);
+template<> glm::u8vec3 fromVariant(const QVariant& v, bool& valid) {
+    return u8vec3FromVariant(v, valid);
 }
 
 template<typename T>
@@ -344,11 +338,11 @@ void Circle3DOverlay::setProperties(const QVariantMap& properties) {
     _dirty |= updateIfValid(properties, "outerStartAlpha", _outerStartAlpha);
     _dirty |= updateIfValid(properties, "outerEndAlpha", _outerEndAlpha);
 
-    _dirty |= updateIfValid<xColor>(properties, "color", { _innerStartColor, _innerEndColor, _outerStartColor, _outerEndColor });
-    _dirty |= updateIfValid<xColor>(properties, "startColor", { _innerStartColor, _outerStartColor } );
-    _dirty |= updateIfValid<xColor>(properties, "endColor", { _innerEndColor, _outerEndColor } );
-    _dirty |= updateIfValid<xColor>(properties, "innerColor", { _innerStartColor, _innerEndColor } );
-    _dirty |= updateIfValid<xColor>(properties, "outerColor", { _outerStartColor, _outerEndColor } );
+    _dirty |= updateIfValid<glm::u8vec3>(properties, "color", { _innerStartColor, _innerEndColor, _outerStartColor, _outerEndColor });
+    _dirty |= updateIfValid<glm::u8vec3>(properties, "startColor", { _innerStartColor, _outerStartColor } );
+    _dirty |= updateIfValid<glm::u8vec3>(properties, "endColor", { _innerEndColor, _outerEndColor } );
+    _dirty |= updateIfValid<glm::u8vec3>(properties, "innerColor", { _innerStartColor, _innerEndColor } );
+    _dirty |= updateIfValid<glm::u8vec3>(properties, "outerColor", { _outerStartColor, _outerEndColor } );
     _dirty |= updateIfValid(properties, "innerStartColor", _innerStartColor);
     _dirty |= updateIfValid(properties, "innerEndColor", _innerEndColor);
     _dirty |= updateIfValid(properties, "outerStartColor", _outerStartColor);
@@ -421,7 +415,7 @@ void Circle3DOverlay::setProperties(const QVariantMap& properties) {
  * @property {number} endAt=360 - The counter-clockwise angle from the overlay's x-axis that drawing ends at, in degrees.
  * @property {number} outerRadius=1 - The outer radius of the overlay, in meters. Synonym: <code>radius</code>.
  * @property {number} innerRadius=0 - The inner radius of the overlay, in meters.
-  * @property {Color} color=255,255,255 - The color of the overlay. Setting this value also sets the values of 
+  * @property {Color} color=255,255,255 - The color of the overlay. Setting this value also sets the values of
  *     <code>innerStartColor</code>, <code>innerEndColor</code>, <code>outerStartColor</code>, and <code>outerEndColor</code>.
  * @property {Color} startColor - Sets the values of <code>innerStartColor</code> and <code>outerStartColor</code>.
  *     <em>Write-only.</em>
@@ -478,16 +472,16 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
         return _innerRadius;
     }
     if (property == "innerStartColor") {
-        return xColorToVariant(_innerStartColor);
+        return u8vec3ColortoVariant(_innerStartColor);
     }
     if (property == "innerEndColor") {
-        return xColorToVariant(_innerEndColor);
+        return u8vec3ColortoVariant(_innerEndColor);
     }
     if (property == "outerStartColor") {
-        return xColorToVariant(_outerStartColor);
+        return u8vec3ColortoVariant(_outerStartColor);
     }
     if (property == "outerEndColor") {
-        return xColorToVariant(_outerEndColor);
+        return u8vec3ColortoVariant(_outerEndColor);
     }
     if (property == "innerStartAlpha") {
         return _innerStartAlpha;
@@ -517,10 +511,10 @@ QVariant Circle3DOverlay::getProperty(const QString& property) {
         return _minorTickMarksLength;
     }
     if (property == "majorTickMarksColor") {
-        return xColorToVariant(_majorTickMarksColor);
+        return u8vec3ColortoVariant(_majorTickMarksColor);
     }
     if (property == "minorTickMarksColor") {
-        return xColorToVariant(_minorTickMarksColor);
+        return u8vec3ColortoVariant(_minorTickMarksColor);
     }
 
     return Planar3DOverlay::getProperty(property);

interface/src/ui/overlays/Circle3DOverlay.h

@@ -39,8 +39,8 @@ public:
     float getMinorTickMarksAngle() const { return _minorTickMarksAngle; }
     float getMajorTickMarksLength() const { return _majorTickMarksLength; }
     float getMinorTickMarksLength() const { return _minorTickMarksLength; }
-    xColor getMajorTickMarksColor() const { return _majorTickMarksColor; }
-    xColor getMinorTickMarksColor() const { return _minorTickMarksColor; }
+    glm::u8vec3 getMajorTickMarksColor() const { return _majorTickMarksColor; }
+    glm::u8vec3 getMinorTickMarksColor() const { return _minorTickMarksColor; }
     
     void setStartAt(float value) { _startAt = value; }
     void setEndAt(float value) { _endAt = value; }
@@ -51,8 +51,8 @@ public:
     void setMinorTickMarksAngle(float value) { _minorTickMarksAngle = value; }
     void setMajorTickMarksLength(float value) { _majorTickMarksLength = value; }
     void setMinorTickMarksLength(float value) { _minorTickMarksLength = value; }
-    void setMajorTickMarksColor(const xColor& value) { _majorTickMarksColor = value; }
-    void setMinorTickMarksColor(const xColor& value) { _minorTickMarksColor = value; }
+    void setMajorTickMarksColor(const glm::u8vec3& value) { _majorTickMarksColor = value; }
+    void setMinorTickMarksColor(const glm::u8vec3& value) { _minorTickMarksColor = value; }
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance,
                                      BoxFace& face, glm::vec3& surfaceNormal, bool precisionPicking = false) override;
@@ -67,10 +67,10 @@ protected:
     float _outerRadius { 1 };
     float _innerRadius { 0 };
 
-    xColor _innerStartColor { DEFAULT_OVERLAY_COLOR };
-    xColor _innerEndColor { DEFAULT_OVERLAY_COLOR };
-    xColor _outerStartColor { DEFAULT_OVERLAY_COLOR };
-    xColor _outerEndColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _innerStartColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _innerEndColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _outerStartColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _outerEndColor { DEFAULT_OVERLAY_COLOR };
     float _innerStartAlpha { DEFAULT_ALPHA };
     float _innerEndAlpha { DEFAULT_ALPHA };
     float _outerStartAlpha { DEFAULT_ALPHA };
@@ -81,8 +81,8 @@ protected:
     float _minorTickMarksAngle { 0 };
     float _majorTickMarksLength { 0 };
     float _minorTickMarksLength { 0 };
-    xColor _majorTickMarksColor { DEFAULT_OVERLAY_COLOR };
-    xColor _minorTickMarksColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _majorTickMarksColor { DEFAULT_OVERLAY_COLOR };
+    glm::u8vec3 _minorTickMarksColor { DEFAULT_OVERLAY_COLOR };
     gpu::Primitive _solidPrimitive { gpu::TRIANGLE_FAN };
     int _quadVerticesID { 0 };
     int _lineVerticesID { 0 };

interface/src/ui/overlays/ContextOverlayInterface.cpp

@@ -83,7 +83,7 @@ ContextOverlayInterface::ContextOverlayInterface() {
     _challengeOwnershipTimeoutTimer.setSingleShot(true);
 }
 
-static const xColor CONTEXT_OVERLAY_COLOR = { 255, 255, 255 };
+static const glm::u8vec3 CONTEXT_OVERLAY_COLOR = { 255, 255, 255 };
 static const float CONTEXT_OVERLAY_INSIDE_DISTANCE = 1.0f; // in meters
 static const float CONTEXT_OVERLAY_SIZE = 0.09f; // in meters, same x and y dims
 static const float CONTEXT_OVERLAY_OFFSET_DISTANCE = 0.1f;
@@ -142,14 +142,15 @@ bool ContextOverlayInterface::createOrDestroyContextOverlay(const EntityItemID&
             glm::vec3 cameraPosition = qApp->getCamera().getPosition();
             glm::vec3 entityDimensions = entityProperties.getDimensions();
             glm::vec3 entityPosition = entityProperties.getPosition();
+            glm::vec3 registrationPoint = entityProperties.getRegistrationPoint();
             glm::vec3 contextOverlayPosition = entityProperties.getPosition();
             glm::vec2 contextOverlayDimensions;
 
             // Update the position of the overlay if the registration point of the entity
             // isn't default
-            if (entityProperties.getRegistrationPoint() != glm::vec3(0.5f)) {
-                glm::vec3 adjustPos = entityProperties.getRegistrationPoint() - glm::vec3(0.5f);
-                entityPosition = entityPosition - (entityProperties.getRotation() * (adjustPos * entityProperties.getDimensions()));
+            if (registrationPoint != glm::vec3(0.5f)) {
+                glm::vec3 adjustPos = registrationPoint - glm::vec3(0.5f);
+                entityPosition = entityPosition - (entityProperties.getRotation() * (adjustPos * entityDimensions));
             }
 
             enableEntityHighlight(entityItemID);

interface/src/ui/overlays/Cube3DOverlay.cpp

@@ -49,11 +49,8 @@ void Cube3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 cubeColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
-
-
+    glm::u8vec3 color = getColor();
+    glm::vec4 cubeColor(toGlm(color), alpha);
 
     auto batch = args->_batch;
     if (batch) {

interface/src/ui/overlays/Grid3DOverlay.cpp

@@ -57,11 +57,9 @@ void Grid3DOverlay::render(RenderArgs* args) {
         return; // do nothing if we're not visible
     }
 
-    const float MAX_COLOR = 255.0f;
-
     float alpha = getAlpha();
-    xColor color = getColor();
-    glm::vec4 gridColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+    glm::u8vec3 color = getColor();
+    glm::vec4 gridColor(toGlm(color), alpha);
 
     auto batch = args->_batch;
 

interface/src/ui/overlays/Image3DOverlay.cpp

@@ -107,17 +107,16 @@ void Image3DOverlay::render(RenderArgs* args) {
     glm::vec2 texCoordBottomRight((fromImage.x() + fromImage.width() - 0.5f) / imageWidth,
                                   (fromImage.y() + fromImage.height() - 0.5f) / imageHeight);
 
-    const float MAX_COLOR = 255.0f;
-    xColor color = getColor();
     float alpha = getAlpha();
+    glm::u8vec3 color = getColor();
+    glm::vec4 imageColor(toGlm(color), alpha);
 
     batch->setModelTransform(getRenderTransform());
     batch->setResourceTexture(0, _texture->getGPUTexture());
 
     DependencyManager::get<GeometryCache>()->renderQuad(
         *batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
-        glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha),
-        _geometryId
+        imageColor, _geometryId
     );
 
     batch->setResourceTexture(0, nullptr); // restore default white color after me

interface/src/ui/overlays/Line3DOverlay.cpp

@@ -128,9 +128,8 @@ void Line3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 colorv4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+    glm::u8vec3 color = getColor();
+    glm::vec4 colorv4(toGlm(color), alpha);
     auto batch = args->_batch;
     if (batch) {
         batch->setModelTransform(Transform());

interface/src/ui/overlays/Overlay.cpp

@@ -15,7 +15,7 @@
 
 #include "Application.h"
 
-const xColor Overlay::DEFAULT_OVERLAY_COLOR = { 255, 255, 255 };
+const glm::u8vec3 Overlay::DEFAULT_OVERLAY_COLOR = { 255, 255, 255 };
 const float Overlay::DEFAULT_ALPHA = 0.7f;
 
 Overlay::Overlay() :
@@ -57,7 +57,7 @@ Overlay::~Overlay() {
 
 void Overlay::setProperties(const QVariantMap& properties) {
     bool valid;
-    auto color = xColorFromVariant(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 xColorToVariant(_color);
+        return u8vec3ColortoVariant(_color);
     }
     if (property == "alpha") {
         return _alpha;
@@ -143,21 +143,21 @@ QVariant Overlay::getProperty(const QString& property) {
     return QVariant();
 }
 
-xColor Overlay::getColor() { 
+glm::u8vec3 Overlay::getColor() {
     if (_colorPulse == 0.0f) {
         return _color; 
     }
 
     float pulseLevel = updatePulse();
-    xColor result = _color;
+    glm::u8vec3 result = _color;
     if (_colorPulse < 0.0f) {
-        result.red *= (1.0f - pulseLevel);
-        result.green *= (1.0f - pulseLevel);
-        result.blue *= (1.0f - pulseLevel);
+        result.x *= (1.0f - pulseLevel);
+        result.y *= (1.0f - pulseLevel);
+        result.z *= (1.0f - pulseLevel);
     } else {
-        result.red *= pulseLevel;
-        result.green *= pulseLevel;
-        result.blue *= pulseLevel;
+        result.x *= pulseLevel;
+        result.y *= pulseLevel;
+        result.z *= pulseLevel;
     }
     return result;
 }

interface/src/ui/overlays/Overlay.h

@@ -11,8 +11,6 @@
 #ifndef hifi_Overlay_h
 #define hifi_Overlay_h
 
-// include this before QGLWidget, which includes an earlier version of OpenGL
-#include <SharedUtil.h> // for xColor
 #include <render/Scene.h>
 
 class OverlayID : public QUuid {
@@ -59,7 +57,7 @@ public:
     virtual bool isTransparent() { return getAlphaPulse() != 0.0f || getAlpha() != 1.0f; };
     virtual bool getIsVisibleInSecondaryCamera() const { return false; }
 
-    xColor getColor();
+    glm::u8vec3 getColor();
     float getAlpha();
 
     float getPulseMax() const { return _pulseMax; }
@@ -73,7 +71,7 @@ public:
     // setters
     virtual void setVisible(bool visible) { _visible = visible; }
     void setDrawHUDLayer(bool drawHUDLayer);
-    void setColor(const xColor& color) { _color = color; }
+    void setColor(const glm::u8vec3& color) { _color = color; }
     void setAlpha(float alpha) { _alpha = alpha; }
 
     void setPulseMax(float value) { _pulseMax = value; }
@@ -115,12 +113,12 @@ protected:
     float _alphaPulse; // ratio of the pulse to the alpha
     float _colorPulse; // ratio of the pulse to the color
 
-    xColor _color;
+    glm::u8vec3 _color;
     bool _visible; // should the overlay be drawn at all
 
     unsigned int _stackOrder { 0 };
 
-    static const xColor DEFAULT_OVERLAY_COLOR;
+    static const glm::u8vec3 DEFAULT_OVERLAY_COLOR;
     static const float DEFAULT_ALPHA;
 
     std::unordered_map<std::string, graphics::MultiMaterial> _materials;

interface/src/ui/overlays/Overlays.cpp

@@ -532,6 +532,8 @@ RayToOverlayIntersectionResult Overlays::findRayIntersectionVector(const PickRay
                                                                    bool visibleOnly, bool collidableOnly) {
     float bestDistance = std::numeric_limits<float>::max();
     bool bestIsFront = false;
+    bool bestIsTablet = false;
+    auto tabletIDs = qApp->getTabletIDs();
 
     QMutexLocker locker(&_mutex);
     RayToOverlayIntersectionResult result;
@@ -554,10 +556,11 @@ RayToOverlayIntersectionResult Overlays::findRayIntersectionVector(const PickRay
             if (thisOverlay->findRayIntersectionExtraInfo(ray.origin, ray.direction, thisDistance,
                                                           thisFace, thisSurfaceNormal, thisExtraInfo, precisionPicking)) {
                 bool isDrawInFront = thisOverlay->getDrawInFront();
-                if ((bestIsFront && isDrawInFront && thisDistance < bestDistance)
-                    || (!bestIsFront && (isDrawInFront || thisDistance < bestDistance))) {
-
+                bool isTablet = tabletIDs.contains(thisID);
+                if ((isDrawInFront && !bestIsFront && !bestIsTablet)
+                        || ((isTablet || isDrawInFront || !bestIsFront) && thisDistance < bestDistance)) {
                     bestIsFront = isDrawInFront;
+                    bestIsTablet = isTablet;
                     bestDistance = thisDistance;
                     result.intersects = true;
                     result.distance = thisDistance;
@@ -629,9 +632,9 @@ QScriptValue RayToOverlayIntersectionResultToScriptValue(QScriptEngine* engine,
     obj.setProperty("distance", value.distance);
     obj.setProperty("face", boxFaceToString(value.face));
 
-    QScriptValue intersection = vec3toScriptValue(engine, value.intersection);
+    QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
     obj.setProperty("intersection", intersection);
-    QScriptValue surfaceNormal = vec3toScriptValue(engine, value.surfaceNormal);
+    QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
     obj.setProperty("surfaceNormal", surfaceNormal);
     obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
     return obj;
@@ -828,40 +831,12 @@ PointerEvent Overlays::calculateOverlayPointerEvent(OverlayID overlayID, PickRay
 }
 
 
-RayToOverlayIntersectionResult Overlays::findRayIntersectionForMouseEvent(PickRay ray) {
-    QVector<OverlayID> overlaysToInclude;
-    QVector<OverlayID> overlaysToDiscard;
-    RayToOverlayIntersectionResult rayPickResult;
-
-    // first priority is tablet screen
-    overlaysToInclude << qApp->getTabletScreenID();
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then tablet home button
-    overlaysToInclude.clear();
-    overlaysToInclude << qApp->getTabletHomeButtonID();
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then tablet frame
-    overlaysToInclude.clear();
-    overlaysToInclude << OverlayID(qApp->getTabletFrameID());
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then whatever
-    return findRayIntersection(ray);
-}
-
 bool Overlays::mousePressEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mousePressEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         _currentClickingOnOverlayID = rayPickResult.overlayID;
 
@@ -901,7 +876,8 @@ bool Overlays::mouseDoublePressEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseDoublePressEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         _currentClickingOnOverlayID = rayPickResult.overlayID;
 
@@ -964,7 +940,8 @@ bool Overlays::mouseReleaseEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseReleaseEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         auto pointerEvent = calculateOverlayPointerEvent(rayPickResult.overlayID, ray, rayPickResult, event, PointerEvent::Release);
         mouseReleasePointerEvent(rayPickResult.overlayID, pointerEvent);
@@ -993,7 +970,8 @@ bool Overlays::mouseMoveEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseMoveEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         auto pointerEvent = calculateOverlayPointerEvent(rayPickResult.overlayID, ray, rayPickResult, event, PointerEvent::Move);
         mouseMovePointerEvent(rayPickResult.overlayID, pointerEvent);

interface/src/ui/overlays/Overlays.h

@@ -44,8 +44,7 @@ void OverlayPropertyResultFromScriptValue(const QScriptValue& object, OverlayPro
 const OverlayID UNKNOWN_OVERLAY_ID = OverlayID();
 
 /**jsdoc
- * The result of a {@link PickRay} search using {@link Overlays.findRayIntersection|findRayIntersection} or 
- * {@link Overlays.findRayIntersectionVector|findRayIntersectionVector}.
+ * The result of a {@link PickRay} search using {@link Overlays.findRayIntersection|findRayIntersection}.
  * @typedef {object} Overlays.RayToOverlayIntersectionResult
  * @property {boolean} intersects - <code>true</code> if the {@link PickRay} intersected with a 3D overlay, otherwise
  *     <code>false</code>.
@@ -383,7 +382,11 @@ public slots:
     OverlayPropertyResult getOverlaysProperties(const QVariant& overlaysProperties);
 
     /**jsdoc
-     * Find the closest 3D overlay intersected by a {@link PickRay}.
+     *  Find the closest 3D overlay intersected by a {@link PickRay}. Overlays with their <code>drawInFront</code> property set  
+     * to <code>true</code> have priority over overlays that don't, except that tablet overlays have priority over any  
+     * <code>drawInFront</code> overlays behind them. I.e., if a <code>drawInFront</code> overlay is behind one that isn't  
+     * <code>drawInFront</code>, the <code>drawInFront</code> overlay is returned, but if a tablet overlay is in front of a  
+     * <code>drawInFront</code> overlay, the tablet overlay is returned.
      * @function Overlays.findRayIntersection
      * @param {PickRay} pickRay - The PickRay to use for finding overlays.
      * @param {boolean} [precisionPicking=false] - <em>Unused</em>; exists to match Entity API.
@@ -750,8 +753,6 @@ private:
     OverlayID _currentClickingOnOverlayID { UNKNOWN_OVERLAY_ID };
     OverlayID _currentHoverOverOverlayID { UNKNOWN_OVERLAY_ID };
 
-    RayToOverlayIntersectionResult findRayIntersectionForMouseEvent(PickRay ray);
-
 private slots:
     void mousePressPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
     void mouseMovePointerEvent(const OverlayID& overlayID, const PointerEvent& event);

interface/src/ui/overlays/Planar3DOverlay.cpp

@@ -64,7 +64,7 @@ void Planar3DOverlay::setProperties(const QVariantMap& properties) {
  */
 QVariant Planar3DOverlay::getProperty(const QString& property) {
     if (property == "dimensions" || property == "scale" || property == "size") {
-        return vec2toVariant(getDimensions());
+        return vec2ToVariant(getDimensions());
     }
 
     return Base3DOverlay::getProperty(property);

interface/src/ui/overlays/Rectangle3DOverlay.cpp

@@ -51,9 +51,8 @@ void Rectangle3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 rectangleColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+    glm::u8vec3 color = getColor();
+    glm::vec4 rectangleColor(toGlm(color), alpha);
 
     auto batch = args->_batch;
     if (batch) {

interface/src/ui/overlays/Shape3DOverlay.cpp

@@ -30,9 +30,8 @@ void Shape3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 cubeColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+    glm::u8vec3 color = getColor();
+    glm::vec4 shapeColor(toGlm(color), alpha);
 
     auto batch = args->_batch;
     if (batch) {
@@ -44,9 +43,9 @@ void Shape3DOverlay::render(RenderArgs* args) {
 
         batch->setModelTransform(getRenderTransform());
         if (_isSolid) {
-            geometryCache->renderSolidShapeInstance(args, *batch, _shape, cubeColor, shapePipeline);
+            geometryCache->renderSolidShapeInstance(args, *batch, _shape, shapeColor, shapePipeline);
         } else {
-            geometryCache->renderWireShapeInstance(args, *batch, _shape, cubeColor, shapePipeline);
+            geometryCache->renderWireShapeInstance(args, *batch, _shape, shapeColor, shapePipeline);
         }
     }
 }

interface/src/ui/overlays/Sphere3DOverlay.cpp

@@ -77,9 +77,8 @@ void Sphere3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 sphereColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+    glm::u8vec3 color = getColor();
+    glm::vec4 sphereColor(toGlm(color), alpha);
 
     auto batch = args->_batch;
 

interface/src/ui/overlays/Text3DOverlay.cpp

@@ -64,21 +64,21 @@ void Text3DOverlay::setText(const QString& text) {
     _text = text;
 }
 
-xColor Text3DOverlay::getBackgroundColor() {
+glm::u8vec3 Text3DOverlay::getBackgroundColor() {
     if (_colorPulse == 0.0f) {
         return _backgroundColor;
     }
 
     float pulseLevel = updatePulse();
-    xColor result = _backgroundColor;
+    glm::u8vec3 result = _backgroundColor;
     if (_colorPulse < 0.0f) {
-        result.red *= (1.0f - pulseLevel);
-        result.green *= (1.0f - pulseLevel);
-        result.blue *= (1.0f - pulseLevel);
+        result.x *= (1.0f - pulseLevel);
+        result.y *= (1.0f - pulseLevel);
+        result.z *= (1.0f - pulseLevel);
     } else {
-        result.red *= pulseLevel;
-        result.green *= pulseLevel;
-        result.blue *= pulseLevel;
+        result.x *= pulseLevel;
+        result.y *= pulseLevel;
+        result.z *= pulseLevel;
     }
     return result;
 }
@@ -94,10 +94,8 @@ void Text3DOverlay::render(RenderArgs* args) {
     auto transform = getRenderTransform();
     batch.setModelTransform(transform);
 
-    const float MAX_COLOR = 255.0f;
-    xColor backgroundColor = getBackgroundColor();
-    glm::vec4 quadColor(backgroundColor.red / MAX_COLOR, backgroundColor.green / MAX_COLOR,
-                        backgroundColor.blue / MAX_COLOR, getBackgroundAlpha());
+    glm::u8vec3 backgroundColor = getBackgroundColor();
+    glm::vec4 quadColor(toGlm(backgroundColor), getBackgroundAlpha());
 
     glm::vec2 dimensions = getDimensions();
     glm::vec2 halfDimensions = dimensions * 0.5f;
@@ -122,8 +120,7 @@ void Text3DOverlay::render(RenderArgs* args) {
     transform.setScale(scaleFactor);
     batch.setModelTransform(transform);
 
-    glm::vec4 textColor = { _color.red / MAX_COLOR, _color.green / MAX_COLOR,
-                            _color.blue / MAX_COLOR, getTextAlpha() };
+    glm::vec4 textColor = { toGlm(_color), getTextAlpha() };
 
     // FIXME: Factor out textRenderer so that Text3DOverlay overlay parts can be grouped by pipeline for a gpu performance increase.
     _textRenderer->draw(batch, 0, 0, getText(), textColor, glm::vec2(-1.0f), true);
@@ -164,7 +161,7 @@ void Text3DOverlay::setProperties(const QVariantMap& properties) {
     bool valid;
     auto backgroundColor = properties["backgroundColor"];
     if (backgroundColor.isValid()) {
-        auto color = xColorFromVariant(backgroundColor, valid);
+        auto color = u8vec3FromVariant(backgroundColor, valid);
         if (valid) {
             _backgroundColor = color;
         }
@@ -260,7 +257,7 @@ QVariant Text3DOverlay::getProperty(const QString& property) {
         return _textAlpha;
     }
     if (property == "backgroundColor") {
-        return xColorToVariant(_backgroundColor);
+        return u8vec3ColortoVariant(_backgroundColor);
     }
     if (property == "backgroundAlpha") {
         return Billboard3DOverlay::getProperty("alpha");

interface/src/ui/overlays/Text3DOverlay.h

@@ -39,7 +39,7 @@ public:
     float getTopMargin() const { return _topMargin; }
     float getRightMargin() const { return _rightMargin; }
     float getBottomMargin() const { return _bottomMargin; }
-    xColor getBackgroundColor();
+    glm::u8vec3 getBackgroundColor();
     float getTextAlpha() { return _textAlpha; }
     float getBackgroundAlpha() { return getAlpha(); }
     bool isTransparent() override { return Overlay::isTransparent() || _textAlpha < 1.0f; }
@@ -65,7 +65,7 @@ private:
 
     QString _text;
     mutable QMutex _mutex; // used to make get/setText threadsafe, mutable so can be used in const functions
-    xColor _backgroundColor = xColor { 0, 0, 0 };
+    glm::u8vec3 _backgroundColor { 0, 0, 0 };
     float _textAlpha { 1.0f };
     float _lineHeight { 1.0f };
     float _leftMargin { 0.1f };

libraries/animation/src/AnimVariant.cpp

@@ -40,7 +40,7 @@ QScriptValue AnimVariantMap::animVariantMapToScriptValue(QScriptEngine* engine,
                 target.setProperty(name, value.getString());
                 break;
             case AnimVariant::Type::Vec3:
-                target.setProperty(name, vec3toScriptValue(engine, value.getVec3()));
+                target.setProperty(name, vec3ToScriptValue(engine, value.getVec3()));
                 break;
             case AnimVariant::Type::Quat:
                 target.setProperty(name, quatToScriptValue(engine, value.getQuat()));

libraries/animation/src/Rig.cpp

@@ -1253,7 +1253,6 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
                       const glm::mat4& rigToSensorMatrix, const glm::mat4& sensorToRigMatrix) {
 
     const bool ENABLE_POLE_VECTORS = true;
-    const float ELBOW_POLE_VECTOR_BLEND_FACTOR = 0.95f;
 
     if (leftHandEnabled) {
 
@@ -1279,33 +1278,16 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
             bool usePoleVector = calculateElbowPoleVector(handJointIndex, elbowJointIndex, armJointIndex, oppositeArmJointIndex, poleVector);
             if (usePoleVector) {
                 glm::vec3 sensorPoleVector = transformVectorFast(rigToSensorMatrix, poleVector);
-
-                if (_smoothPoleVectors) {
-                    // smooth toward desired pole vector from previous pole vector...  to reduce jitter
-                    if (!_prevLeftHandPoleVectorValid) {
-                        _prevLeftHandPoleVectorValid = true;
-                        _prevLeftHandPoleVector = sensorPoleVector;
-                    }
-                    glm::quat deltaRot = rotationBetween(_prevLeftHandPoleVector, sensorPoleVector);
-                    glm::quat smoothDeltaRot = safeMix(deltaRot, Quaternions::IDENTITY, ELBOW_POLE_VECTOR_BLEND_FACTOR);
-                    _prevLeftHandPoleVector = smoothDeltaRot * _prevLeftHandPoleVector;
-                } else {
-                    _prevLeftHandPoleVector = sensorPoleVector;
-                }
                 _animVars.set("leftHandPoleVectorEnabled", true);
                 _animVars.set("leftHandPoleReferenceVector", Vectors::UNIT_X);
-                _animVars.set("leftHandPoleVector", transformVectorFast(sensorToRigMatrix, _prevLeftHandPoleVector));
+                _animVars.set("leftHandPoleVector", transformVectorFast(sensorToRigMatrix, sensorPoleVector));
             } else {
-                _prevLeftHandPoleVectorValid = false;
                 _animVars.set("leftHandPoleVectorEnabled", false);
             }
-
         } else {
-            _prevLeftHandPoleVectorValid = false;
             _animVars.set("leftHandPoleVectorEnabled", false);
         }
     } else {
-        _prevLeftHandPoleVectorValid = false;
         _animVars.set("leftHandPoleVectorEnabled", false);
 
         _animVars.unset("leftHandPosition");
@@ -1344,33 +1326,16 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
             bool usePoleVector = calculateElbowPoleVector(handJointIndex, elbowJointIndex, armJointIndex, oppositeArmJointIndex, poleVector);
             if (usePoleVector) {
                 glm::vec3 sensorPoleVector = transformVectorFast(rigToSensorMatrix, poleVector);
-
-                if (_smoothPoleVectors) {
-                    // smooth toward desired pole vector from previous pole vector...  to reduce jitter
-                    if (!_prevRightHandPoleVectorValid) {
-                        _prevRightHandPoleVectorValid = true;
-                        _prevRightHandPoleVector = sensorPoleVector;
-                    }
-                    glm::quat deltaRot = rotationBetween(_prevRightHandPoleVector, sensorPoleVector);
-                    glm::quat smoothDeltaRot = safeMix(deltaRot, Quaternions::IDENTITY, ELBOW_POLE_VECTOR_BLEND_FACTOR);
-                    _prevRightHandPoleVector = smoothDeltaRot * _prevRightHandPoleVector;
-                } else {
-                    _prevRightHandPoleVector = sensorPoleVector;
-                }
-
                 _animVars.set("rightHandPoleVectorEnabled", true);
                 _animVars.set("rightHandPoleReferenceVector", -Vectors::UNIT_X);
-                _animVars.set("rightHandPoleVector", transformVectorFast(sensorToRigMatrix, _prevRightHandPoleVector));
+                _animVars.set("rightHandPoleVector", transformVectorFast(sensorToRigMatrix, sensorPoleVector));
             } else {
-                _prevRightHandPoleVectorValid = false;
                 _animVars.set("rightHandPoleVectorEnabled", false);
             }
         } else {
-            _prevRightHandPoleVectorValid = false;
             _animVars.set("rightHandPoleVectorEnabled", false);
         }
     } else {
-        _prevRightHandPoleVectorValid = false;
         _animVars.set("rightHandPoleVectorEnabled", false);
 
         _animVars.unset("rightHandPosition");

libraries/animation/src/Rig.h

@@ -227,7 +227,6 @@ public:
     const AnimVariantMap& getAnimVars() const { return _lastAnimVars; }
     const AnimContext::DebugStateMachineMap& getStateMachineMap() const { return _lastContext.getStateMachineMap(); }
 
-    void toggleSmoothPoleVectors() { _smoothPoleVectors = !_smoothPoleVectors; };
 signals:
     void onLoadComplete();
 
@@ -381,14 +380,6 @@ protected:
     glm::vec3 _prevLeftFootPoleVector { Vectors::UNIT_Z }; // sensor space
     bool _prevLeftFootPoleVectorValid { false };
 
-    glm::vec3 _prevRightHandPoleVector{ -Vectors::UNIT_Z }; // sensor space
-    bool _prevRightHandPoleVectorValid{ false };
-
-    glm::vec3 _prevLeftHandPoleVector{ -Vectors::UNIT_Z }; // sensor space
-    bool _prevLeftHandPoleVectorValid{ false };
-
-    bool _smoothPoleVectors { false };
-
     int _rigId;
     bool _headEnabled { false };
 

libraries/audio/src/AudioInjectorOptions.cpp

@@ -34,7 +34,7 @@ AudioInjectorOptions::AudioInjectorOptions() :
 
 QScriptValue injectorOptionsToScriptValue(QScriptEngine* engine, const AudioInjectorOptions& injectorOptions) {
     QScriptValue obj = engine->newObject();
-    obj.setProperty("position", vec3toScriptValue(engine, injectorOptions.position));
+    obj.setProperty("position", vec3ToScriptValue(engine, injectorOptions.position));
     obj.setProperty("volume", injectorOptions.volume);
     obj.setProperty("loop", injectorOptions.loop);
     obj.setProperty("orientation", quatToScriptValue(engine, injectorOptions.orientation));

libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp

@@ -173,7 +173,6 @@ AvatarTransit::Status AvatarTransit::updatePosition(float deltaTime) {
     Status status = Status::IDLE;
     if (_isTransiting) {
         float nextTime = _currentTime + deltaTime;
-        glm::vec3 newPosition;
         if (nextTime >= _totalTime) {
             _currentPosition = _endPosition;
             _isTransiting = false;
@@ -704,6 +703,19 @@ static TextRenderer3D* textRenderer(TextRendererType type) {
     return displayNameRenderer;
 }
 
+void Avatar::metaBlendshapeOperator(int blendshapeNumber, const QVector<BlendshapeOffset>& blendshapeOffsets, const QVector<int>& blendedMeshSizes,
+                                    const render::ItemIDs& subItemIDs) {
+    render::Transaction transaction;
+    transaction.updateItem<AvatarData>(_renderItemID, [blendshapeNumber, blendshapeOffsets, blendedMeshSizes,
+                                                       subItemIDs](AvatarData& avatar) {
+        auto avatarPtr = dynamic_cast<Avatar*>(&avatar);
+        if (avatarPtr) {
+            avatarPtr->setBlendedVertices(blendshapeNumber, blendshapeOffsets, blendedMeshSizes, subItemIDs);
+        }
+    });
+    AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
+}
+
 void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
     auto avatarPayload = new render::Payload<AvatarData>(self);
     auto avatarPayloadPointer = std::shared_ptr<render::Payload<AvatarData>>(avatarPayload);
@@ -713,7 +725,8 @@ void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& sc
     // INitialize the _render bound as we are creating the avatar render item
     _renderBound = getBounds();
     transaction.resetItem(_renderItemID, avatarPayloadPointer);
-    _skeletonModel->addToScene(scene, transaction);
+    using namespace std::placeholders;
+    _skeletonModel->addToScene(scene, transaction, std::bind(&Avatar::metaBlendshapeOperator, this, _1, _2, _3, _4));
     _skeletonModel->setTagMask(render::hifi::TAG_ALL_VIEWS);
     _skeletonModel->setGroupCulled(true);
     _skeletonModel->setCanCastShadow(true);
@@ -792,7 +805,7 @@ void Avatar::updateRenderItem(render::Transaction& transaction) {
                     avatarPtr->_renderBound = renderBound;
                 }
             }
-      );
+        );
     }
 }
 
@@ -936,7 +949,8 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
     render::Transaction transaction;
     if (_skeletonModel->isRenderable() && _skeletonModel->needsFixupInScene()) {
         _skeletonModel->removeFromScene(scene, transaction);
-        _skeletonModel->addToScene(scene, transaction);
+        using namespace std::placeholders;
+        _skeletonModel->addToScene(scene, transaction, std::bind(&Avatar::metaBlendshapeOperator, this, _1, _2, _3, _4));
 
         _skeletonModel->setTagMask(render::hifi::TAG_ALL_VIEWS);
         _skeletonModel->setGroupCulled(true);

libraries/avatars-renderer/src/avatars-renderer/Avatar.h

@@ -28,6 +28,8 @@
 #include "Rig.h"
 #include <ThreadSafeValueCache.h>
 
+#include "MetaModelPayload.h"
+
 namespace render {
     template <> const ItemKey payloadGetKey(const AvatarSharedPointer& avatar);
     template <> const Item::Bound payloadGetBound(const AvatarSharedPointer& avatar);
@@ -108,7 +110,7 @@ private:
     float _scale { 1.0f };
 };
 
-class Avatar : public AvatarData, public scriptable::ModelProvider {
+class Avatar : public AvatarData, public scriptable::ModelProvider, public MetaModelPayload {
     Q_OBJECT
 
     // This property has JSDoc in MyAvatar.h.
@@ -620,6 +622,9 @@ protected:
     static const float ATTACHMENT_LOADING_PRIORITY;
 
     LoadingStatus _loadingStatus { LoadingStatus::NoModel };
+
+    void metaBlendshapeOperator(int blendshapeNumber, const QVector<BlendshapeOffset>& blendshapeOffsets, const QVector<int>& blendedMeshSizes,
+                                const render::ItemIDs& subItemIDs);
 };
 
 #endif // hifi_Avatar_h

libraries/avatars/src/AvatarData.cpp

@@ -75,8 +75,11 @@ size_t AvatarDataPacket::maxJointDataSize(size_t numJoints, bool hasGrabJoints)
     totalSize += numJoints * sizeof(SixByteTrans); // Translations
 
     size_t NUM_FAUX_JOINT = 2;
-    size_t num_grab_joints = (hasGrabJoints ? 2 : 0);
-    totalSize += (NUM_FAUX_JOINT + num_grab_joints) * (sizeof(SixByteQuat) + sizeof(SixByteTrans)); // faux joints
+    totalSize += NUM_FAUX_JOINT * (sizeof(SixByteQuat) + sizeof(SixByteTrans)); // faux joints
+
+    if (hasGrabJoints) {
+        totalSize += sizeof(AvatarDataPacket::FarGrabJoints);
+    }
 
     return totalSize;
 }
@@ -690,7 +693,7 @@ QByteArray AvatarData::toByteArray(AvatarDataDetail dataDetail, quint64 lastSent
         if (hasGrabJoints) {
             // the far-grab joints may range further than 3 meters, so we can't use packFloatVec3ToSignedTwoByteFixed etc
             auto startSection = destinationBuffer;
-            auto data = reinterpret_cast<AvatarDataPacket::FarGrabJoints*>(destinationBuffer);
+
             glm::vec3 leftFarGrabPosition = extractTranslation(leftFarGrabMatrix);
             glm::quat leftFarGrabRotation = extractRotation(leftFarGrabMatrix);
             glm::vec3 rightFarGrabPosition = extractTranslation(rightFarGrabMatrix);
@@ -698,28 +701,17 @@ QByteArray AvatarData::toByteArray(AvatarDataDetail dataDetail, quint64 lastSent
             glm::vec3 mouseFarGrabPosition = extractTranslation(mouseFarGrabMatrix);
             glm::quat mouseFarGrabRotation = extractRotation(mouseFarGrabMatrix);
 
-            AVATAR_MEMCPY(leftFarGrabPosition);
-            // Can't do block copy as struct order is x, y, z, w.
-            data->leftFarGrabRotation[0] = leftFarGrabRotation.w;
-            data->leftFarGrabRotation[1] = leftFarGrabRotation.x;
-            data->leftFarGrabRotation[2] = leftFarGrabRotation.y;
-            data->leftFarGrabRotation[3] = leftFarGrabRotation.z;
-            destinationBuffer += sizeof(data->leftFarGrabPosition);
-
-            AVATAR_MEMCPY(rightFarGrabPosition);
-            data->rightFarGrabRotation[0] = rightFarGrabRotation.w;
-            data->rightFarGrabRotation[1] = rightFarGrabRotation.x;
-            data->rightFarGrabRotation[2] = rightFarGrabRotation.y;
-            data->rightFarGrabRotation[3] = rightFarGrabRotation.z;
-            destinationBuffer += sizeof(data->rightFarGrabRotation);
-
-            AVATAR_MEMCPY(mouseFarGrabPosition);
-            data->mouseFarGrabRotation[0] = mouseFarGrabRotation.w;
-            data->mouseFarGrabRotation[1] = mouseFarGrabRotation.x;
-            data->mouseFarGrabRotation[2] = mouseFarGrabRotation.y;
-            data->mouseFarGrabRotation[3] = mouseFarGrabRotation.z;
-            destinationBuffer += sizeof(data->mouseFarGrabRotation);
+            AvatarDataPacket::FarGrabJoints farGrabJoints = {
+                { leftFarGrabPosition.x, leftFarGrabPosition.y, leftFarGrabPosition.z },
+                { leftFarGrabRotation.w, leftFarGrabRotation.x, leftFarGrabRotation.y, leftFarGrabRotation.z },
+                { rightFarGrabPosition.x, rightFarGrabPosition.y, rightFarGrabPosition.z },
+                { rightFarGrabRotation.w, rightFarGrabRotation.x, rightFarGrabRotation.y, rightFarGrabRotation.z },
+                { mouseFarGrabPosition.x, mouseFarGrabPosition.y, mouseFarGrabPosition.z },
+                { mouseFarGrabRotation.w, mouseFarGrabRotation.x, mouseFarGrabRotation.y, mouseFarGrabRotation.z }
+            };
 
+            memcpy(destinationBuffer, &farGrabJoints, sizeof(farGrabJoints));
+            destinationBuffer += sizeof(AvatarDataPacket::FarGrabJoints);
             int numBytes = destinationBuffer - startSection;
 
             if (outboundDataRateOut) {
@@ -1250,25 +1242,37 @@ int AvatarData::parseDataFromBuffer(const QByteArray& buffer) {
             auto startSection = sourceBuffer;
 
             PACKET_READ_CHECK(FarGrabJoints, sizeof(AvatarDataPacket::FarGrabJoints));
-            auto data = reinterpret_cast<const AvatarDataPacket::FarGrabJoints*>(sourceBuffer);
-            glm::vec3 leftFarGrabPosition = glm::vec3(data->leftFarGrabPosition[0], data->leftFarGrabPosition[1],
-                                                      data->leftFarGrabPosition[2]);
-            glm::quat leftFarGrabRotation = glm::quat(data->leftFarGrabRotation[0], data->leftFarGrabRotation[1],
-                                                      data->leftFarGrabRotation[2], data->leftFarGrabRotation[3]);
-            glm::vec3 rightFarGrabPosition = glm::vec3(data->rightFarGrabPosition[0], data->rightFarGrabPosition[1],
-                                                       data->rightFarGrabPosition[2]);
-            glm::quat rightFarGrabRotation = glm::quat(data->rightFarGrabRotation[0], data->rightFarGrabRotation[1],
-                                                       data->rightFarGrabRotation[2], data->rightFarGrabRotation[3]);
-            glm::vec3 mouseFarGrabPosition = glm::vec3(data->mouseFarGrabPosition[0], data->mouseFarGrabPosition[1],
-                                                       data->mouseFarGrabPosition[2]);
-            glm::quat mouseFarGrabRotation = glm::quat(data->mouseFarGrabRotation[0], data->mouseFarGrabRotation[1],
-                                                       data->mouseFarGrabRotation[2], data->mouseFarGrabRotation[3]);
+
+            AvatarDataPacket::FarGrabJoints farGrabJoints;
+            memcpy(&farGrabJoints, sourceBuffer, sizeof(farGrabJoints)); // to avoid misaligned floats
+
+            glm::vec3 leftFarGrabPosition = glm::vec3(farGrabJoints.leftFarGrabPosition[0],
+                                                      farGrabJoints.leftFarGrabPosition[1],
+                                                      farGrabJoints.leftFarGrabPosition[2]);
+            glm::quat leftFarGrabRotation = glm::quat(farGrabJoints.leftFarGrabRotation[0],
+                                                      farGrabJoints.leftFarGrabRotation[1],
+                                                      farGrabJoints.leftFarGrabRotation[2],
+                                                      farGrabJoints.leftFarGrabRotation[3]);
+            glm::vec3 rightFarGrabPosition = glm::vec3(farGrabJoints.rightFarGrabPosition[0],
+                                                       farGrabJoints.rightFarGrabPosition[1],
+                                                       farGrabJoints.rightFarGrabPosition[2]);
+            glm::quat rightFarGrabRotation = glm::quat(farGrabJoints.rightFarGrabRotation[0],
+                                                       farGrabJoints.rightFarGrabRotation[1],
+                                                       farGrabJoints.rightFarGrabRotation[2],
+                                                       farGrabJoints.rightFarGrabRotation[3]);
+            glm::vec3 mouseFarGrabPosition = glm::vec3(farGrabJoints.mouseFarGrabPosition[0],
+                                                       farGrabJoints.mouseFarGrabPosition[1],
+                                                       farGrabJoints.mouseFarGrabPosition[2]);
+            glm::quat mouseFarGrabRotation = glm::quat(farGrabJoints.mouseFarGrabRotation[0],
+                                                       farGrabJoints.mouseFarGrabRotation[1],
+                                                       farGrabJoints.mouseFarGrabRotation[2],
+                                                       farGrabJoints.mouseFarGrabRotation[3]);
 
             _farGrabLeftMatrixCache.set(createMatFromQuatAndPos(leftFarGrabRotation, leftFarGrabPosition));
             _farGrabRightMatrixCache.set(createMatFromQuatAndPos(rightFarGrabRotation, rightFarGrabPosition));
             _farGrabMouseMatrixCache.set(createMatFromQuatAndPos(mouseFarGrabRotation, mouseFarGrabPosition));
 
-            sourceBuffer += sizeof(AvatarDataPacket::AvatarGlobalPosition);
+            sourceBuffer += sizeof(AvatarDataPacket::FarGrabJoints);
             int numBytesRead = sourceBuffer - startSection;
             _farGrabJointRate.increment(numBytesRead);
             _farGrabJointUpdateRate.increment();
@@ -2828,10 +2832,10 @@ QScriptValue RayToAvatarIntersectionResultToScriptValue(QScriptEngine* engine, c
     obj.setProperty("avatarID", avatarIDValue);
     obj.setProperty("distance", value.distance);
     obj.setProperty("face", boxFaceToString(value.face));
+    QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
 
-    QScriptValue intersection = vec3toScriptValue(engine, value.intersection);
     obj.setProperty("intersection", intersection);
-    QScriptValue surfaceNormal = vec3toScriptValue(engine, value.surfaceNormal);
+    QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
     obj.setProperty("surfaceNormal", surfaceNormal);
     obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
     return obj;

libraries/controllers/src/controllers/Pose.cpp

@@ -41,10 +41,10 @@ namespace controller {
      */
     QScriptValue Pose::toScriptValue(QScriptEngine* engine, const Pose& pose) {
         QScriptValue obj = engine->newObject();
-        obj.setProperty("translation", vec3toScriptValue(engine, pose.translation));
+        obj.setProperty("translation", vec3ToScriptValue(engine, pose.translation));
         obj.setProperty("rotation", quatToScriptValue(engine, pose.rotation));
-        obj.setProperty("velocity", vec3toScriptValue(engine, pose.velocity));
-        obj.setProperty("angularVelocity", vec3toScriptValue(engine, pose.angularVelocity));
+        obj.setProperty("velocity", vec3ToScriptValue(engine, pose.velocity));
+        obj.setProperty("angularVelocity", vec3ToScriptValue(engine, pose.angularVelocity));
         obj.setProperty("valid", pose.valid);
         return obj;
     }

libraries/display-plugins/src/display-plugins/CompositorHelper.cpp

@@ -494,7 +494,7 @@ glm::mat4 CompositorHelper::getPoint2DTransform(const glm::vec2& point, float si
 
 
 QVariant ReticleInterface::getPosition() const {
-    return vec2toVariant(_compositor->getReticlePosition());
+    return vec2ToVariant(_compositor->getReticlePosition());
 }
 
 void ReticleInterface::setPosition(QVariant position) {

libraries/entities-renderer/src/RenderableLightEntityItem.cpp

@@ -41,7 +41,7 @@ void LightEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPoint
     float largestDiameter = glm::compMax(dimensions);
     light->setMaximumRadius(largestDiameter / 2.0f);
 
-    light->setColor(toGlm(entity->getXColor()));
+    light->setColor(toGlm(entity->getColor()));
 
     float intensity = entity->getIntensity();//* entity->getFadingRatio();
     light->setIntensity(intensity);

libraries/entities-renderer/src/RenderableLineEntityItem.cpp

@@ -37,7 +37,7 @@ void LineEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointe
     if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
         _lineVerticesID = geometryCache->allocateID();
     }
-    glm::vec4 lineColor(toGlm(entity->getXColor()), entity->getLocalRenderAlpha());
+    glm::vec4 lineColor(toGlm(entity->getColor()), entity->getLocalRenderAlpha());
     geometryCache->updateVertices(_lineVerticesID, _linePoints, lineColor);
 }
 

libraries/entities-renderer/src/RenderableModelEntityItem.h

@@ -24,8 +24,6 @@
 
 #include "RenderableEntityItem.h"
 
-
-
 class Model;
 class EntityTreeRenderer;
 

libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp

@@ -142,7 +142,7 @@ void PolyLineEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPo
     }
     if (strokeColorsChanged) {
         _lastStrokeColors = entity->getStrokeColors();
-        _lastStrokeColors = _lastNormals.size() == _lastStrokeColors.size() ? _lastStrokeColors : QVector<glm::vec3>({ toGlm(entity->getXColor()) });
+        _lastStrokeColors = _lastNormals.size() == _lastStrokeColors.size() ? _lastStrokeColors : QVector<glm::vec3>({ toGlm(entity->getColor()) });
     }
     if (pointsChanged || strokeWidthsChanged || normalsChanged || strokeColorsChanged) {
         _empty = std::min(_lastPoints.size(), std::min(_lastNormals.size(), _lastStrokeWidths.size())) < 2;
@@ -161,10 +161,10 @@ void PolyLineEntityRenderer::updateGeometry(const std::vector<Vertex>& vertices)
     _verticesBuffer->setSubData(0, vertices);
 }
 
-std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertices(const QVector<glm::vec3>& points, 
-                                                                                   const QVector<glm::vec3>& normals, 
+std::vector<PolyLineEntityRenderer::Vertex> PolyLineEntityRenderer::updateVertices(const QVector<glm::vec3>& points,
+                                                                                   const QVector<glm::vec3>& normals,
                                                                                    const QVector<float>& strokeWidths, 
-                                                                                   const QVector<glm::vec3>& strokeColors, 
+                                                                                   const QVector<glm::vec3>& strokeColors,
                                                                                    const bool isUVModeStretch,
                                                                                    const float textureAspectRatio) {
     // Calculate the minimum vector size out of normals, points, and stroke widths

libraries/entities-renderer/src/RenderablePolyLineEntityItem.h

@@ -52,10 +52,10 @@ protected:
     };
 
     void updateGeometry(const std::vector<Vertex>& vertices);
-    static std::vector<Vertex> updateVertices(const QVector<glm::vec3>& points, 
-                                              const QVector<glm::vec3>& normals, 
+    static std::vector<Vertex> updateVertices(const QVector<glm::vec3>& points,
+                                              const QVector<glm::vec3>& normals,
                                               const QVector<float>& strokeWidths, 
-                                              const QVector<glm::vec3>& strokeColors, 
+                                              const QVector<glm::vec3>& strokeColors,
                                               const bool isUVModeStretch,
                                               const float textureAspectRatio);
 

libraries/entities-renderer/src/RenderableTextEntityItem.cpp

@@ -47,11 +47,11 @@ bool TextEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoint
         return true;
     }
 
-    if (_textColor != toGlm(entity->getTextColorX())) {
+    if (_textColor != toGlm(entity->getTextColor())) {
         return true;
     }
 
-    if (_backgroundColor != toGlm(entity->getBackgroundColorX())) {
+    if (_backgroundColor != toGlm(entity->getBackgroundColor())) {
         return true;
     }
 
@@ -77,8 +77,8 @@ void TextEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
 }
 
 void TextEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
-    _textColor = toGlm(entity->getTextColorX());
-    _backgroundColor = toGlm(entity->getBackgroundColorX());
+    _textColor = toGlm(entity->getTextColor());
+    _backgroundColor = toGlm(entity->getBackgroundColor());
     _faceCamera = entity->getFaceCamera();
     _lineHeight = entity->getLineHeight();
     _text = entity->getText();

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -413,10 +413,10 @@ void ZoneEntityRenderer::updateHazeFromEntity(const TypedEntityPointer& entity)
     haze->setAltitudeBased(_hazeProperties.getHazeAltitudeEffect());
 
     haze->setHazeRangeFactor(graphics::Haze::convertHazeRangeToHazeRangeFactor(_hazeProperties.getHazeRange()));
-    xColor hazeColor = _hazeProperties.getHazeColor();
-    haze->setHazeColor(glm::vec3(hazeColor.red / 255.0, hazeColor.green / 255.0, hazeColor.blue / 255.0));
-    xColor hazeGlareColor = _hazeProperties.getHazeGlareColor();
-    haze->setHazeGlareColor(glm::vec3(hazeGlareColor.red / 255.0, hazeGlareColor.green / 255.0, hazeGlareColor.blue / 255.0));
+    glm::u8vec3 hazeColor = _hazeProperties.getHazeColor();
+    haze->setHazeColor(toGlm(hazeColor));
+    glm::u8vec3 hazeGlareColor = _hazeProperties.getHazeGlareColor();
+    haze->setHazeGlareColor(toGlm(hazeGlareColor));
     haze->setHazeEnableGlare(_hazeProperties.getHazeEnableGlare());
     haze->setHazeGlareBlend(graphics::Haze::convertGlareAngleToPower(_hazeProperties.getHazeGlareAngle()));
 
@@ -447,7 +447,7 @@ void ZoneEntityRenderer::updateKeyBackgroundFromEntity(const TypedEntityPointer&
     setSkyboxMode((ComponentMode)entity->getSkyboxMode());
 
     editBackground();
-    setSkyboxColor(_skyboxProperties.getColorVec3());
+    setSkyboxColor(toGlm(_skyboxProperties.getColor()));
     setProceduralUserData(entity->getUserData());
     setSkyboxURL(_skyboxProperties.getURL());
 }

libraries/entities/src/EntityEditFilters.cpp

@@ -104,10 +104,10 @@ bool EntityEditFilters::filter(glm::vec3& position, EntityItemProperties& proper
                         AABox aaBox = zoneEntity->getAABox(success);
                         if (success) {
                             QScriptValue boundingBox = filterData.engine->newObject();
-                            QScriptValue bottomRightNear = vec3toScriptValue(filterData.engine, aaBox.getCorner());
-                            QScriptValue topFarLeft = vec3toScriptValue(filterData.engine, aaBox.calcTopFarLeft());
-                            QScriptValue center = vec3toScriptValue(filterData.engine, aaBox.calcCenter());
-                            QScriptValue boundingBoxDimensions = vec3toScriptValue(filterData.engine, aaBox.getDimensions());
+                            QScriptValue bottomRightNear = vec3ToScriptValue(filterData.engine, aaBox.getCorner());
+                            QScriptValue topFarLeft = vec3ToScriptValue(filterData.engine, aaBox.calcTopFarLeft());
+                            QScriptValue center = vec3ToScriptValue(filterData.engine, aaBox.calcCenter());
+                            QScriptValue boundingBoxDimensions = vec3ToScriptValue(filterData.engine, aaBox.getDimensions());
                             boundingBox.setProperty("brn", bottomRightNear);
                             boundingBox.setProperty("tfl", topFarLeft);
                             boundingBox.setProperty("center", center);

libraries/entities/src/EntityItem.cpp

@@ -131,6 +131,10 @@ EntityPropertyFlags EntityItem::getEntityProperties(EncodeBitstreamParams& param
     requestedProperties += PROP_CLONE_AVATAR_ENTITY;
     requestedProperties += PROP_CLONE_ORIGIN_ID;
 
+    withReadLock([&] {
+        requestedProperties += _grabProperties.getEntityProperties(params);
+    });
+
     return requestedProperties;
 }
 
@@ -168,6 +172,9 @@ OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packet
     EntityPropertyFlags propertyFlags(PROP_LAST_ITEM);
     EntityPropertyFlags requestedProperties = getEntityProperties(params);
 
+    requestedProperties -= PROP_CLIENT_ONLY;
+    requestedProperties -= PROP_OWNING_AVATAR_ID;
+
     // If we are being called for a subsequent pass at appendEntityData() that failed to completely encode this item,
     // then our entityTreeElementExtraEncodeData should include data about which properties we need to append.
     if (entityTreeElementExtraEncodeData && entityTreeElementExtraEncodeData->entities.contains(getEntityItemID())) {
@@ -300,7 +307,12 @@ OctreeElement::AppendState EntityItem::appendEntityData(OctreePacketData* packet
         APPEND_ENTITY_PROPERTY(PROP_CLONE_LIMIT, getCloneLimit());
         APPEND_ENTITY_PROPERTY(PROP_CLONE_DYNAMIC, getCloneDynamic());
         APPEND_ENTITY_PROPERTY(PROP_CLONE_AVATAR_ENTITY, getCloneAvatarEntity());
-        APPEND_ENTITY_PROPERTY(PROP_CLONE_ORIGIN_ID, getCloneOriginID()); 
+        APPEND_ENTITY_PROPERTY(PROP_CLONE_ORIGIN_ID, getCloneOriginID());
+
+        withReadLock([&] {
+            _grabProperties.appendSubclassData(packetData, params, entityTreeElementExtraEncodeData, requestedProperties,
+                                               propertyFlags, propertiesDidntFit, propertyCount, appendState);
+        });
 
         appendSubclassData(packetData, params, entityTreeElementExtraEncodeData,
                                 requestedProperties,
@@ -661,7 +673,7 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
     const QUuid& myNodeID = nodeList->getSessionUUID();
     bool weOwnSimulation = _simulationOwner.matchesValidID(myNodeID);
 
-    // pack SimulationOwner and terse update properties near each other
+    // pack SimulationOwner, transform, and velocity properties near each other
     // NOTE: the server is authoritative for changes to simOwnerID so we always unpack ownership data
     // even when we would otherwise ignore the rest of the packet.
 
@@ -892,7 +904,15 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
     READ_ENTITY_PROPERTY(PROP_CLONE_LIMIT, float, setCloneLimit);
     READ_ENTITY_PROPERTY(PROP_CLONE_DYNAMIC, bool, setCloneDynamic);
     READ_ENTITY_PROPERTY(PROP_CLONE_AVATAR_ENTITY, bool, setCloneAvatarEntity);
-    READ_ENTITY_PROPERTY(PROP_CLONE_ORIGIN_ID, QUuid, setCloneOriginID); 
+    READ_ENTITY_PROPERTY(PROP_CLONE_ORIGIN_ID, QUuid, setCloneOriginID);
+
+    withWriteLock([&] {
+        int bytesFromGrab = _grabProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+                                                                             propertyFlags, overwriteLocalData,
+                                                                             somethingChanged);
+        bytesRead += bytesFromGrab;
+        dataAt += bytesFromGrab;
+    });
 
     bytesRead += readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
                                                   propertyFlags, overwriteLocalData, somethingChanged);
@@ -1329,13 +1349,16 @@ EntityItemProperties EntityItem::getProperties(const EntityPropertyFlags& desire
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(cloneAvatarEntity, getCloneAvatarEntity);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(cloneOriginID, getCloneOriginID);
 
+    withReadLock([&] {
+        _grabProperties.getProperties(properties);
+    });
+
     properties._defaultSettings = false;
 
     return properties;
 }
 
-void EntityItem::getAllTerseUpdateProperties(EntityItemProperties& properties) const {
-    // a TerseUpdate includes the transform and its derivatives
+void EntityItem::getTransformAndVelocityProperties(EntityItemProperties& properties) const {
     if (!properties._positionChanged) {
         properties._position = getLocalPosition();
     }
@@ -1359,8 +1382,11 @@ void EntityItem::getAllTerseUpdateProperties(EntityItemProperties& properties) c
     properties._accelerationChanged = true;
 }
 
-void EntityItem::setScriptSimulationPriority(uint8_t priority) {
-    uint8_t newPriority = stillHasGrabActions() ? glm::max(priority, SCRIPT_GRAB_SIMULATION_PRIORITY) : priority;
+void EntityItem::upgradeScriptSimulationPriority(uint8_t priority) {
+    uint8_t newPriority = glm::max(priority, _scriptSimulationPriority);
+    if (newPriority < SCRIPT_GRAB_SIMULATION_PRIORITY && stillHasGrabActions()) {
+        newPriority = SCRIPT_GRAB_SIMULATION_PRIORITY;
+    }
     if (newPriority != _scriptSimulationPriority) {
         // set the dirty flag to trigger a bid or ownership update
         markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_PRIORITY);
@@ -1395,7 +1421,7 @@ bool EntityItem::stillWaitingToTakeOwnership(uint64_t timestamp) const {
 bool EntityItem::setProperties(const EntityItemProperties& properties) {
     bool somethingChanged = false;
 
-    // these affect TerseUpdate properties
+    // these affect transform and velocity properties
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(simulationOwner, setSimulationOwner);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(position, setPosition);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(rotation, setRotation);
@@ -1465,6 +1491,11 @@ bool EntityItem::setProperties(const EntityItemProperties& properties) {
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(cloneAvatarEntity, setCloneAvatarEntity);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(cloneOriginID, setCloneOriginID);
 
+    withWriteLock([&] {
+        bool grabPropertiesChanged = _grabProperties.setProperties(properties);
+        somethingChanged |= grabPropertiesChanged;
+    });
+
     if (updateQueryAACube()) {
         somethingChanged = true;
     }
@@ -1784,6 +1815,12 @@ void EntityItem::setUnscaledDimensions(const glm::vec3& value) {
     }
 }
 
+glm::vec3 EntityItem::getUnscaledDimensions() const {
+   return resultWithReadLock<glm::vec3>([&] {
+        return _unscaledDimensions;
+    });
+}
+
 void EntityItem::setRotation(glm::quat rotation) {
     if (getLocalOrientation() != rotation) {
         setLocalOrientation(rotation);
@@ -3221,3 +3258,26 @@ void EntityItem::setScriptHasFinishedPreload(bool value) {
 bool EntityItem::isScriptPreloadFinished() {
     return _scriptPreloadFinished;
 }
+
+void EntityItem::prepareForSimulationOwnershipBid(EntityItemProperties& properties, uint64_t now, uint8_t priority) {
+    if (dynamicDataNeedsTransmit()) {
+        setDynamicDataNeedsTransmit(false);
+        properties.setActionData(getDynamicData());
+    }
+
+    if (updateQueryAACube()) {
+        // due to parenting, the server may not know where something is in world-space, so include the bounding cube.
+        properties.setQueryAACube(getQueryAACube());
+    }
+
+    // set the LastEdited of the properties but NOT the entity itself
+    properties.setLastEdited(now);
+
+    clearScriptSimulationPriority();
+    properties.setSimulationOwner(Physics::getSessionUUID(), priority);
+    setPendingOwnershipPriority(priority);
+
+    properties.setClientOnly(getClientOnly());
+    properties.setOwningAvatarID(getOwningAvatarID());
+    setLastBroadcast(now); // for debug/physics status icons
+}

libraries/entities/src/EntityItem.h

@@ -35,6 +35,7 @@
 #include "SimulationOwner.h"
 #include "SimulationFlags.h"
 #include "EntityDynamicInterface.h"
+#include "GrabPropertyGroup.h"
 
 #include "graphics/Material.h"
 
@@ -191,7 +192,7 @@ public:
     virtual void setScaledDimensions(const glm::vec3& value);
     virtual glm::vec3 getRaycastDimensions() const { return getScaledDimensions(); }
 
-    inline const glm::vec3 getUnscaledDimensions() const { return _unscaledDimensions; }
+    glm::vec3 getUnscaledDimensions() const;
     virtual void setUnscaledDimensions(const glm::vec3& value);
 
     float getLocalRenderAlpha() const;
@@ -263,9 +264,8 @@ public:
     void setCollisionSoundURL(const QString& value);
 
     glm::vec3 getRegistrationPoint() const; /// registration point as ratio of entity
-
     /// registration point as ratio of entity
-    virtual void setRegistrationPoint(const glm::vec3& value); // FIXME: this is suspicious! 
+    virtual void setRegistrationPoint(const glm::vec3& value); // FIXME: this is suspicious!
 
     bool hasAngularVelocity() const { return getWorldAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
     bool hasLocalAngularVelocity() const { return getLocalAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
@@ -325,7 +325,7 @@ public:
     // TODO: move this "ScriptSimulationPriority" and "PendingOwnership" stuff into EntityMotionState
     // but first would need to do some other cleanup. In the meantime these live here as "scratch space"
     // to allow libs that don't know about each other to communicate.
-    void setScriptSimulationPriority(uint8_t priority);
+    void upgradeScriptSimulationPriority(uint8_t priority);
     void clearScriptSimulationPriority();
     uint8_t getScriptSimulationPriority() const { return _scriptSimulationPriority; }
     void setPendingOwnershipPriority(uint8_t priority);
@@ -420,7 +420,7 @@ public:
     quint64 getLastEditedFromRemote() const { return _lastEditedFromRemote; }
     void updateLastEditedFromRemote() { _lastEditedFromRemote = usecTimestampNow(); }
 
-    void getAllTerseUpdateProperties(EntityItemProperties& properties) const;
+    void getTransformAndVelocityProperties(EntityItemProperties& properties) const;
 
     void flagForMotionStateChange() { _flags |= Simulation::DIRTY_MOTION_TYPE; }
 
@@ -533,6 +533,10 @@ public:
     void setCloneIDs(const QVector<QUuid>& cloneIDs);
     void setVisuallyReady(bool visuallyReady) { _visuallyReady = visuallyReady; }
 
+    const GrabPropertyGroup& getGrabProperties() const { return _grabProperties; }
+
+    void prepareForSimulationOwnershipBid(EntityItemProperties& properties, uint64_t now, uint8_t priority);
+
 signals:
     void requestRenderUpdate();
     void spaceUpdate(std::pair<int32_t, glm::vec4> data);
@@ -711,6 +715,8 @@ protected:
     QUuid _cloneOriginID;
     QVector<QUuid> _cloneIDs;
 
+    GrabPropertyGroup _grabProperties;
+
 private:
     std::unordered_map<std::string, graphics::MultiMaterial> _materials;
     std::mutex _materialsLock;

libraries/entities/src/EntityItemProperties.cpp

@@ -40,6 +40,7 @@ HazePropertyGroup EntityItemProperties::_staticHaze;
 BloomPropertyGroup EntityItemProperties::_staticBloom;
 KeyLightPropertyGroup EntityItemProperties::_staticKeyLight;
 AmbientLightPropertyGroup EntityItemProperties::_staticAmbientLight;
+GrabPropertyGroup EntityItemProperties::_staticGrab;
 
 EntityPropertyList PROP_LAST_ITEM = (EntityPropertyList)(PROP_AFTER_LAST_ITEM - 1);
 
@@ -61,8 +62,8 @@ EntityItemProperties::EntityItemProperties(EntityPropertyFlags desiredProperties
 
 }
 
-void EntityItemProperties::calculateNaturalPosition(const glm::vec3& min, const glm::vec3& max) {
-    glm::vec3 halfDimension = (max - min) / 2.0f;
+void EntityItemProperties::calculateNaturalPosition(const vec3& min, const vec3& max) {
+    vec3 halfDimension = (max - min) / 2.0f;
     _naturalPosition = max - halfDimension;
 }
 
@@ -86,6 +87,7 @@ void EntityItemProperties::debugDump() const {
     getKeyLight().debugDump();
     getAmbientLight().debugDump();
     getBloom().debugDump();
+    getGrab().debugDump();
 
     qCDebug(entities) << "   changed properties...";
     EntityPropertyFlags props = getChangedProperties();
@@ -471,6 +473,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
     changedProperties += _skybox.getChangedProperties();
     changedProperties += _haze.getChangedProperties();
     changedProperties += _bloom.getChangedProperties();
+    changedProperties += _grab.getChangedProperties();
 
     return changedProperties;
 }
@@ -628,6 +631,8 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
  *     avatar entities: their <code>clientOnly</code> property will be set to <code>true</code>.
  * @property {Uuid} cloneOriginID - The ID of the entity that this entity was cloned from.
  *
+ * @property {Entities.Grab} grab - The grab-related properties.
+ *
  * @property {string} itemName="" - Certifiable name of the Marketplace item.
  * @property {string} itemDescription="" - Certifiable description of the Marketplace item.
  * @property {string} itemCategories="" - Certifiable category of the Marketplace item.
@@ -872,9 +877,9 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
  * @property {number} emitSpeed=5 - The speed, in m/s, that each particle is emitted at.
  * @property {number} speedSpread=1 - The spread in speeds at which particles are emitted at. If <code>emitSpeed == 5</code> 
  *     and <code>speedSpread == 1</code>, particles will be emitted with speeds in the range 4m/s &ndash; 6m/s.
- * @property {vec3} emitAcceleration=0,-9.8,0 - The acceleration that is applied to each particle during its lifetime. The 
+ * @property {Vec3} emitAcceleration=0,-9.8,0 - The acceleration that is applied to each particle during its lifetime. The 
  *     default is Earth's gravity value.
- * @property {vec3} accelerationSpread=0,0,0 - The spread in accelerations that each particle is given. If
+ * @property {Vec3} accelerationSpread=0,0,0 - The spread in accelerations that each particle is given. If
  *     <code>emitAccelerations == {x: 0, y: -9.8, z: 0}</code> and <code>accelerationSpread ==
  *     {x: 0, y: 1, z: 0}</code>, each particle will have an acceleration in the range <code>{x: 0, y: -10.8, z: 0}</code>
  *     &ndash; <code>{x: 0, y: -8.8, z: 0}</code>.
@@ -887,7 +892,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
  *     default, particles emit along the entity's local z-axis, and <code>azimuthStart</code> and <code>azimuthFinish</code> 
  *     are relative to the entity's local x-axis. The default value is a rotation of -90 degrees about the local x-axis, i.e., 
  *     the particles emit vertically.
- * @property {vec3} emitDimensions=0,0,0 - The dimensions of the ellipsoid from which particles are emitted.
+ * @property {Vec3} emitDimensions=0,0,0 - The dimensions of the ellipsoid from which particles are emitted.
  * @property {number} emitRadiusStart=1 - The starting radius within the ellipsoid at which particles start being emitted;
  *     range <code>0.0</code> &ndash; <code>1.0</code> for the ellipsoid center to the ellipsoid surface, respectively.
  *     Particles are emitted from the portion of the ellipsoid that lies between <code>emitRadiusStart</code> and the 
@@ -916,9 +921,9 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
  *     and <code>radiusSpread == 0.25</code>, each particle will have a radius in the range <code>0.25</code> &ndash; 
  *     <code>0.75</code>.
  * @property {Color} color=255,255,255 - The color of each particle at the middle of its life.
- * @property {Color} colorStart={} - The color of each particle at the start of its life. If any of the component values are 
+ * @property {ColorFloat} colorStart={} - The color of each particle at the start of its life. If any of the component values are
  *     undefined, the <code>color</code> value is used.
- * @property {Color} colorFinish={} - The color of each particle at the end of its life. If any of the component values are 
+ * @property {ColorFloat} colorFinish={} - The color of each particle at the end of its life. If any of the component values are
  *     undefined, the <code>color</code> value is used.
  * @property {Color} colorSpread=0,0,0 - The spread in color that each particle is given. If
  *     <code>color == {red: 100, green: 100, blue: 100}</code> and <code>colorSpread ==
@@ -1314,9 +1319,6 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_NAME, name);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLLISION_SOUND_URL, collisionSoundURL);
 
-    // Light, Line, Model, ParticleEffect, PolyLine, Shape
-    COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLOR, color);
-
     // Particles only
     if (_type == EntityTypes::ParticleEffect) {
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_EMITTING_PARTICLES, isEmitting);
@@ -1338,9 +1340,10 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_RADIUS_SPREAD, radiusSpread);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_RADIUS_START, radiusStart);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_RADIUS_FINISH, radiusFinish);
-        COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLOR_SPREAD, colorSpread);
-        COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLOR_START, colorStart);
-        COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_COLOR_FINISH, colorFinish);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR, color, u8vec3Color);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR_SPREAD, colorSpread, u8vec3Color);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR_START, colorStart, vec3Color);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR_FINISH, colorFinish, vec3Color);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_ALPHA_SPREAD, alphaSpread);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_ALPHA_START, alphaStart);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_ALPHA_FINISH, alphaFinish);
@@ -1363,6 +1366,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_JOINT_TRANSLATIONS_SET, jointTranslationsSet);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_JOINT_TRANSLATIONS, jointTranslations);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_RELAY_PARENT_JOINTS, relayParentJoints);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR, color, u8vec3Color);
     }
 
     if (_type == EntityTypes::Model || _type == EntityTypes::Zone || _type == EntityTypes::ParticleEffect) {
@@ -1379,6 +1383,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
 
     if (_type == EntityTypes::Box || _type == EntityTypes::Sphere || _type == EntityTypes::Shape) {
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_SHAPE, shape);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR, color, u8vec3Color);
     }
 
     // FIXME - it seems like ParticleEffect should also support this
@@ -1393,6 +1398,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
 
     // Lights only
     if (_type == EntityTypes::Light) {
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR, color, u8vec3Color);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_IS_SPOTLIGHT, isSpotlight);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_INTENSITY, intensity);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_FALLOFF_RADIUS, falloffRadius);
@@ -1404,8 +1410,8 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     if (_type == EntityTypes::Text) {
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_TEXT, text);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_LINE_HEIGHT, lineHeight);
-        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_TEXT_COLOR, textColor, getTextColor());
-        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_BACKGROUND_COLOR, backgroundColor, getBackgroundColor());
+        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER_TYPED(PROP_TEXT_COLOR, textColor, getTextColor(), u8vec3Color);
+        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER_TYPED(PROP_BACKGROUND_COLOR, backgroundColor, getBackgroundColor(), u8vec3Color);
     }
 
     // Zones only
@@ -1459,10 +1465,11 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
 
     // Lines & PolyLines
     if (_type == EntityTypes::Line || _type == EntityTypes::PolyLine) {
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_COLOR, color, u8vec3Color);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_LINE_WIDTH, lineWidth);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_LINE_POINTS, linePoints);
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_NORMALS, normals);  // Polyline only.
-        COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_STROKE_COLORS, strokeColors);  // Polyline only.
+        COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_STROKE_COLORS, strokeColors, qVectorVec3Color);  // Polyline only.
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_STROKE_WIDTHS, strokeWidths);  // Polyline only.
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_TEXTURES, textures);  // Polyline only.
         COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_IS_UV_MODE_STRETCH, isUVModeStretch);  // Polyline only.
@@ -1493,10 +1500,10 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
 
         AABox aaBox = getAABox();
         QScriptValue boundingBox = engine->newObject();
-        QScriptValue bottomRightNear = vec3toScriptValue(engine, aaBox.getCorner());
-        QScriptValue topFarLeft = vec3toScriptValue(engine, aaBox.calcTopFarLeft());
-        QScriptValue center = vec3toScriptValue(engine, aaBox.calcCenter());
-        QScriptValue boundingBoxDimensions = vec3toScriptValue(engine, aaBox.getDimensions());
+        QScriptValue bottomRightNear = vec3ToScriptValue(engine, aaBox.getCorner());
+        QScriptValue topFarLeft = vec3ToScriptValue(engine, aaBox.calcTopFarLeft());
+        QScriptValue center = vec3ToScriptValue(engine, aaBox.calcCenter());
+        QScriptValue boundingBoxDimensions = vec3ToScriptValue(engine, aaBox.getDimensions());
         boundingBox.setProperty("brn", bottomRightNear);
         boundingBox.setProperty("tfl", topFarLeft);
         boundingBox.setProperty("center", center);
@@ -1530,6 +1537,8 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_CLONE_AVATAR_ENTITY, cloneAvatarEntity);
     COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_CLONE_ORIGIN_ID, cloneOriginID);
 
+    _grab.copyToScriptValue(_desiredProperties, properties, engine, skipDefaults, defaultEntityProperties);
+
     // Rendering info
     if (!skipDefaults && !strictSemantics &&
         (!psuedoPropertyFlagsActive || psueudoPropertyFlags.test(EntityPsuedoPropertyFlag::RenderInfo))) {
@@ -1598,10 +1607,10 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE(angularDamping, float, setAngularDamping);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(visible, bool, setVisible);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(canCastShadow, bool, setCanCastShadow);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(color, xColor, setColor);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorSpread, xColor, setColorSpread);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorStart, vec3, setColorStart);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorFinish, vec3, setColorFinish);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(color, u8vec3Color, setColor);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorSpread, u8vec3Color, setColorSpread);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorStart, vec3Color, setColorStart);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(colorFinish, vec3Color, setColorFinish);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(alpha, float, setAlpha);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(alphaSpread, float, setAlphaSpread);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(alphaStart, float, setAlphaStart);
@@ -1626,8 +1635,8 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE(userData, QString, setUserData);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(text, QString, setText);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(lineHeight, float, setLineHeight);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(textColor, xColor, setTextColor);
-    COPY_PROPERTY_FROM_QSCRIPTVALUE(backgroundColor, xColor, setBackgroundColor);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(textColor, u8vec3Color, setTextColor);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(backgroundColor, u8vec3Color, setBackgroundColor);
     COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(shapeType, ShapeType);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(maxParticles, quint32, setMaxParticles);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(lifespan, float, setLifespan);
@@ -1700,7 +1709,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE(strokeColors, qVectorVec3, setStrokeColors);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(strokeWidths,qVectorFloat, setStrokeWidths);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(isUVModeStretch, bool, setIsUVModeStretch);
-    
+
 
     if (!honorReadOnly) {
         // this is used by the json reader to set things that we don't want javascript to able to affect.
@@ -1718,6 +1727,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     _skybox.copyFromScriptValue(object, _defaultSettings);
     _haze.copyFromScriptValue(object, _defaultSettings);
     _bloom.copyFromScriptValue(object, _defaultSettings);
+    _grab.copyFromScriptValue(object, _defaultSettings);
 
     COPY_PROPERTY_FROM_QSCRIPTVALUE(xTextureURL, QString, setXTextureURL);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(yTextureURL, QString, setYTextureURL);
@@ -1883,6 +1893,7 @@ void EntityItemProperties::merge(const EntityItemProperties& other) {
     _skybox.merge(other._skybox);
     _haze.merge(other._haze);
     _bloom.merge(other._bloom);
+    _grab.merge(other._grab);
 
     COPY_PROPERTY_IF_CHANGED(xTextureURL);
     COPY_PROPERTY_IF_CHANGED(yTextureURL);
@@ -1973,13 +1984,13 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
     std::call_once(initMap, [](){
         ADD_PROPERTY_TO_MAP(PROP_VISIBLE, Visible, visible, bool);
         ADD_PROPERTY_TO_MAP(PROP_CAN_CAST_SHADOW, CanCastShadow, canCastShadow, bool);
-        ADD_PROPERTY_TO_MAP(PROP_POSITION, Position, position, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_DIMENSIONS, Dimensions, dimensions, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_ROTATION, Rotation, rotation, glm::quat);
+        ADD_PROPERTY_TO_MAP(PROP_POSITION, Position, position, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_DIMENSIONS, Dimensions, dimensions, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_ROTATION, Rotation, rotation, quat);
         ADD_PROPERTY_TO_MAP(PROP_DENSITY, Density, density, float);
-        ADD_PROPERTY_TO_MAP(PROP_VELOCITY, Velocity, velocity, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_GRAVITY, Gravity, gravity, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_ACCELERATION, Acceleration, acceleration, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_VELOCITY, Velocity, velocity, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_GRAVITY, Gravity, gravity, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_ACCELERATION, Acceleration, acceleration, vec3);
         ADD_PROPERTY_TO_MAP(PROP_DAMPING, Damping, damping, float);
         ADD_PROPERTY_TO_MAP(PROP_RESTITUTION, Restitution, restitution, float);
         ADD_PROPERTY_TO_MAP(PROP_FRICTION, Friction, friction, float);
@@ -1988,10 +1999,10 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_SCRIPT_TIMESTAMP, ScriptTimestamp, scriptTimestamp, quint64);
         ADD_PROPERTY_TO_MAP(PROP_SERVER_SCRIPTS, ServerScripts, serverScripts, QString);
         ADD_PROPERTY_TO_MAP(PROP_COLLISION_SOUND_URL, CollisionSoundURL, collisionSoundURL, QString);
-        ADD_PROPERTY_TO_MAP(PROP_COLOR, Color, color, xColor);
-        ADD_PROPERTY_TO_MAP(PROP_COLOR_SPREAD, ColorSpread, colorSpread, xColor);
-        ADD_PROPERTY_TO_MAP(PROP_COLOR_START, ColorStart, colorStart, vec3);
-        ADD_PROPERTY_TO_MAP(PROP_COLOR_FINISH, ColorFinish, colorFinish, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_COLOR, Color, color, u8vec3Color);
+        ADD_PROPERTY_TO_MAP(PROP_COLOR_SPREAD, ColorSpread, colorSpread, u8vec3Color);
+        ADD_PROPERTY_TO_MAP(PROP_COLOR_START, ColorStart, colorStart, vec3Color);
+        ADD_PROPERTY_TO_MAP(PROP_COLOR_FINISH, ColorFinish, colorFinish, vec3Color);
         ADD_PROPERTY_TO_MAP(PROP_ALPHA, Alpha, alpha, float);
         ADD_PROPERTY_TO_MAP(PROP_ALPHA_SPREAD, AlphaSpread, alphaSpread, float);
         ADD_PROPERTY_TO_MAP(PROP_ALPHA_START, AlphaStart, alphaStart, float);
@@ -1999,8 +2010,8 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_EMITTER_SHOULD_TRAIL, EmitterShouldTrail, emitterShouldTrail, bool);
         ADD_PROPERTY_TO_MAP(PROP_MODEL_URL, ModelURL, modelURL, QString);
         ADD_PROPERTY_TO_MAP(PROP_COMPOUND_SHAPE_URL, CompoundShapeURL, compoundShapeURL, QString);
-        ADD_PROPERTY_TO_MAP(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, vec3);
         ADD_PROPERTY_TO_MAP(PROP_ANGULAR_DAMPING, AngularDamping, angularDamping, float);
         ADD_PROPERTY_TO_MAP(PROP_COLLISIONLESS, Collisionless, collisionless, bool);
         ADD_PROPERTY_TO_MAP(PROP_COLLISIONLESS, unused, ignoreForCollisions, unused); // legacy support
@@ -2019,24 +2030,24 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_SIMULATION_OWNER, SimulationOwner, simulationOwner, SimulationOwner);
         ADD_PROPERTY_TO_MAP(PROP_TEXT, Text, text, QString);
         ADD_PROPERTY_TO_MAP(PROP_LINE_HEIGHT, LineHeight, lineHeight, float);
-        ADD_PROPERTY_TO_MAP(PROP_TEXT_COLOR, TextColor, textColor, xColor);
-        ADD_PROPERTY_TO_MAP(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, xColor);
+        ADD_PROPERTY_TO_MAP(PROP_TEXT_COLOR, TextColor, textColor, u8vec3Color);
+        ADD_PROPERTY_TO_MAP(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, u8vec3Color);
         ADD_PROPERTY_TO_MAP(PROP_SHAPE_TYPE, ShapeType, shapeType, ShapeType);
         ADD_PROPERTY_TO_MAP(PROP_MAX_PARTICLES, MaxParticles, maxParticles, quint32);
         ADD_PROPERTY_TO_MAP(PROP_LIFESPAN, Lifespan, lifespan, float);
         ADD_PROPERTY_TO_MAP(PROP_EMITTING_PARTICLES, IsEmitting, isEmitting, bool);
         ADD_PROPERTY_TO_MAP(PROP_EMIT_RATE, EmitRate, emitRate, float);
-        ADD_PROPERTY_TO_MAP(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, glm::quat);
-        ADD_PROPERTY_TO_MAP(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_EMIT_SPEED, EmitSpeed, emitSpeed, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_SPEED_SPREAD, SpeedSpread, speedSpread, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_EMIT_ORIENTATION, EmitOrientation, emitOrientation, quat);
+        ADD_PROPERTY_TO_MAP(PROP_EMIT_DIMENSIONS, EmitDimensions, emitDimensions, vec3);
         ADD_PROPERTY_TO_MAP(PROP_EMIT_RADIUS_START, EmitRadiusStart, emitRadiusStart, float);
         ADD_PROPERTY_TO_MAP(PROP_POLAR_START, EmitPolarStart, polarStart, float);
         ADD_PROPERTY_TO_MAP(PROP_POLAR_FINISH, EmitPolarFinish, polarFinish, float);
         ADD_PROPERTY_TO_MAP(PROP_AZIMUTH_START, EmitAzimuthStart, azimuthStart, float);
         ADD_PROPERTY_TO_MAP(PROP_AZIMUTH_FINISH, EmitAzimuthFinish, azimuthFinish, float);
-        ADD_PROPERTY_TO_MAP(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_EMIT_ACCELERATION, EmitAcceleration, emitAcceleration, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_ACCELERATION_SPREAD, AccelerationSpread, accelerationSpread, vec3);
         ADD_PROPERTY_TO_MAP(PROP_PARTICLE_RADIUS, ParticleRadius, particleRadius, float);
         ADD_PROPERTY_TO_MAP(PROP_RADIUS_SPREAD, RadiusSpread, radiusSpread, float);
         ADD_PROPERTY_TO_MAP(PROP_RADIUS_START, RadiusStart, radiusStart, float);
@@ -2072,24 +2083,24 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_CERTIFICATE_ID, CertificateID, certificateID, QString);
         ADD_PROPERTY_TO_MAP(PROP_STATIC_CERTIFICATE_VERSION, StaticCertificateVersion, staticCertificateVersion, quint32);
 
-        ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_COLOR, KeyLightColor, keyLightColor, xColor);
+        ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_COLOR, KeyLightColor, keyLightColor, u8vec3Color);
         ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_INTENSITY, KeyLightIntensity, keyLightIntensity, float);
-        ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_DIRECTION, KeyLightDirection, keyLightDirection, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_DIRECTION, KeyLightDirection, keyLightDirection, vec3);
         ADD_PROPERTY_TO_MAP(PROP_KEYLIGHT_CAST_SHADOW, KeyLightCastShadows, keyLightCastShadows, bool);
 
-        ADD_PROPERTY_TO_MAP(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_VOXEL_VOLUME_SIZE, VoxelVolumeSize, voxelVolumeSize, vec3);
         ADD_PROPERTY_TO_MAP(PROP_VOXEL_DATA, VoxelData, voxelData, QByteArray);
         ADD_PROPERTY_TO_MAP(PROP_VOXEL_SURFACE_STYLE, VoxelSurfaceStyle, voxelSurfaceStyle, uint16_t);
         ADD_PROPERTY_TO_MAP(PROP_NAME, Name, name, QString);
         ADD_PROPERTY_TO_MAP(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString);
         ADD_PROPERTY_TO_MAP(PROP_LINE_WIDTH, LineWidth, lineWidth, float);
-        ADD_PROPERTY_TO_MAP(PROP_LINE_POINTS, LinePoints, linePoints, QVector<glm::vec3>);
+        ADD_PROPERTY_TO_MAP(PROP_LINE_POINTS, LinePoints, linePoints, QVector<vec3>);
         ADD_PROPERTY_TO_MAP(PROP_HREF, Href, href, QString);
         ADD_PROPERTY_TO_MAP(PROP_DESCRIPTION, Description, description, QString);
         ADD_PROPERTY_TO_MAP(PROP_FACE_CAMERA, FaceCamera, faceCamera, bool);
         ADD_PROPERTY_TO_MAP(PROP_ACTION_DATA, ActionData, actionData, QByteArray);
-        ADD_PROPERTY_TO_MAP(PROP_NORMALS, Normals, normals, QVector<glm::vec3>);
-        ADD_PROPERTY_TO_MAP(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<glm::vec3>);
+        ADD_PROPERTY_TO_MAP(PROP_NORMALS, Normals, normals, QVector<vec3>);
+        ADD_PROPERTY_TO_MAP(PROP_STROKE_COLORS, StrokeColors, strokeColors, QVector<vec3>);
         ADD_PROPERTY_TO_MAP(PROP_STROKE_WIDTHS, StrokeWidths, strokeWidths, QVector<float>);
         ADD_PROPERTY_TO_MAP(PROP_IS_UV_MODE_STRETCH, IsUVModeStretch, isUVModeStretch, QVector<float>);
         ADD_PROPERTY_TO_MAP(PROP_X_TEXTURE_URL, XTextureURL, xTextureURL, QString);
@@ -2105,16 +2116,16 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_PARENT_ID, ParentID, parentID, QUuid);
         ADD_PROPERTY_TO_MAP(PROP_PARENT_JOINT_INDEX, ParentJointIndex, parentJointIndex, uint16_t);
 
-        ADD_PROPERTY_TO_MAP(PROP_LOCAL_POSITION, LocalPosition, localPosition, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_LOCAL_ROTATION, LocalRotation, localRotation, glm::quat);
-        ADD_PROPERTY_TO_MAP(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, glm::vec3);
-        ADD_PROPERTY_TO_MAP(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, glm::vec3);
+        ADD_PROPERTY_TO_MAP(PROP_LOCAL_POSITION, LocalPosition, localPosition, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_LOCAL_ROTATION, LocalRotation, localRotation, quat);
+        ADD_PROPERTY_TO_MAP(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, vec3);
+        ADD_PROPERTY_TO_MAP(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, vec3);
 
         ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS_SET, JointRotationsSet, jointRotationsSet, QVector<bool>);
-        ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<glm::quat>);
+        ADD_PROPERTY_TO_MAP(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<quat>);
         ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS_SET, JointTranslationsSet, jointTranslationsSet, QVector<bool>);
-        ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<glm::vec3>);
+        ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<vec3>);
         ADD_PROPERTY_TO_MAP(PROP_RELAY_PARENT_JOINTS, RelayParentJoints, relayParentJoints, bool);
 
         ADD_PROPERTY_TO_MAP(PROP_SHAPE, Shape, shape, QString);
@@ -2172,6 +2183,26 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_CLONE_AVATAR_ENTITY, CloneAvatarEntity, cloneAvatarEntity, bool);
         ADD_PROPERTY_TO_MAP(PROP_CLONE_ORIGIN_ID, CloneOriginID, cloneOriginID, QUuid);
 
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_GRABBABLE, Grab, grab, Grabbable, grabbable);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_KINEMATIC, Grab, grab, GrabKinematic, grabKinematic);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_FOLLOWS_CONTROLLER, Grab, grab, GrabFollowsController, grabFollowsController);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_TRIGGERABLE, Grab, grab, Triggerable, triggerable);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_EQUIPPABLE, Grab, grab, Equippable, equippable);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, Grab, grab,
+                                  EquippableLeftPosition, equippableLeftPosition);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, Grab, grab,
+                                  EquippableLeftRotation, equippableLeftRotation);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, Grab, grab,
+                                  EquippableRightPosition, equippableRightPosition);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, Grab, grab,
+                                  EquippableRightRotation, equippableRightRotation);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, Grab, grab,
+                                  EquippableIndicatorURL, equippableIndicatorURL);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, Grab, grab,
+                                  EquippableIndicatorScale, equippableIndicatorScale);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, Grab, grab,
+                                  EquippableIndicatorOffset, equippableIndicatorOffset);
+
         // FIXME - these are not yet handled
         //ADD_PROPERTY_TO_MAP(PROP_CREATED, Created, created, quint64);
 
@@ -2224,7 +2255,7 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
     // Always include the root octcode. This is only because the OctreeEditPacketSender will check these octcodes
     // to determine which server to send the changes to in the case of multiple jurisdictions. The root will be sent
     // to all servers.
-    glm::vec3 rootPosition(0);
+    vec3 rootPosition(0);
     float rootScale = 0.5f;
     unsigned char* octcode = pointToOctalCode(rootPosition.x, rootPosition.y, rootPosition.z, rootScale);
 
@@ -2309,7 +2340,6 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
             APPEND_ENTITY_PROPERTY(PROP_SCRIPT, properties.getScript());
             APPEND_ENTITY_PROPERTY(PROP_SCRIPT_TIMESTAMP, properties.getScriptTimestamp());
             APPEND_ENTITY_PROPERTY(PROP_SERVER_SCRIPTS, properties.getServerScripts());
-            APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
             APPEND_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, properties.getRegistrationPoint());
             APPEND_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, properties.getAngularVelocity());
             APPEND_ENTITY_PROPERTY(PROP_ANGULAR_DAMPING, properties.getAngularDamping());
@@ -2344,6 +2374,7 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
                 APPEND_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, properties.getCompoundShapeURL());
                 APPEND_ENTITY_PROPERTY(PROP_TEXTURES, properties.getTextures());
                 APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)(properties.getShapeType()));
+                APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
 
                 _staticAnimation.setProperties(properties);
                 _staticAnimation.appendToEditPacket(packetData, requestedProperties, propertyFlags, propertiesDidntFit, propertyCount, appendState);
@@ -2356,8 +2387,8 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
             }
 
             if (properties.getType() == EntityTypes::Light) {
-                APPEND_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, properties.getIsSpotlight());
                 APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
+                APPEND_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, properties.getIsSpotlight());
                 APPEND_ENTITY_PROPERTY(PROP_INTENSITY, properties.getIntensity());
                 APPEND_ENTITY_PROPERTY(PROP_FALLOFF_RADIUS, properties.getFalloffRadius());
                 APPEND_ENTITY_PROPERTY(PROP_EXPONENT, properties.getExponent());
@@ -2385,6 +2416,7 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
                 APPEND_ENTITY_PROPERTY(PROP_RADIUS_SPREAD, properties.getRadiusSpread());
                 APPEND_ENTITY_PROPERTY(PROP_RADIUS_START, properties.getRadiusStart());
                 APPEND_ENTITY_PROPERTY(PROP_RADIUS_FINISH, properties.getRadiusFinish());
+                APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
                 APPEND_ENTITY_PROPERTY(PROP_COLOR_SPREAD, properties.getColorSpread());
                 APPEND_ENTITY_PROPERTY(PROP_COLOR_START, properties.getColorStart());
                 APPEND_ENTITY_PROPERTY(PROP_COLOR_FINISH, properties.getColorFinish());
@@ -2445,11 +2477,13 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
             }
 
             if (properties.getType() == EntityTypes::Line) {
+                APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
                 APPEND_ENTITY_PROPERTY(PROP_LINE_WIDTH, properties.getLineWidth());
                 APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, properties.getLinePoints());
             }
 
             if (properties.getType() == EntityTypes::PolyLine) {
+                APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
                 APPEND_ENTITY_PROPERTY(PROP_LINE_WIDTH, properties.getLineWidth());
                 APPEND_ENTITY_PROPERTY(PROP_LINE_POINTS, properties.getLinePoints());
                 APPEND_ENTITY_PROPERTY(PROP_NORMALS, properties.getPackedNormals());
@@ -2464,6 +2498,7 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
                 properties.getType() == EntityTypes::Box ||
                 properties.getType() == EntityTypes::Sphere) {
                 APPEND_ENTITY_PROPERTY(PROP_SHAPE, properties.getShape());
+                APPEND_ENTITY_PROPERTY(PROP_COLOR, properties.getColor());
             }
 
             // Materials
@@ -2501,6 +2536,10 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
             APPEND_ENTITY_PROPERTY(PROP_CLONE_LIMIT, properties.getCloneLimit());
             APPEND_ENTITY_PROPERTY(PROP_CLONE_DYNAMIC, properties.getCloneDynamic());
             APPEND_ENTITY_PROPERTY(PROP_CLONE_AVATAR_ENTITY, properties.getCloneAvatarEntity());
+
+            _staticGrab.setProperties(properties);
+            _staticGrab.appendToEditPacket(packetData, requestedProperties, propertyFlags,
+                                           propertiesDidntFit, propertyCount, appendState);
         }
 
         if (propertyCount > 0) {
@@ -2562,7 +2601,7 @@ QByteArray EntityItemProperties::getPackedNormals() const {
     return packNormals(getNormals());
 }
 
-QByteArray EntityItemProperties::packNormals(const QVector<glm::vec3>& normals) const {
+QByteArray EntityItemProperties::packNormals(const QVector<vec3>& normals) const {
     int normalsSize = normals.size();
     QByteArray packedNormals = QByteArray(normalsSize * 6 + 1, '0');
     // add size of the array
@@ -2579,7 +2618,7 @@ QByteArray EntityItemProperties::packNormals(const QVector<glm::vec3>& normals)
 QByteArray EntityItemProperties::getPackedStrokeColors() const {
     return packStrokeColors(getStrokeColors());
 }
-QByteArray EntityItemProperties::packStrokeColors(const QVector<glm::vec3>& strokeColors) const {
+QByteArray EntityItemProperties::packStrokeColors(const QVector<vec3>& strokeColors) const {
     int strokeColorsSize = strokeColors.size();
     QByteArray packedStrokeColors = QByteArray(strokeColorsSize * 3 + 1, '0');
 
@@ -2589,9 +2628,9 @@ QByteArray EntityItemProperties::packStrokeColors(const QVector<glm::vec3>& stro
 
     for (int i = 0; i < strokeColorsSize; i++) {
         // add the color to the QByteArray
-        packedStrokeColors[i * 3 + 1] = strokeColors[i].r * 255;
-        packedStrokeColors[i * 3 + 2] = strokeColors[i].g * 255;
-        packedStrokeColors[i * 3 + 3] = strokeColors[i].b * 255;
+        packedStrokeColors[i * 3 + 1] = strokeColors[i].x * 255;
+        packedStrokeColors[i * 3 + 2] = strokeColors[i].y * 255;
+        packedStrokeColors[i * 3 + 3] = strokeColors[i].z * 255;
     }
     return packedStrokeColors;
 }
@@ -2680,13 +2719,13 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     processedBytes += propertyFlags.getEncodedLength();
 
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SIMULATION_OWNER, QByteArray, setSimulationOwner);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POSITION, glm::vec3, setPosition);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DIMENSIONS, glm::vec3, setDimensions);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ROTATION, glm::quat, setRotation);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POSITION, vec3, setPosition);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DIMENSIONS, vec3, setDimensions);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ROTATION, quat, setRotation);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DENSITY, float, setDensity);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VELOCITY, glm::vec3, setVelocity);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_GRAVITY, glm::vec3, setGravity);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION, glm::vec3, setAcceleration);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VELOCITY, vec3, setVelocity);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_GRAVITY, vec3, setGravity);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION, vec3, setAcceleration);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_DAMPING, float, setDamping);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RESTITUTION, float, setRestitution);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FRICTION, float, setFriction);
@@ -2694,9 +2733,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SCRIPT, QString, setScript);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SCRIPT_TIMESTAMP, quint64, setScriptTimestamp);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SERVER_SCRIPTS, QString, setServerScripts);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, xColor, setColor);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_REGISTRATION_POINT, glm::vec3, setRegistrationPoint);
-    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_VELOCITY, glm::vec3, setAngularVelocity);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_REGISTRATION_POINT, vec3, setRegistrationPoint);
+    READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_VELOCITY, vec3, setAngularVelocity);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_DAMPING, float, setAngularDamping);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VISIBLE, bool, setVisible);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CAN_CAST_SHADOW, bool, setCanCastShadow);
@@ -2719,8 +2757,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     if (properties.getType() == EntityTypes::Text) {
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT, QString, setText);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_HEIGHT, float, setLineHeight);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT_COLOR, xColor, setTextColor);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_BACKGROUND_COLOR, xColor, setBackgroundColor);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXT_COLOR, u8vec3Color, setTextColor);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_BACKGROUND_COLOR, u8vec3Color, setBackgroundColor);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FACE_CAMERA, bool, setFaceCamera);
     }
 
@@ -2729,19 +2767,20 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXTURES, QString, setTextures);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHAPE_TYPE, ShapeType, setShapeType);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
 
         properties.getAnimation().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);
 
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS_SET, QVector<bool>, setJointRotationsSet);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS, QVector<glm::quat>, setJointRotations);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_ROTATIONS, QVector<quat>, setJointRotations);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS_SET, QVector<bool>, setJointTranslationsSet);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS, QVector<glm::vec3>, setJointTranslations);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_JOINT_TRANSLATIONS, QVector<vec3>, setJointTranslations);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RELAY_PARENT_JOINTS, bool, setRelayParentJoints);
     }
 
     if (properties.getType() == EntityTypes::Light) {
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, xColor, setColor);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_INTENSITY, float, setIntensity);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FALLOFF_RADIUS, float, setFalloffRadius);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EXPONENT, float, setExponent);
@@ -2756,22 +2795,23 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RATE, float, setEmitRate);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_SPEED, float, setEmitSpeed);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SPEED_SPREAD, float, setSpeedSpread);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, glm::quat, setEmitOrientation);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_DIMENSIONS, glm::vec3, setEmitDimensions);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ORIENTATION, quat, setEmitOrientation);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_DIMENSIONS, vec3, setEmitDimensions);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_START, float, setPolarStart);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_POLAR_FINISH, float, setPolarFinish);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_START, float, setAzimuthStart);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AZIMUTH_FINISH, float, setAzimuthFinish);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EMIT_ACCELERATION, vec3, setEmitAcceleration);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ACCELERATION_SPREAD, vec3, setAccelerationSpread);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARTICLE_RADIUS, float, setParticleRadius);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_SPREAD, float, setRadiusSpread);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_START, float, setRadiusStart);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_RADIUS_FINISH, float, setRadiusFinish);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_SPREAD, xColor, setColorSpread);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_START, vec3, setColorStart);
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_FINISH, vec3, setColorFinish);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_SPREAD, u8vec3Color, setColorSpread);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_START, vec3Color, setColorStart);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR_FINISH, vec3Color, setColorFinish);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_SPREAD, float, setAlphaSpread);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_START, float, setAlphaStart);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ALPHA_FINISH, float, setAlphaFinish);
@@ -2794,7 +2834,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FLYING_ALLOWED, bool, setFlyingAllowed);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_GHOSTING_ALLOWED, bool, setGhostingAllowed);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_FILTER_URL, QString, setFilterURL);
- 
+
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_HAZE_MODE, uint32_t, setHazeMode);
         properties.getHaze().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);
 
@@ -2807,7 +2847,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     }
 
     if (properties.getType() == EntityTypes::PolyVox) {
-        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_VOLUME_SIZE, glm::vec3, setVoxelVolumeSize);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_VOLUME_SIZE, vec3, setVoxelVolumeSize);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_DATA, QByteArray, setVoxelData);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VOXEL_SURFACE_STYLE, uint16_t, setVoxelSurfaceStyle);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_X_TEXTURE_URL, QString, setXTextureURL);
@@ -2822,14 +2862,16 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     }
 
     if (properties.getType() == EntityTypes::Line) {
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
         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_LINE_POINTS, QVector<vec3>, setLinePoints);
     }
 
 
     if (properties.getType() == EntityTypes::PolyLine) {
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
         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_LINE_POINTS, QVector<vec3>, setLinePoints);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NORMALS, QByteArray, setPackedNormals);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_COLORS, QByteArray, setPackedStrokeColors);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
@@ -2843,6 +2885,7 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         properties.getType() == EntityTypes::Box ||
         properties.getType() == EntityTypes::Sphere) {
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHAPE, QString, setShape);
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLOR, u8vec3Color, setColor);
     }
 
     // Materials
@@ -2881,6 +2924,8 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CLONE_DYNAMIC, bool, setCloneDynamic);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CLONE_AVATAR_ENTITY, bool, setCloneAvatarEntity);
 
+    properties.getGrab().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);
+
     return valid;
 }
 
@@ -2888,14 +2933,14 @@ void EntityItemProperties::setPackedNormals(const QByteArray& value) {
     setNormals(unpackNormals(value));
 }
 
-QVector<glm::vec3> EntityItemProperties::unpackNormals(const QByteArray& normals) {
+QVector<vec3> EntityItemProperties::unpackNormals(const QByteArray& normals) {
     // the size of the vector is packed first
-    QVector<glm::vec3> unpackedNormals = QVector<glm::vec3>((int)normals[0]);
+    QVector<vec3> unpackedNormals = QVector<vec3>((int)normals[0]);
 
     if ((int)normals[0] == normals.size() / 6) {
         int j = 0;
         for (int i = 1; i < normals.size();) {
-            glm::vec3 aux = glm::vec3();
+            vec3 aux = vec3();
             i += unpackFloatVec3FromSignedTwoByteFixed((unsigned char*)normals.data() + i, aux, 15);
             unpackedNormals[j] = aux;
             j++;
@@ -2911,9 +2956,9 @@ void EntityItemProperties::setPackedStrokeColors(const QByteArray& value) {
     setStrokeColors(unpackStrokeColors(value));
 }
 
-QVector<glm::vec3> EntityItemProperties::unpackStrokeColors(const QByteArray& strokeColors) {
+QVector<vec3> EntityItemProperties::unpackStrokeColors(const QByteArray& strokeColors) {
     // the size of the vector is packed first
-    QVector<glm::vec3> unpackedStrokeColors = QVector<glm::vec3>((int)strokeColors[0]);
+    QVector<vec3> unpackedStrokeColors = QVector<vec3>((int)strokeColors[0]);
    
     if ((int)strokeColors[0] == strokeColors.size() / 3) {
         int j = 0;
@@ -3120,6 +3165,7 @@ void EntityItemProperties::markAllChanged() {
     _skybox.markAllChanged();
     _haze.markAllChanged();
     _bloom.markAllChanged();
+    _grab.markAllChanged();
 
     _sourceUrlChanged = true;
     _voxelVolumeSizeChanged = true;
@@ -3185,10 +3231,10 @@ void EntityItemProperties::markAllChanged() {
 AABox EntityItemProperties::getAABox() const {
 
     // _position represents the position of the registration point.
-    glm::vec3 registrationRemainder = glm::vec3(1.0f, 1.0f, 1.0f) - _registrationPoint;
+    vec3 registrationRemainder = vec3(1.0f) - _registrationPoint;
 
-    glm::vec3 unrotatedMinRelativeToEntity = - (_dimensions * _registrationPoint);
-    glm::vec3 unrotatedMaxRelativeToEntity = _dimensions * registrationRemainder;
+    vec3 unrotatedMinRelativeToEntity = - (_dimensions * _registrationPoint);
+    vec3 unrotatedMaxRelativeToEntity = _dimensions * registrationRemainder;
     Extents unrotatedExtentsRelativeToRegistrationPoint = { unrotatedMinRelativeToEntity, unrotatedMaxRelativeToEntity };
     Extents rotatedExtentsRelativeToRegistrationPoint = unrotatedExtentsRelativeToRegistrationPoint.getRotated(_rotation);
 
@@ -3198,9 +3244,12 @@ AABox EntityItemProperties::getAABox() const {
     return AABox(rotatedExtentsRelativeToRegistrationPoint);
 }
 
-bool EntityItemProperties::hasTerseUpdateChanges() const {
-    // a TerseUpdate includes the transform and its derivatives
-    return _positionChanged || _velocityChanged || _rotationChanged || _angularVelocityChanged || _accelerationChanged;
+bool EntityItemProperties::hasTransformOrVelocityChanges() const {
+    return _positionChanged ||_localPositionChanged
+        || _rotationChanged || _localRotationChanged
+        || _velocityChanged || _localVelocityChanged
+        || _angularVelocityChanged || _localAngularVelocityChanged
+        || _accelerationChanged;
 }
 
 bool EntityItemProperties::hasMiscPhysicsChanges() const {
@@ -3209,6 +3258,56 @@ bool EntityItemProperties::hasMiscPhysicsChanges() const {
         _compoundShapeURLChanged || _dynamicChanged || _collisionlessChanged || _collisionMaskChanged;
 }
 
+bool EntityItemProperties::hasSimulationRestrictedChanges() const {
+    return _positionChanged || _localPositionChanged
+        || _rotationChanged || _localRotationChanged
+        || _velocityChanged || _localVelocityChanged
+        || _angularVelocityChanged || _localAngularVelocityChanged
+        || _accelerationChanged
+        || _parentIDChanged || _parentJointIndexChanged;
+}
+
+void EntityItemProperties::copySimulationRestrictedProperties(const EntityItemPointer& entity) {
+    if (!_parentIDChanged) {
+        setParentID(entity->getParentID());
+    }
+    if (!_parentJointIndexChanged) {
+        setParentJointIndex(entity->getParentJointIndex());
+    }
+    if (!_localPositionChanged && !_positionChanged) {
+        setPosition(entity->getWorldPosition());
+    }
+    if (!_localRotationChanged && !_rotationChanged) {
+        setRotation(entity->getWorldOrientation());
+    }
+    if (!_localVelocityChanged && !_velocityChanged) {
+        setVelocity(entity->getWorldVelocity());
+    }
+    if (!_localAngularVelocityChanged && !_angularVelocityChanged) {
+        setAngularVelocity(entity->getWorldAngularVelocity());
+    }
+    if (!_accelerationChanged) {
+        setAcceleration(entity->getAcceleration());
+    }
+    if (!_localDimensionsChanged && !_dimensionsChanged) {
+        setDimensions(entity->getScaledDimensions());
+    }
+}
+
+void EntityItemProperties::clearSimulationRestrictedProperties() {
+    _positionChanged = false;
+    _localPositionChanged = false;
+    _rotationChanged = false;
+    _localRotationChanged = false;
+    _velocityChanged = false;
+    _localVelocityChanged = false;
+    _angularVelocityChanged = false;
+    _localAngularVelocityChanged = false;
+    _accelerationChanged = false;
+    _parentIDChanged = false;
+    _parentJointIndexChanged = false;
+}
+
 void EntityItemProperties::clearSimulationOwner() {
     _simulationOwner.clear();
     _simulationOwnerChanged = true;
@@ -3227,6 +3326,20 @@ void EntityItemProperties::setSimulationOwner(const QByteArray& data) {
     }
 }
 
+uint8_t EntityItemProperties::computeSimulationBidPriority() const {
+    uint8_t priority = 0;
+    if (_parentIDChanged || _parentJointIndexChanged) {
+        // we need higher simulation ownership priority to chang parenting info
+        priority = SCRIPT_GRAB_SIMULATION_PRIORITY;
+    } else if ( _positionChanged || _localPositionChanged
+            || _rotationChanged || _localRotationChanged
+            || _velocityChanged || _localVelocityChanged
+            || _angularVelocityChanged || _localAngularVelocityChanged) {
+        priority = SCRIPT_POKE_SIMULATION_PRIORITY;
+    }
+    return priority;
+}
+
 QList<QString> EntityItemProperties::listChangedProperties() {
     QList<QString> out;
     if (containsPositionChange()) {
@@ -3654,6 +3767,7 @@ QList<QString> EntityItemProperties::listChangedProperties() {
     getSkybox().listChangedProperties(out);
     getHaze().listChangedProperties(out);
     getBloom().listChangedProperties(out);
+    getGrab().listChangedProperties(out);
 
     return out;
 }

libraries/entities/src/EntityItemProperties.h

@@ -58,6 +58,9 @@ const std::array<ComponentPair, COMPONENT_MODE_ITEM_COUNT> COMPONENT_MODES = { {
     ComponentPair { COMPONENT_MODE_ENABLED, { "enabled" } }
 } };
 
+using vec3Color = glm::vec3;
+using u8vec3Color = glm::u8vec3;
+
 /// A collection of properties of an entity item used in the scripting API. Translates between the actual properties of an
 /// entity and a JavaScript style hash/QScriptValue storing a set of properties. Used in scripting to set/get the complete
 /// set of entity item properties via JavaScript hashes/QScriptValues
@@ -137,10 +140,10 @@ public:
     DEFINE_PROPERTY_REF(PROP_SCRIPT, Script, script, QString, ENTITY_ITEM_DEFAULT_SCRIPT);
     DEFINE_PROPERTY(PROP_SCRIPT_TIMESTAMP, ScriptTimestamp, scriptTimestamp, quint64, ENTITY_ITEM_DEFAULT_SCRIPT_TIMESTAMP);
     DEFINE_PROPERTY_REF(PROP_COLLISION_SOUND_URL, CollisionSoundURL, collisionSoundURL, QString, ENTITY_ITEM_DEFAULT_COLLISION_SOUND_URL);
-    DEFINE_PROPERTY_REF(PROP_COLOR, Color, color, xColor, ParticleEffectEntityItem::DEFAULT_XCOLOR);
-    DEFINE_PROPERTY_REF(PROP_COLOR_SPREAD, ColorSpread, colorSpread, xColor, ParticleEffectEntityItem::DEFAULT_XCOLOR_SPREAD);
-    DEFINE_PROPERTY_REF(PROP_COLOR_START, ColorStart, colorStart, vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
-    DEFINE_PROPERTY_REF(PROP_COLOR_FINISH, ColorFinish, colorFinish, vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
+    DEFINE_PROPERTY_REF(PROP_COLOR, Color, color, u8vec3Color, particle::DEFAULT_COLOR);
+    DEFINE_PROPERTY_REF(PROP_COLOR_SPREAD, ColorSpread, colorSpread, u8vec3Color, particle::DEFAULT_COLOR_SPREAD);
+    DEFINE_PROPERTY_REF(PROP_COLOR_START, ColorStart, colorStart, glm::vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
+    DEFINE_PROPERTY_REF(PROP_COLOR_FINISH, ColorFinish, colorFinish, glm::vec3, particle::DEFAULT_COLOR_UNINITIALIZED);
     DEFINE_PROPERTY(PROP_ALPHA, Alpha, alpha, float, particle::DEFAULT_ALPHA);
     DEFINE_PROPERTY(PROP_ALPHA_SPREAD, AlphaSpread, alphaSpread, float, particle::DEFAULT_ALPHA_SPREAD);
     DEFINE_PROPERTY(PROP_ALPHA_START, AlphaStart, alphaStart, float, particle::DEFAULT_ALPHA_START);
@@ -164,8 +167,8 @@ public:
     DEFINE_PROPERTY_REF(PROP_SIMULATION_OWNER, SimulationOwner, simulationOwner, SimulationOwner, SimulationOwner());
     DEFINE_PROPERTY_REF(PROP_TEXT, Text, text, QString, TextEntityItem::DEFAULT_TEXT);
     DEFINE_PROPERTY(PROP_LINE_HEIGHT, LineHeight, lineHeight, float, TextEntityItem::DEFAULT_LINE_HEIGHT);
-    DEFINE_PROPERTY_REF(PROP_TEXT_COLOR, TextColor, textColor, xColor, TextEntityItem::DEFAULT_TEXT_COLOR);
-    DEFINE_PROPERTY_REF(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, xColor, TextEntityItem::DEFAULT_BACKGROUND_COLOR);
+    DEFINE_PROPERTY_REF(PROP_TEXT_COLOR, TextColor, textColor, u8vec3Color, TextEntityItem::DEFAULT_TEXT_COLOR);
+    DEFINE_PROPERTY_REF(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, u8vec3Color, TextEntityItem::DEFAULT_BACKGROUND_COLOR);
     DEFINE_PROPERTY_REF_ENUM(PROP_SHAPE_TYPE, ShapeType, shapeType, ShapeType, SHAPE_TYPE_NONE);
     DEFINE_PROPERTY(PROP_MAX_PARTICLES, MaxParticles, maxParticles, quint32, particle::DEFAULT_MAX_PARTICLES);
     DEFINE_PROPERTY(PROP_LIFESPAN, Lifespan, lifespan, float, particle::DEFAULT_LIFESPAN);
@@ -206,7 +209,7 @@ public:
     DEFINE_PROPERTY_GROUP(Animation, animation, AnimationPropertyGroup);
     DEFINE_PROPERTY_REF(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString, "");
     DEFINE_PROPERTY(PROP_LINE_WIDTH, LineWidth, lineWidth, float, LineEntityItem::DEFAULT_LINE_WIDTH);
-    DEFINE_PROPERTY_REF(LINE_POINTS, LinePoints, linePoints, QVector<glm::vec3>, QVector<glm::vec3>());
+    DEFINE_PROPERTY_REF(LINE_POINTS, LinePoints, linePoints, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
     DEFINE_PROPERTY_REF(PROP_HREF, Href, href, QString, "");
     DEFINE_PROPERTY_REF(PROP_DESCRIPTION, Description, description, QString, "");
     DEFINE_PROPERTY(PROP_FACE_CAMERA, FaceCamera, faceCamera, bool, TextEntityItem::DEFAULT_FACE_CAMERA);
@@ -233,8 +236,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, glm::vec2, glm::vec2(0.0f));
+    DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, glm::vec2, glm::vec2(1.0f));
     DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float, 0);
     DEFINE_PROPERTY_REF(PROP_MATERIAL_DATA, MaterialData, materialData, QString, "");
 
@@ -260,16 +263,16 @@ public:
     DEFINE_PROPERTY_REF(PROP_STATIC_CERTIFICATE_VERSION, StaticCertificateVersion, staticCertificateVersion, quint32, ENTITY_ITEM_DEFAULT_STATIC_CERTIFICATE_VERSION);
 
     // these are used when bouncing location data into and out of scripts
-    DEFINE_PROPERTY_REF(PROP_LOCAL_POSITION, LocalPosition, localPosition, vec3, ENTITY_ITEM_ZERO_VEC3);
+    DEFINE_PROPERTY_REF(PROP_LOCAL_POSITION, LocalPosition, localPosition, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
     DEFINE_PROPERTY_REF(PROP_LOCAL_ROTATION, LocalRotation, localRotation, quat, ENTITY_ITEM_DEFAULT_ROTATION);
-    DEFINE_PROPERTY_REF(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, vec3, ENTITY_ITEM_ZERO_VEC3);
-    DEFINE_PROPERTY_REF(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, vec3, ENTITY_ITEM_ZERO_VEC3);
-    DEFINE_PROPERTY_REF(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, vec3, ENTITY_ITEM_ZERO_VEC3);
+    DEFINE_PROPERTY_REF(PROP_LOCAL_VELOCITY, LocalVelocity, localVelocity, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
+    DEFINE_PROPERTY_REF(PROP_LOCAL_ANGULAR_VELOCITY, LocalAngularVelocity, localAngularVelocity, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
+    DEFINE_PROPERTY_REF(PROP_LOCAL_DIMENSIONS, LocalDimensions, localDimensions, glm::vec3, ENTITY_ITEM_ZERO_VEC3);
 
     DEFINE_PROPERTY_REF(PROP_JOINT_ROTATIONS_SET, JointRotationsSet, jointRotationsSet, QVector<bool>, QVector<bool>());
     DEFINE_PROPERTY_REF(PROP_JOINT_ROTATIONS, JointRotations, jointRotations, QVector<glm::quat>, QVector<glm::quat>());
     DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS_SET, JointTranslationsSet, jointTranslationsSet, QVector<bool>, QVector<bool>());
-    DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<glm::vec3>, QVector<glm::vec3>());
+    DEFINE_PROPERTY_REF(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<glm::vec3>, ENTITY_ITEM_DEFAULT_EMPTY_VEC3_QVEC);
 
     DEFINE_PROPERTY(PROP_FLYING_ALLOWED, FlyingAllowed, flyingAllowed, bool, ZoneEntityItem::DEFAULT_FLYING_ALLOWED);
     DEFINE_PROPERTY(PROP_GHOSTING_ALLOWED, GhostingAllowed, ghostingAllowed, bool, ZoneEntityItem::DEFAULT_GHOSTING_ALLOWED);
@@ -292,6 +295,8 @@ public:
     DEFINE_PROPERTY(PROP_CLONE_AVATAR_ENTITY, CloneAvatarEntity, cloneAvatarEntity, bool, ENTITY_ITEM_DEFAULT_CLONE_AVATAR_ENTITY);
     DEFINE_PROPERTY_REF(PROP_CLONE_ORIGIN_ID, CloneOriginID, cloneOriginID, QUuid, ENTITY_ITEM_DEFAULT_CLONE_ORIGIN_ID);
 
+    DEFINE_PROPERTY_GROUP(Grab, grab, GrabPropertyGroup);
+
     static QString getComponentModeString(uint32_t mode);
     static QString getComponentModeAsString(uint32_t mode);
 
@@ -344,13 +349,18 @@ public:
 
     void setCreated(QDateTime& v);
 
-    bool hasTerseUpdateChanges() const;
+    bool hasTransformOrVelocityChanges() const;
     bool hasMiscPhysicsChanges() const;
 
+    bool hasSimulationRestrictedChanges() const;
+    void copySimulationRestrictedProperties(const EntityItemPointer& entity);
+    void clearSimulationRestrictedProperties();
+
     void clearSimulationOwner();
     void setSimulationOwner(const QUuid& id, uint8_t priority);
     void setSimulationOwner(const QByteArray& data);
     void setSimulationPriority(uint8_t priority) { _simulationOwner.setPriority(priority); }
+    uint8_t computeSimulationBidPriority() const;
 
     void setActionDataDirty() { _actionDataChanged = true; }
 

libraries/entities/src/EntityItemPropertiesMacros.h

@@ -101,8 +101,11 @@
         changedProperties += P;    \
     }
 
-inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec2& v) { return vec2toScriptValue(e, v); }
-inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec3& v) { return vec3toScriptValue(e, v); }
+inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec2& v) { return vec2ToScriptValue(e, v); }
+inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::vec3& v) { return vec3ToScriptValue(e, v); }
+inline QScriptValue vec3Color_convertScriptValue(QScriptEngine* e, const glm::vec3& v) { return vec3ColorToScriptValue(e, v); }
+inline QScriptValue convertScriptValue(QScriptEngine* e, const glm::u8vec3& v) { return u8vec3ToScriptValue(e, v); }
+inline QScriptValue u8vec3Color_convertScriptValue(QScriptEngine* e, const glm::u8vec3& v) { return u8vec3ColorToScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, float v) { return QScriptValue(v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, int v) { return QScriptValue(v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, bool v) { return QScriptValue(v); }
@@ -111,10 +114,10 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, quint32 v) { return QSc
 inline QScriptValue convertScriptValue(QScriptEngine* e, quint64 v) { return QScriptValue((qsreal)v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QString& v) { return QScriptValue(v); }
 
-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 qVectorVec3ToScriptValue(e, v); }
+inline QScriptValue qVectorVec3Color_convertScriptValue(QScriptEngine* e, const QVector<glm::vec3>& v) {return qVectorVec3ColorToScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<glm::quat>& v) {return qVectorQuatToScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<bool>& v) {return qVectorBoolToScriptValue(e, v); }
 inline QScriptValue convertScriptValue(QScriptEngine* e, const QVector<float>& v) { return qVectorFloatToScriptValue(e, v); }
@@ -128,8 +131,6 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const EntityItemID& v)
 
 inline QScriptValue convertScriptValue(QScriptEngine* e, const AACube& v) { return aaCubeToScriptValue(e, v); }
 
-
-
 #define COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(X,G,g,P,p) \
     if ((desiredProperties.isEmpty() || desiredProperties.getHasProperty(X)) && \
         (!skipDefaults || defaultEntityProperties.get##G().get##P() != get##P())) { \
@@ -142,6 +143,18 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const AACube& v) { retu
         properties.setProperty(#g, groupProperties); \
     }
 
+#define COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_TYPED(X,G,g,P,p,T) \
+    if ((desiredProperties.isEmpty() || desiredProperties.getHasProperty(X)) && \
+        (!skipDefaults || defaultEntityProperties.get##G().get##P() != get##P())) { \
+        QScriptValue groupProperties = properties.property(#g); \
+        if (!groupProperties.isValid()) { \
+            groupProperties = engine->newObject(); \
+        } \
+        QScriptValue V = T##_convertScriptValue(engine, get##P()); \
+        groupProperties.setProperty(#p, V); \
+        properties.setProperty(#g, groupProperties); \
+    }
+
 #define COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_GETTER(X,G,g,P,p,M)                       \
     if ((desiredProperties.isEmpty() || desiredProperties.getHasProperty(X)) &&       \
         (!skipDefaults || defaultEntityProperties.get##G().get##P() != get##P())) {   \
@@ -161,6 +174,13 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const AACube& v) { retu
         properties.setProperty(#P, V); \
     }
 
+#define COPY_PROPERTY_TO_QSCRIPTVALUE_TYPED(p,P,T) \
+    if ((_desiredProperties.isEmpty() || _desiredProperties.getHasProperty(p)) && \
+        (!skipDefaults || defaultEntityProperties._##P != _##P)) { \
+        QScriptValue V = T##_convertScriptValue(engine, _##P); \
+        properties.setProperty(#P, V); \
+    }
+
 #define COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER_NO_SKIP(P, G) \
     properties.setProperty(#P, G);
 
@@ -171,6 +191,13 @@ inline QScriptValue convertScriptValue(QScriptEngine* e, const AACube& v) { retu
         properties.setProperty(#P, V); \
     }
 
+#define COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER_TYPED(p, P, G, T) \
+    if ((_desiredProperties.isEmpty() || _desiredProperties.getHasProperty(p)) && \
+        (!skipDefaults || defaultEntityProperties._##P != _##P)) { \
+        QScriptValue V = T##_convertScriptValue(engine, G); \
+        properties.setProperty(#P, V); \
+    }
+
 // same as COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER but uses #X instead of #P in the setProperty() step
 #define COPY_PROXY_PROPERTY_TO_QSCRIPTVALUE_GETTER(p, P, X, G) \
     if (((!psuedoPropertyFlagsButDesiredEmpty && _desiredProperties.isEmpty()) || _desiredProperties.getHasProperty(p)) && \
@@ -205,7 +232,6 @@ inline QUuid QUuid_convertFromScriptValue(const QScriptValue& v, bool& isValid)
 inline EntityItemID EntityItemID_convertFromScriptValue(const QScriptValue& v, bool& isValid) { isValid = true; return v.toVariant().toUuid(); }
 
 
-
 inline QDateTime QDateTime_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
     isValid = true;
     auto result = QDateTime::fromString(v.toVariant().toString().trimmed(), Qt::ISODate);
@@ -213,8 +239,6 @@ inline QDateTime QDateTime_convertFromScriptValue(const QScriptValue& v, bool& i
     return result;
 }
 
-
-
 inline QByteArray QByteArray_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
     isValid = true;
     QString b64 = v.toVariant().toString().trimmed();
@@ -222,49 +246,31 @@ inline QByteArray QByteArray_convertFromScriptValue(const QScriptValue& v, bool&
 }
 
 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);
+    isValid = true;
+    glm::vec2 vec2;
+    vec2FromScriptValue(v, vec2);
+    return vec2;
 }
 
 inline glm::vec3 vec3_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
-    isValid = false; /// assume it can't be converted
-    QScriptValue x = v.property("x");
-    QScriptValue y = v.property("y");
-    QScriptValue z = v.property("z");
-    if (!x.isValid()) {
-        x = v.property("red");
-    }
-    if (!y.isValid()) {
-        y = v.property("green");
-    }
-    if (!z.isValid()) {
-        z = v.property("blue");
-    }
-    if (x.isValid() && y.isValid() && z.isValid()) {
-        glm::vec3 newValue(0);
-        newValue.x = x.toVariant().toFloat();
-        newValue.y = y.toVariant().toFloat();
-        newValue.z = z.toVariant().toFloat();
-        isValid = !glm::isnan(newValue.x) &&
-                  !glm::isnan(newValue.y) &&
-                  !glm::isnan(newValue.z);
-        if (isValid) {
-            return newValue;
-        }
-    }
-    return glm::vec3(0);
+    isValid = true;
+    glm::vec3 vec3;
+    vec3FromScriptValue(v, vec3);
+    return vec3;
+}
+
+inline glm::vec3 vec3Color_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
+    isValid = true;
+    glm::vec3 vec3;
+    vec3FromScriptValue(v, vec3);
+    return vec3;
+}
+
+inline glm::u8vec3 u8vec3Color_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
+    isValid = true;
+    glm::u8vec3 vec3;
+    u8vec3FromScriptValue(v, vec3);
+    return vec3;
 }
 
 inline AACube AACube_convertFromScriptValue(const QScriptValue& v, bool& isValid) {
@@ -317,31 +323,6 @@ inline glm::quat quat_convertFromScriptValue(const QScriptValue& v, bool& isVali
     return glm::quat();
 }
 
-inline xColor xColor_convertFromScriptValue(const QScriptValue& v, bool& isValid) { 
-    xColor newValue { 255, 255, 255 };
-    isValid = false; /// assume it can't be converted
-    QScriptValue r = v.property("red");
-    QScriptValue g = v.property("green");
-    QScriptValue b = v.property("blue");
-    if (!r.isValid()) {
-        r = v.property("x");
-    }
-    if (!g.isValid()) {
-        g = v.property("y");
-    }
-    if (!b.isValid()) {
-        b = v.property("z");
-    }
-    if (r.isValid() && g.isValid() && b.isValid()) {
-        newValue.red = r.toVariant().toInt();
-        newValue.green = g.toVariant().toInt();
-        newValue.blue = b.toVariant().toInt();
-        isValid = true;
-    }
-    return newValue;
-}
-
-
 #define COPY_PROPERTY_IF_CHANGED(P) \
 {                                   \
     if (other._##P##Changed) {      \

libraries/entities/src/EntityPropertyFlags.cpp

@@ -0,0 +1,207 @@
+
+#include "EntityPropertyFlags.h"
+
+
+QDebug& operator<<(QDebug& dbg, const EntityPropertyFlags& f) {
+    QString result = "[ ";
+
+    result = f.getHasProperty(PROP_PAGED_PROPERTY) ? result + "pagedProperty " : result;
+    result = f.getHasProperty(PROP_CUSTOM_PROPERTIES_INCLUDED) ? result + "customPropertiesIncluded " : result;
+    result = f.getHasProperty(PROP_VISIBLE) ? result + "visible " : result;
+    result = f.getHasProperty(PROP_CAN_CAST_SHADOW) ? result + "canCastShadow " : result;
+    result = f.getHasProperty(PROP_POSITION) ? result + "position " : result;
+    result = f.getHasProperty(PROP_DIMENSIONS) ? result + "dimensions " : result;
+    result = f.getHasProperty(PROP_ROTATION) ? result + "rotation " : result;
+    result = f.getHasProperty(PROP_DENSITY) ? result + "density " : result;
+    result = f.getHasProperty(PROP_VELOCITY) ? result + "velocity " : result;
+    result = f.getHasProperty(PROP_GRAVITY) ? result + "gravity " : result;
+    result = f.getHasProperty(PROP_DAMPING) ? result + "damping " : result;
+    result = f.getHasProperty(PROP_LIFETIME) ? result + "lifetime " : result;
+    result = f.getHasProperty(PROP_SCRIPT) ? result + "script " : result;
+    result = f.getHasProperty(PROP_COLOR) ? result + "color " : result;
+    result = f.getHasProperty(PROP_MODEL_URL) ? result + "modelUrl " : result;
+    result = f.getHasProperty(PROP_ANIMATION_URL) ? result + "animationUrl " : result;
+    result = f.getHasProperty(PROP_ANIMATION_FPS) ? result + "animationFps " : result;
+    result = f.getHasProperty(PROP_ANIMATION_FRAME_INDEX) ? result + "animationFrameIndex " : result;
+    result = f.getHasProperty(PROP_ANIMATION_PLAYING) ? result + "animationPlaying " : result;
+    result = f.getHasProperty(PROP_ANIMATION_ALLOW_TRANSLATION) ? result + "animationAllowTranslation " : result;
+    result = f.getHasProperty(PROP_RELAY_PARENT_JOINTS) ? result + "relayParentJoints " : result;
+    result = f.getHasProperty(PROP_REGISTRATION_POINT) ? result + "registrationPoint " : result;
+    result = f.getHasProperty(PROP_ANGULAR_VELOCITY) ? result + "angularVelocity " : result;
+    result = f.getHasProperty(PROP_ANGULAR_DAMPING) ? result + "angularDamping " : result;
+    result = f.getHasProperty(PROP_COLLISIONLESS) ? result + "collisionless " : result;
+    result = f.getHasProperty(PROP_DYNAMIC) ? result + "dynamic " : result;
+    result = f.getHasProperty(PROP_IS_SPOTLIGHT) ? result + "isSpotlight " : result;
+    result = f.getHasProperty(PROP_DIFFUSE_COLOR) ? result + "diffuseColor " : result;
+    result = f.getHasProperty(PROP_AMBIENT_COLOR_UNUSED) ? result + "ambientColorUnused " : result;
+    result = f.getHasProperty(PROP_SPECULAR_COLOR_UNUSED) ? result + "specularColorUnused " : result;
+    result = f.getHasProperty(PROP_INTENSITY) ? result + "intensity " : result;
+    result = f.getHasProperty(PROP_LINEAR_ATTENUATION_UNUSED) ? result + "linearAttenuationUnused " : result;
+    result = f.getHasProperty(PROP_QUADRATIC_ATTENUATION_UNUSED) ? result + "quadraticAttenuationUnused " : result;
+    result = f.getHasProperty(PROP_EXPONENT) ? result + "exponent " : result;
+    result = f.getHasProperty(PROP_CUTOFF) ? result + "cutoff " : result;
+    result = f.getHasProperty(PROP_LOCKED) ? result + "locked " : result;
+    result = f.getHasProperty(PROP_TEXTURES) ? result + "textures " : result;
+    result = f.getHasProperty(PROP_ANIMATION_SETTINGS_UNUSED) ? result + "animationSettingsUnused " : result;
+    result = f.getHasProperty(PROP_USER_DATA) ? result + "userData " : result;
+    result = f.getHasProperty(PROP_SHAPE_TYPE) ? result + "shapeType " : result;
+    result = f.getHasProperty(PROP_MAX_PARTICLES) ? result + "maxParticles " : result;
+    result = f.getHasProperty(PROP_LIFESPAN) ? result + "lifespan " : result;
+    result = f.getHasProperty(PROP_EMIT_RATE) ? result + "emitRate " : result;
+    result = f.getHasProperty(PROP_EMIT_SPEED) ? result + "emitSpeed " : result;
+    result = f.getHasProperty(PROP_EMIT_STRENGTH) ? result + "emitStrength " : result;
+    result = f.getHasProperty(PROP_EMIT_ACCELERATION) ? result + "emitAcceleration " : result;
+    result = f.getHasProperty(PROP_PARTICLE_RADIUS) ? result + "particleRadius " : result;
+    result = f.getHasProperty(PROP_COMPOUND_SHAPE_URL) ? result + "compoundShapeUrl " : result;
+    result = f.getHasProperty(PROP_MARKETPLACE_ID) ? result + "marketplaceID " : result;
+    result = f.getHasProperty(PROP_ACCELERATION) ? result + "acceleration " : result;
+    result = f.getHasProperty(PROP_SIMULATION_OWNER) ? result + "simulationOwner " : result;
+    result = f.getHasProperty(PROP_NAME) ? result + "name " : result;
+    result = f.getHasProperty(PROP_COLLISION_SOUND_URL) ? result + "collisionSoundUrl " : result;
+    result = f.getHasProperty(PROP_RESTITUTION) ? result + "restitution " : result;
+    result = f.getHasProperty(PROP_FRICTION) ? result + "friction " : result;
+    result = f.getHasProperty(PROP_VOXEL_VOLUME_SIZE) ? result + "voxelVolumeSize " : result;
+    result = f.getHasProperty(PROP_VOXEL_DATA) ? result + "voxelData " : result;
+    result = f.getHasProperty(PROP_VOXEL_SURFACE_STYLE) ? result + "voxelSurfaceStyle " : result;
+    result = f.getHasProperty(PROP_LINE_WIDTH) ? result + "lineWidth " : result;
+    result = f.getHasProperty(PROP_LINE_POINTS) ? result + "linePoints " : result;
+    result = f.getHasProperty(PROP_HREF) ? result + "href " : result;
+    result = f.getHasProperty(PROP_DESCRIPTION) ? result + "description " : result;
+    result = f.getHasProperty(PROP_FACE_CAMERA) ? result + "faceCamera " : result;
+    result = f.getHasProperty(PROP_SCRIPT_TIMESTAMP) ? result + "scriptTimestamp " : result;
+    result = f.getHasProperty(PROP_ACTION_DATA) ? result + "actionData " : result;
+    result = f.getHasProperty(PROP_X_TEXTURE_URL) ? result + "xTextureUrl " : result;
+    result = f.getHasProperty(PROP_Y_TEXTURE_URL) ? result + "yTextureUrl " : result;
+    result = f.getHasProperty(PROP_Z_TEXTURE_URL) ? result + "zTextureUrl " : result;
+    result = f.getHasProperty(PROP_NORMALS) ? result + "normals " : result;
+    result = f.getHasProperty(PROP_STROKE_COLORS) ? result + "strokeColors " : result;
+    result = f.getHasProperty(PROP_STROKE_WIDTHS) ? result + "strokeWidths " : result;
+    result = f.getHasProperty(PROP_IS_UV_MODE_STRETCH) ? result + "isUvModeStretch " : result;
+    result = f.getHasProperty(PROP_SPEED_SPREAD) ? result + "speedSpread " : result;
+    result = f.getHasProperty(PROP_ACCELERATION_SPREAD) ? result + "accelerationSpread " : result;
+    result = f.getHasProperty(PROP_X_N_NEIGHBOR_ID) ? result + "xNNeighborID " : result;
+    result = f.getHasProperty(PROP_Y_N_NEIGHBOR_ID) ? result + "yNNeighborID " : result;
+    result = f.getHasProperty(PROP_Z_N_NEIGHBOR_ID) ? result + "zNNeighborID " : result;
+    result = f.getHasProperty(PROP_X_P_NEIGHBOR_ID) ? result + "xPNeighborID " : result;
+    result = f.getHasProperty(PROP_Y_P_NEIGHBOR_ID) ? result + "yPNeighborID " : result;
+    result = f.getHasProperty(PROP_Z_P_NEIGHBOR_ID) ? result + "zPNeighborID " : result;
+    result = f.getHasProperty(PROP_RADIUS_SPREAD) ? result + "radiusSpread " : result;
+    result = f.getHasProperty(PROP_RADIUS_START) ? result + "radiusStart " : result;
+    result = f.getHasProperty(PROP_RADIUS_FINISH) ? result + "radiusFinish " : result;
+    result = f.getHasProperty(PROP_ALPHA) ? result + "alpha " : result;
+    result = f.getHasProperty(PROP_COLOR_SPREAD) ? result + "colorSpread " : result;
+    result = f.getHasProperty(PROP_COLOR_START) ? result + "colorStart " : result;
+    result = f.getHasProperty(PROP_COLOR_FINISH) ? result + "colorFinish " : result;
+    result = f.getHasProperty(PROP_ALPHA_SPREAD) ? result + "alphaSpread " : result;
+    result = f.getHasProperty(PROP_ALPHA_START) ? result + "alphaStart " : result;
+    result = f.getHasProperty(PROP_ALPHA_FINISH) ? result + "alphaFinish " : result;
+    result = f.getHasProperty(PROP_EMIT_ORIENTATION) ? result + "emitOrientation " : result;
+    result = f.getHasProperty(PROP_EMIT_DIMENSIONS) ? result + "emitDimensions " : result;
+    result = f.getHasProperty(PROP_EMIT_RADIUS_START) ? result + "emitRadiusStart " : result;
+    result = f.getHasProperty(PROP_POLAR_START) ? result + "polarStart " : result;
+    result = f.getHasProperty(PROP_POLAR_FINISH) ? result + "polarFinish " : result;
+    result = f.getHasProperty(PROP_AZIMUTH_START) ? result + "azimuthStart " : result;
+    result = f.getHasProperty(PROP_AZIMUTH_FINISH) ? result + "azimuthFinish " : result;
+    result = f.getHasProperty(PROP_ANIMATION_LOOP) ? result + "animationLoop " : result;
+    result = f.getHasProperty(PROP_ANIMATION_FIRST_FRAME) ? result + "animationFirstFrame " : result;
+    result = f.getHasProperty(PROP_ANIMATION_LAST_FRAME) ? result + "animationLastFrame " : result;
+    result = f.getHasProperty(PROP_ANIMATION_HOLD) ? result + "animationHold " : result;
+    result = f.getHasProperty(PROP_ANIMATION_START_AUTOMATICALLY) ? result + "animationStartAutomatically " : result;
+    result = f.getHasProperty(PROP_EMITTER_SHOULD_TRAIL) ? result + "emitterShouldTrail " : result;
+    result = f.getHasProperty(PROP_PARENT_ID) ? result + "parentID " : result;
+    result = f.getHasProperty(PROP_PARENT_JOINT_INDEX) ? result + "parentJointIndex " : result;
+    result = f.getHasProperty(PROP_LOCAL_POSITION) ? result + "localPosition " : result;
+    result = f.getHasProperty(PROP_LOCAL_ROTATION) ? result + "localRotation " : result;
+    result = f.getHasProperty(PROP_QUERY_AA_CUBE) ? result + "queryAaCube " : result;
+    result = f.getHasProperty(PROP_JOINT_ROTATIONS_SET) ? result + "jointRotationsSet " : result;
+    result = f.getHasProperty(PROP_JOINT_ROTATIONS) ? result + "jointRotations " : result;
+    result = f.getHasProperty(PROP_JOINT_TRANSLATIONS_SET) ? result + "jointTranslationsSet " : result;
+    result = f.getHasProperty(PROP_JOINT_TRANSLATIONS) ? result + "jointTranslations " : result;
+    result = f.getHasProperty(PROP_COLLISION_MASK) ? result + "collisionMask " : result;
+    result = f.getHasProperty(PROP_FALLOFF_RADIUS) ? result + "falloffRadius " : result;
+    result = f.getHasProperty(PROP_FLYING_ALLOWED) ? result + "flyingAllowed " : result;
+    result = f.getHasProperty(PROP_GHOSTING_ALLOWED) ? result + "ghostingAllowed " : result;
+    result = f.getHasProperty(PROP_CLIENT_ONLY) ? result + "clientOnly " : result;
+    result = f.getHasProperty(PROP_OWNING_AVATAR_ID) ? result + "owningAvatarID " : result;
+    result = f.getHasProperty(PROP_SHAPE) ? result + "shape " : result;
+    result = f.getHasProperty(PROP_DPI) ? result + "dpi " : result;
+    result = f.getHasProperty(PROP_LOCAL_VELOCITY) ? result + "localVelocity " : result;
+    result = f.getHasProperty(PROP_LOCAL_ANGULAR_VELOCITY) ? result + "localAngularVelocity " : result;
+    result = f.getHasProperty(PROP_LAST_EDITED_BY) ? result + "lastEditedBy " : result;
+    result = f.getHasProperty(PROP_SERVER_SCRIPTS) ? result + "serverScripts " : result;
+    result = f.getHasProperty(PROP_FILTER_URL) ? result + "filterUrl " : result;
+    result = f.getHasProperty(PROP_ITEM_NAME) ? result + "itemName " : result;
+    result = f.getHasProperty(PROP_ITEM_DESCRIPTION) ? result + "itemDescription " : result;
+    result = f.getHasProperty(PROP_ITEM_CATEGORIES) ? result + "itemCategories " : result;
+    result = f.getHasProperty(PROP_ITEM_ARTIST) ? result + "itemArtist " : result;
+    result = f.getHasProperty(PROP_ITEM_LICENSE) ? result + "itemLicense " : result;
+    result = f.getHasProperty(PROP_LIMITED_RUN) ? result + "limitedRun " : result;
+    result = f.getHasProperty(PROP_EDITION_NUMBER) ? result + "editionNumber " : result;
+    result = f.getHasProperty(PROP_ENTITY_INSTANCE_NUMBER) ? result + "entityInstanceNumber " : result;
+    result = f.getHasProperty(PROP_CERTIFICATE_ID) ? result + "certificateID " : result;
+    result = f.getHasProperty(PROP_STATIC_CERTIFICATE_VERSION) ? result + "staticCertificateVersion " : result;
+    result = f.getHasProperty(PROP_CLONEABLE) ? result + "cloneable " : result;
+    result = f.getHasProperty(PROP_CLONE_LIFETIME) ? result + "cloneLifetime " : result;
+    result = f.getHasProperty(PROP_CLONE_LIMIT) ? result + "cloneLimit " : result;
+    result = f.getHasProperty(PROP_CLONE_DYNAMIC) ? result + "cloneDynamic " : result;
+    result = f.getHasProperty(PROP_CLONE_AVATAR_ENTITY) ? result + "cloneAvatarEntity " : result;
+    result = f.getHasProperty(PROP_CLONE_ORIGIN_ID) ? result + "cloneOriginID " : result;
+    result = f.getHasProperty(PROP_HAZE_MODE) ? result + "hazeMode " : result;
+    result = f.getHasProperty(PROP_KEYLIGHT_COLOR) ? result + "keylightColor " : result;
+    result = f.getHasProperty(PROP_KEYLIGHT_INTENSITY) ? result + "keylightIntensity " : result;
+    result = f.getHasProperty(PROP_KEYLIGHT_DIRECTION) ? result + "keylightDirection " : result;
+    result = f.getHasProperty(PROP_KEYLIGHT_CAST_SHADOW) ? result + "keylightCastShadow " : result;
+    result = f.getHasProperty(PROP_HAZE_RANGE) ? result + "hazeRange " : result;
+    result = f.getHasProperty(PROP_HAZE_COLOR) ? result + "hazeColor " : result;
+    result = f.getHasProperty(PROP_HAZE_GLARE_COLOR) ? result + "hazeGlareColor " : result;
+    result = f.getHasProperty(PROP_HAZE_ENABLE_GLARE) ? result + "hazeEnableGlare " : result;
+    result = f.getHasProperty(PROP_HAZE_GLARE_ANGLE) ? result + "hazeGlareAngle " : result;
+    result = f.getHasProperty(PROP_HAZE_ALTITUDE_EFFECT) ? result + "hazeAltitudeEffect " : result;
+    result = f.getHasProperty(PROP_HAZE_CEILING) ? result + "hazeCeiling " : result;
+    result = f.getHasProperty(PROP_HAZE_BASE_REF) ? result + "hazeBaseRef " : result;
+    result = f.getHasProperty(PROP_HAZE_BACKGROUND_BLEND) ? result + "hazeBackgroundBlend " : result;
+    result = f.getHasProperty(PROP_HAZE_ATTENUATE_KEYLIGHT) ? result + "hazeAttenuateKeylight " : result;
+    result = f.getHasProperty(PROP_HAZE_KEYLIGHT_RANGE) ? result + "hazeKeylightRange " : result;
+    result = f.getHasProperty(PROP_HAZE_KEYLIGHT_ALTITUDE) ? result + "hazeKeylightAltitude " : result;
+    result = f.getHasProperty(PROP_KEY_LIGHT_MODE) ? result + "keyLightMode " : result;
+    result = f.getHasProperty(PROP_AMBIENT_LIGHT_MODE) ? result + "ambientLightMode " : result;
+    result = f.getHasProperty(PROP_SKYBOX_MODE) ? result + "skyboxMode " : result;
+    result = f.getHasProperty(PROP_LOCAL_DIMENSIONS) ? result + "localDimensions " : result;
+    result = f.getHasProperty(PROP_MATERIAL_URL) ? result + "materialUrl " : result;
+    result = f.getHasProperty(PROP_MATERIAL_MAPPING_MODE) ? result + "materialMappingMode " : result;
+    result = f.getHasProperty(PROP_MATERIAL_PRIORITY) ? result + "materialPriority " : result;
+    result = f.getHasProperty(PROP_PARENT_MATERIAL_NAME) ? result + "parentMaterialName " : result;
+    result = f.getHasProperty(PROP_MATERIAL_MAPPING_POS) ? result + "materialMappingPos " : result;
+    result = f.getHasProperty(PROP_MATERIAL_MAPPING_SCALE) ? result + "materialMappingScale " : result;
+    result = f.getHasProperty(PROP_MATERIAL_MAPPING_ROT) ? result + "materialMappingRot " : result;
+    result = f.getHasProperty(PROP_MATERIAL_DATA) ? result + "materialData " : result;
+    result = f.getHasProperty(PROP_VISIBLE_IN_SECONDARY_CAMERA) ? result + "visibleInSecondaryCamera " : result;
+    result = f.getHasProperty(PROP_PARTICLE_SPIN) ? result + "particleSpin " : result;
+    result = f.getHasProperty(PROP_SPIN_START) ? result + "spinStart " : result;
+    result = f.getHasProperty(PROP_SPIN_FINISH) ? result + "spinFinish " : result;
+    result = f.getHasProperty(PROP_SPIN_SPREAD) ? result + "spinSpread " : result;
+    result = f.getHasProperty(PROP_PARTICLE_ROTATE_WITH_ENTITY) ? result + "particleRotateWithEntity " : result;
+    result = f.getHasProperty(PROP_BLOOM_INTENSITY) ? result + "bloomIntensity " : result;
+    result = f.getHasProperty(PROP_BLOOM_THRESHOLD) ? result + "bloomThreshold " : result;
+    result = f.getHasProperty(PROP_BLOOM_SIZE) ? result + "bloomSize " : result;
+    result = f.getHasProperty(PROP_GRAB_GRABBABLE) ? result + "grab.Grabbable " : result;
+    result = f.getHasProperty(PROP_GRAB_KINEMATIC) ? result + "grab.Kinematic " : result;
+    result = f.getHasProperty(PROP_GRAB_FOLLOWS_CONTROLLER) ? result + "grab.FollowsController " : result;
+    result = f.getHasProperty(PROP_GRAB_TRIGGERABLE) ? result + "grab.Triggerable " : result;
+    result = f.getHasProperty(PROP_GRAB_EQUIPPABLE) ? result + "grab.Equippable " : result;
+    result =
+        f.getHasProperty(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET) ? result + "grab.LeftEquippablePositionOffset " : result;
+    result =
+        f.getHasProperty(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET) ? result + "grab.LeftEquippableRotationOffset " : result;
+    result =
+        f.getHasProperty(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET) ? result + "grab.RightEquippablePositionOffset " : result;
+    result =
+        f.getHasProperty(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET) ? result + "grab.RightEquippableRotationOffset " : result;
+    result = f.getHasProperty(PROP_GRAB_EQUIPPABLE_INDICATOR_URL) ? result + "grab.EquippableIndicatorURL " : result;
+    result = f.getHasProperty(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE) ? result + "grab.EquippableIndicatorScale " : result;
+    result = f.getHasProperty(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET) ? result + "grab.EquippableIndicatorOffset " : result;
+
+    result += "]";
+    dbg.nospace() << result;
+    return dbg;
+}

libraries/entities/src/EntityPropertyFlags.h

@@ -262,6 +262,19 @@ enum EntityPropertyList {
     PROP_BLOOM_THRESHOLD,
     PROP_BLOOM_SIZE,
 
+    PROP_GRAB_GRABBABLE,
+    PROP_GRAB_KINEMATIC,
+    PROP_GRAB_FOLLOWS_CONTROLLER,
+    PROP_GRAB_TRIGGERABLE,
+    PROP_GRAB_EQUIPPABLE,
+    PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET,
+    PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET,
+    PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET,
+    PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET,
+    PROP_GRAB_EQUIPPABLE_INDICATOR_URL,
+    PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE,
+    PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET,
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////
     // ATTENTION: add new properties to end of list just ABOVE this line
     PROP_AFTER_LAST_ITEM,
@@ -304,5 +317,10 @@ typedef PropertyFlags<EntityPropertyList> EntityPropertyFlags;
 // one greater than the last item property due to the enum's auto-incrementing.
 extern EntityPropertyList PROP_LAST_ITEM;
 
+QString EntityPropertyFlagsToString(EntityPropertyFlags propertiesFlags);
+
+
+QDebug& operator<<(QDebug& dbg, const EntityPropertyFlags& f);
+
 
 #endif // hifi_EntityPropertyFlags_h

libraries/entities/src/EntityScriptingInterface.cpp

@@ -174,6 +174,7 @@ EntityItemProperties convertPropertiesToScriptSemantics(const EntityItemProperti
 }
 
 
+// TODO: this method looks expensive and should take properties by reference, update it, and return void
 EntityItemProperties convertPropertiesFromScriptSemantics(const EntityItemProperties& scriptSideProperties,
                                                           bool scalesWithParent) {
     // convert position and rotation properties from world-space to local, unless localPosition and localRotation
@@ -242,13 +243,12 @@ QUuid EntityScriptingInterface::addEntity(const EntityItemProperties& properties
     _activityTracking.addedEntityCount++;
 
     auto nodeList = DependencyManager::get<NodeList>();
-    auto sessionID = nodeList->getSessionUUID();
+    const auto sessionID = nodeList->getSessionUUID();
 
     EntityItemProperties propertiesWithSimID = properties;
     if (clientOnly) {
-        const QUuid myNodeID = sessionID;
         propertiesWithSimID.setClientOnly(clientOnly);
-        propertiesWithSimID.setOwningAvatarID(myNodeID);
+        propertiesWithSimID.setOwningAvatarID(sessionID);
     }
 
     propertiesWithSimID.setLastEditedBy(sessionID);
@@ -290,7 +290,7 @@ bool EntityScriptingInterface::addLocalEntityCopy(EntityItemProperties& properti
 
                 entity->setLastBroadcast(usecTimestampNow());
                 // since we're creating this object we will immediately volunteer to own its simulation
-                entity->setScriptSimulationPriority(VOLUNTEER_SIMULATION_PRIORITY);
+                entity->upgradeScriptSimulationPriority(VOLUNTEER_SIMULATION_PRIORITY);
                 properties.setLastEdited(entity->getLastEdited());
             } else {
                 qCDebug(entities) << "script failed to add new Entity to local Octree";
@@ -530,54 +530,86 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties&
 
     _activityTracking.editedEntityCount++;
 
-    auto nodeList = DependencyManager::get<NodeList>();
-    auto sessionID = nodeList->getSessionUUID();
+    const auto sessionID = DependencyManager::get<NodeList>()->getSessionUUID();
 
     EntityItemProperties properties = scriptSideProperties;
-    properties.setLastEditedBy(sessionID);
 
     EntityItemID entityID(id);
     if (!_entityTree) {
+        properties.setLastEditedBy(sessionID);
         queueEntityMessage(PacketType::EntityEdit, entityID, properties);
         return id;
     }
-    // If we have a local entity tree set, then also update it.
 
-    bool updatedEntity = false;
-    _entityTree->withWriteLock([&] {
-        EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
+    EntityItemPointer entity(nullptr);
+    SimulationOwner simulationOwner;
+    _entityTree->withReadLock([&] {
+        // make a copy of entity for local logic outside of tree lock
+        entity = _entityTree->findEntityByEntityItemID(entityID);
         if (!entity) {
             return;
         }
 
-        if (entity->getClientOnly() && entity->getOwningAvatarID() != nodeList->getSessionUUID()) {
+        if (entity->getClientOnly() && entity->getOwningAvatarID() != sessionID) {
             // don't edit other avatar's avatarEntities
+            properties = EntityItemProperties();
             return;
         }
+        // make a copy of simulationOwner for local logic outside of tree lock
+        simulationOwner = entity->getSimulationOwner();
+    });
 
-        if (scriptSideProperties.parentRelatedPropertyChanged()) {
-            // All of parentID, parentJointIndex, position, rotation are needed to make sense of any of them.
-            // If any of these changed, pull any missing properties from the entity.
+    if (entity) {
+        if (properties.hasSimulationRestrictedChanges()) {
+            if (_bidOnSimulationOwnership) {
+                // flag for simulation ownership, or upgrade existing ownership priority
+                // (actual bids for simulation ownership are sent by the PhysicalEntitySimulation)
+                entity->upgradeScriptSimulationPriority(properties.computeSimulationBidPriority());
+                if (simulationOwner.getID() == sessionID) {
+                    // we own the simulation --> copy ALL restricted properties
+                    properties.copySimulationRestrictedProperties(entity);
+                } else {
+                    // we don't own the simulation but think we would like to
 
-            if (!scriptSideProperties.parentIDChanged()) {
-                properties.setParentID(entity->getParentID());
-            }
-            if (!scriptSideProperties.parentJointIndexChanged()) {
-                properties.setParentJointIndex(entity->getParentJointIndex());
-            }
-            if (!scriptSideProperties.localPositionChanged() && !scriptSideProperties.positionChanged()) {
-                properties.setPosition(entity->getWorldPosition());
-            }
-            if (!scriptSideProperties.localRotationChanged() && !scriptSideProperties.rotationChanged()) {
-                properties.setRotation(entity->getWorldOrientation());
-            }
-            if (!scriptSideProperties.localDimensionsChanged() && !scriptSideProperties.dimensionsChanged()) {
-                properties.setDimensions(entity->getScaledDimensions());
+                    uint8_t desiredPriority = entity->getScriptSimulationPriority();
+                    if (desiredPriority < simulationOwner.getPriority()) {
+                        // the priority at which we'd like to own it is not high enough
+                        // --> assume failure and clear all restricted property changes
+                        properties.clearSimulationRestrictedProperties();
+                    } else {
+                        // the priority at which we'd like to own it is high enough to win.
+                        // --> assume success and copy ALL restricted properties
+                        properties.copySimulationRestrictedProperties(entity);
+                    }
+                }
+            } else if (!simulationOwner.getID().isNull()) {
+                // someone owns this but not us
+                // clear restricted properties
+                properties.clearSimulationRestrictedProperties();
             }
+            // clear the cached simulationPriority level
+            entity->upgradeScriptSimulationPriority(0);
         }
+
+        // set these to make EntityItemProperties::getScalesWithParent() work correctly
         properties.setClientOnly(entity->getClientOnly());
         properties.setOwningAvatarID(entity->getOwningAvatarID());
-        properties = convertPropertiesFromScriptSemantics(properties, properties.getScalesWithParent());
+
+        // make sure the properties has a type, so that the encode can know which properties to include
+        properties.setType(entity->getType());
+    } else if (_bidOnSimulationOwnership) {
+        // bail when simulation participants don't know about entity
+        return QUuid();
+    }
+    // TODO: it is possible there is no remaining useful changes in properties and we should bail early.
+    // How to check for this cheaply?
+
+    properties = convertPropertiesFromScriptSemantics(properties, properties.getScalesWithParent());
+    properties.setLastEditedBy(sessionID);
+
+    // done reading and modifying properties --> start write
+    bool updatedEntity = false;
+    _entityTree->withWriteLock([&] {
         updatedEntity = _entityTree->updateEntity(entityID, properties);
     });
 
@@ -590,63 +622,37 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties&
     //     return QUuid();
     // }
 
-    bool entityFound { false };
+    bool hasQueryAACubeRelatedChanges = properties.queryAACubeRelatedPropertyChanged();
+    // done writing, send update
     _entityTree->withReadLock([&] {
-        EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
+        // find the entity again: maybe it was removed since we last found it
+        entity = _entityTree->findEntityByEntityItemID(entityID);
         if (entity) {
-            entityFound = true;
-            // make sure the properties has a type, so that the encode can know which properties to include
-            properties.setType(entity->getType());
-            bool hasTerseUpdateChanges = properties.hasTerseUpdateChanges();
-            bool hasPhysicsChanges = properties.hasMiscPhysicsChanges() || hasTerseUpdateChanges;
-            if (_bidOnSimulationOwnership && hasPhysicsChanges) {
-                auto nodeList = DependencyManager::get<NodeList>();
-                const QUuid myNodeID = nodeList->getSessionUUID();
+            uint64_t now = usecTimestampNow();
+            entity->setLastBroadcast(now);
 
-                if (entity->getSimulatorID() == myNodeID) {
-                    // we think we already own the simulation, so make sure to send ALL TerseUpdate properties
-                    if (hasTerseUpdateChanges) {
-                        entity->getAllTerseUpdateProperties(properties);
-                    }
-                    // TODO: if we knew that ONLY TerseUpdate properties have changed in properties AND the object
-                    // is dynamic AND it is active in the physics simulation then we could chose to NOT queue an update
-                    // and instead let the physics simulation decide when to send a terse update.  This would remove
-                    // the "slide-no-rotate" glitch (and typical double-update) that we see during the "poke rolling
-                    // balls" test.  However, even if we solve this problem we still need to provide a "slerp the visible
-                    // proxy toward the true physical position" feature to hide the final glitches in the remote watcher's
-                    // simulation.
-
-                    if (entity->getSimulationPriority() < SCRIPT_POKE_SIMULATION_PRIORITY) {
-                        // we re-assert our simulation ownership at a higher priority
-                        properties.setSimulationOwner(myNodeID, SCRIPT_POKE_SIMULATION_PRIORITY);
-                    }
-                } else {
-                    // we make a bid for simulation ownership
-                    properties.setSimulationOwner(myNodeID, SCRIPT_POKE_SIMULATION_PRIORITY);
-                    entity->setScriptSimulationPriority(SCRIPT_POKE_SIMULATION_PRIORITY);
-                }
-            }
-            if (properties.queryAACubeRelatedPropertyChanged()) {
+            if (hasQueryAACubeRelatedChanges) {
                 properties.setQueryAACube(entity->getQueryAACube());
-            }
-            entity->setLastBroadcast(usecTimestampNow());
-            properties.setLastEdited(entity->getLastEdited());
 
-            // if we've moved an entity with children, check/update the queryAACube of all descendents and tell the server
-            // if they've changed.
-            entity->forEachDescendant([&](SpatiallyNestablePointer descendant) {
-                if (descendant->getNestableType() == NestableType::Entity) {
-                    if (descendant->updateQueryAACube()) {
-                        EntityItemPointer entityDescendant = std::static_pointer_cast<EntityItem>(descendant);
-                        EntityItemProperties newQueryCubeProperties;
-                        newQueryCubeProperties.setQueryAACube(descendant->getQueryAACube());
-                        newQueryCubeProperties.setLastEdited(properties.getLastEdited());
-                        queueEntityMessage(PacketType::EntityEdit, descendant->getID(), newQueryCubeProperties);
-                        entityDescendant->setLastBroadcast(usecTimestampNow());
+                // if we've moved an entity with children, check/update the queryAACube of all descendents and tell the server
+                // if they've changed.
+                entity->forEachDescendant([&](SpatiallyNestablePointer descendant) {
+                    if (descendant->getNestableType() == NestableType::Entity) {
+                        if (descendant->updateQueryAACube()) {
+                            EntityItemPointer entityDescendant = std::static_pointer_cast<EntityItem>(descendant);
+                            EntityItemProperties newQueryCubeProperties;
+                            newQueryCubeProperties.setQueryAACube(descendant->getQueryAACube());
+                            newQueryCubeProperties.setLastEdited(properties.getLastEdited());
+                            queueEntityMessage(PacketType::EntityEdit, descendant->getID(), newQueryCubeProperties);
+                            entityDescendant->setLastBroadcast(now);
+                        }
                     }
-                }
-            });
-        } else {
+                });
+            }
+        }
+    });
+    if (!entity) {
+        if (hasQueryAACubeRelatedChanges) {
             // Sometimes ESS don't have the entity they are trying to edit in their local tree.  In this case,
             // convertPropertiesFromScriptSemantics doesn't get called and local* edits will get dropped.
             // This is because, on the script side, "position" is in world frame, but in the network
@@ -668,8 +674,6 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties&
                 properties.setDimensions(properties.getLocalDimensions());
             }
         }
-    });
-    if (!entityFound) {
         // we've made an edit to an entity we don't know about, or to a non-entity.  If it's a known non-entity,
         // print a warning and don't send an edit packet to the entity-server.
         QSharedPointer<SpatialParentFinder> parentFinder = DependencyManager::get<SpatialParentFinder>();
@@ -1192,9 +1196,9 @@ QScriptValue RayToEntityIntersectionResultToScriptValue(QScriptEngine* engine, c
     obj.setProperty("distance", value.distance);
     obj.setProperty("face", boxFaceToString(value.face));
 
-    QScriptValue intersection = vec3toScriptValue(engine, value.intersection);
+    QScriptValue intersection = vec3ToScriptValue(engine, value.intersection);
     obj.setProperty("intersection", intersection);
-    QScriptValue surfaceNormal = vec3toScriptValue(engine, value.surfaceNormal);
+    QScriptValue surfaceNormal = vec3ToScriptValue(engine, value.surfaceNormal);
     obj.setProperty("surfaceNormal", surfaceNormal);
     obj.setProperty("extraInfo", engine->toScriptValue(value.extraInfo));
     return obj;
@@ -1449,7 +1453,7 @@ QUuid EntityScriptingInterface::addAction(const QString& actionTypeString,
         }
         action->setIsMine(true);
         success = entity->addAction(simulation, action);
-        entity->setScriptSimulationPriority(SCRIPT_GRAB_SIMULATION_PRIORITY);
+        entity->upgradeScriptSimulationPriority(SCRIPT_GRAB_SIMULATION_PRIORITY);
         return false; // Physics will cause a packet to be sent, so don't send from here.
     });
     if (success) {
@@ -1465,7 +1469,7 @@ bool EntityScriptingInterface::updateAction(const QUuid& entityID, const QUuid&
     return actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
         bool success = entity->updateAction(simulation, actionID, arguments);
         if (success) {
-            entity->setScriptSimulationPriority(SCRIPT_GRAB_SIMULATION_PRIORITY);
+            entity->upgradeScriptSimulationPriority(SCRIPT_GRAB_SIMULATION_PRIORITY);
         }
         return success;
     });
@@ -1479,7 +1483,7 @@ bool EntityScriptingInterface::deleteAction(const QUuid& entityID, const QUuid&
         success = entity->removeAction(simulation, actionID);
         if (success) {
             // reduce from grab to poke
-            entity->setScriptSimulationPriority(SCRIPT_POKE_SIMULATION_PRIORITY);
+            entity->upgradeScriptSimulationPriority(SCRIPT_POKE_SIMULATION_PRIORITY);
         }
         return false; // Physics will cause a packet to be sent, so don't send from here.
     });

libraries/entities/src/EntityTree.cpp

@@ -668,7 +668,7 @@ void EntityTree::unhookChildAvatar(const EntityItemID entityID) {
 void EntityTree::cleanupCloneIDs(const EntityItemID& entityID) {
     EntityItemPointer entity = findEntityByEntityItemID(entityID);
     if (entity) {
-        // remove clone ID from it's clone origin's clone ID list if clone origin exists
+        // remove clone ID from its clone origin's clone ID list if clone origin exists
         const QUuid& cloneOriginID = entity->getCloneOriginID();
         if (!cloneOriginID.isNull()) {
             EntityItemPointer cloneOrigin = findEntityByID(cloneOriginID);
@@ -1933,6 +1933,14 @@ void EntityTree::fixupNeedsParentFixups() {
                 }
             });
             entity->locationChanged(true);
+
+            // Update our parent's bounding box
+            bool success = false;
+            auto parent = entity->getParentPointer(success);
+            if (success && parent) {
+                parent->updateQueryAACube();
+            }
+
             entity->postParentFixup();
         } else if (getIsServer() || _avatarIDs.contains(entity->getParentID())) {
             // this is a child of an avatar, which the entity server will never have
@@ -2558,7 +2566,7 @@ bool EntityTree::readFromMap(QVariantMap& map) {
         if (needsConversion && (properties.getType() == EntityTypes::EntityType::Zone)) {
             // The legacy version had no keylight mode - this is set to on
             properties.setKeyLightMode(COMPONENT_MODE_ENABLED);
-            
+
             // The ambient URL has been moved from "keyLight" to "ambientLight"
             if (entityMap.contains("keyLight")) {
                 QVariantMap keyLightObject = entityMap["keyLight"].toMap();
@@ -2629,6 +2637,108 @@ bool EntityTree::readFromMap(QVariantMap& map) {
             }
         }
 
+        // convert old grab-related userData to new grab properties
+        if (contentVersion < (int)EntityVersion::GrabProperties) {
+            QJsonObject userData = QJsonDocument::fromJson(properties.getUserData().toUtf8()).object();
+            QJsonObject grabbableKey = userData["grabbableKey"].toObject();
+            QJsonValue wantsTrigger = grabbableKey["wantsTrigger"];
+
+            GrabPropertyGroup& grabProperties = properties.getGrab();
+
+            if (wantsTrigger.isBool()) {
+                grabProperties.setTriggerable(wantsTrigger.toBool());
+            }
+            QJsonValue triggerable = grabbableKey["triggerable"];
+            if (triggerable.isBool()) {
+                grabProperties.setTriggerable(triggerable.toBool());
+            }
+            QJsonValue grabbable = grabbableKey["grabbable"];
+            if (grabbable.isBool()) {
+                grabProperties.setGrabbable(grabbable.toBool());
+            }
+            QJsonValue ignoreIK = grabbableKey["ignoreIK"];
+            if (ignoreIK.isBool()) {
+                grabProperties.setGrabFollowsController(ignoreIK.toBool());
+            }
+            QJsonValue kinematic = grabbableKey["kinematic"];
+            if (kinematic.isBool()) {
+                grabProperties.setGrabKinematic(kinematic.toBool());
+            }
+
+            if (grabbableKey["spatialKey"].isObject()) {
+                QJsonObject spatialKey = grabbableKey["spatialKey"].toObject();
+                grabProperties.setEquippable(true);
+                if (spatialKey["leftRelativePosition"].isObject()) {
+                    grabProperties.setEquippableLeftPosition(qMapToVec3(spatialKey["leftRelativePosition"].toVariant()));
+                }
+                if (spatialKey["rightRelativePosition"].isObject()) {
+                    grabProperties.setEquippableRightPosition(qMapToVec3(spatialKey["rightRelativePosition"].toVariant()));
+                }
+                if (spatialKey["relativeRotation"].isObject()) {
+                    grabProperties.setEquippableLeftRotation(qMapToQuat(spatialKey["relativeRotation"].toVariant()));
+                    grabProperties.setEquippableRightRotation(qMapToQuat(spatialKey["relativeRotation"].toVariant()));
+                }
+            }
+
+            QJsonObject wearable = userData["wearable"].toObject();
+            QJsonObject joints = wearable["joints"].toObject();
+            if (joints["LeftHand"].isArray()) {
+                QJsonArray leftHand = joints["LeftHand"].toArray();
+                if (leftHand.size() == 2) {
+                    grabProperties.setEquippable(true);
+                    grabProperties.setEquippableLeftPosition(qMapToVec3(leftHand[0].toVariant()));
+                    grabProperties.setEquippableLeftRotation(qMapToQuat(leftHand[1].toVariant()));
+                }
+            }
+            if (joints["RightHand"].isArray()) {
+                QJsonArray rightHand = joints["RightHand"].toArray();
+                if (rightHand.size() == 2) {
+                    grabProperties.setEquippable(true);
+                    grabProperties.setEquippableRightPosition(qMapToVec3(rightHand[0].toVariant()));
+                    grabProperties.setEquippableRightRotation(qMapToQuat(rightHand[1].toVariant()));
+                }
+            }
+
+            if (userData["equipHotspots"].isArray()) {
+                QJsonArray equipHotspots = userData["equipHotspots"].toArray();
+                if (equipHotspots.size() > 0) {
+                    // just take the first one
+                    QJsonObject firstHotSpot = equipHotspots[0].toObject();
+                    QJsonObject joints = firstHotSpot["joints"].toObject();
+                    if (joints["LeftHand"].isArray()) {
+                        QJsonArray leftHand = joints["LeftHand"].toArray();
+                        if (leftHand.size() == 2) {
+                            grabProperties.setEquippable(true);
+                            grabProperties.setEquippableLeftPosition(qMapToVec3(leftHand[0].toVariant()));
+                            grabProperties.setEquippableLeftRotation(qMapToQuat(leftHand[1].toVariant()));
+                        }
+                    }
+                    if (joints["RightHand"].isArray()) {
+                        QJsonArray rightHand = joints["RightHand"].toArray();
+                        if (rightHand.size() == 2) {
+                            grabProperties.setEquippable(true);
+                            grabProperties.setEquippableRightPosition(qMapToVec3(rightHand[0].toVariant()));
+                            grabProperties.setEquippableRightRotation(qMapToQuat(rightHand[1].toVariant()));
+                        }
+                    }
+                    QJsonValue indicatorURL = firstHotSpot["modelURL"];
+                    if (indicatorURL.isString()) {
+                        grabProperties.setEquippableIndicatorURL(indicatorURL.toString());
+                    }
+                    QJsonValue indicatorScale = firstHotSpot["modelScale"];
+                    if (indicatorScale.isDouble()) {
+                        grabProperties.setEquippableIndicatorScale(glm::vec3((float)indicatorScale.toDouble()));
+                    } else if (indicatorScale.isObject()) {
+                        grabProperties.setEquippableIndicatorScale(qMapToVec3(indicatorScale.toVariant()));
+                    }
+                    QJsonValue indicatorOffset = firstHotSpot["position"];
+                    if (indicatorOffset.isObject()) {
+                        grabProperties.setEquippableIndicatorOffset(qMapToVec3(indicatorOffset.toVariant()));
+                    }
+                }
+            }
+        }
+
         // Zero out the spread values that were fixed in version ParticleEntityFix so they behave the same as before
         if (contentVersion < (int)EntityVersion::ParticleEntityFix) {
             properties.setRadiusSpread(0.0f);

libraries/entities/src/GrabPropertyGroup.cpp

@@ -0,0 +1,303 @@
+//
+//  GrabPropertyGroup.h
+//  libraries/entities/src
+//
+//  Created by Seth Alves on 2018-8-8.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "GrabPropertyGroup.h"
+
+#include <OctreePacketData.h>
+
+#include "EntityItemProperties.h"
+#include "EntityItemPropertiesMacros.h"
+
+void GrabPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties,
+                                          QScriptEngine* engine, bool skipDefaults,
+                                          EntityItemProperties& defaultEntityProperties) const {
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_GRABBABLE, Grab, grab, Grabbable, grabbable);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_KINEMATIC, Grab, grab, GrabKinematic, grabKinematic);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_FOLLOWS_CONTROLLER, Grab, grab, GrabFollowsController, grabFollowsController);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_TRIGGERABLE, Grab, grab, Triggerable, triggerable);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_EQUIPPABLE, Grab, grab, Equippable, equippable);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, Grab, grab,
+                                        EquippableLeftPosition, equippableLeftPosition);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, Grab, grab,
+                                        EquippableLeftRotation, equippableLeftRotation);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, Grab, grab,
+                                        EquippableRightPosition, equippableRightPosition);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, Grab, grab,
+                                        EquippableRightRotation, equippableRightRotation);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, Grab, grab,
+                                        EquippableIndicatorURL, equippableIndicatorURL);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, Grab, grab,
+                                        EquippableIndicatorScale, equippableIndicatorScale);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, Grab, grab,
+                                        EquippableIndicatorOffset, equippableIndicatorOffset);
+
+}
+
+void GrabPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, grabbable, bool, setGrabbable);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, grabKinematic, bool, setGrabKinematic);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, grabFollowsController, bool, setGrabFollowsController);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, triggerable, bool, setTriggerable);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, equippable, bool, setEquippable);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, equippableLeftPosition, vec3, setEquippableLeftPosition);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, equippableLeftRotation, quat, setEquippableLeftRotation);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, equippableRightPosition, vec3, setEquippableRightPosition);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(grab, equippableRightRotation, quat, setEquippableRightRotation);
+}
+
+void GrabPropertyGroup::merge(const GrabPropertyGroup& other) {
+    COPY_PROPERTY_IF_CHANGED(grabbable);
+    COPY_PROPERTY_IF_CHANGED(grabKinematic);
+    COPY_PROPERTY_IF_CHANGED(grabFollowsController);
+    COPY_PROPERTY_IF_CHANGED(triggerable);
+    COPY_PROPERTY_IF_CHANGED(equippable);
+    COPY_PROPERTY_IF_CHANGED(equippableLeftPosition);
+    COPY_PROPERTY_IF_CHANGED(equippableLeftRotation);
+    COPY_PROPERTY_IF_CHANGED(equippableRightPosition);
+    COPY_PROPERTY_IF_CHANGED(equippableRightRotation);
+}
+
+void GrabPropertyGroup::debugDump() const {
+    qCDebug(entities) << "   GrabPropertyGroup: ---------------------------------------------";
+
+    qCDebug(entities) << "            _grabbable:" << _grabbable;
+    qCDebug(entities) << "            _grabKinematic:" << _grabKinematic;
+    qCDebug(entities) << "            _grabFollowsController:" << _grabFollowsController;
+    qCDebug(entities) << "            _triggerable:" << _triggerable;
+    qCDebug(entities) << "            _equippable:" << _equippable;
+    qCDebug(entities) << "            _equippableLeftPosition:" << _equippableLeftPosition;
+    qCDebug(entities) << "            _equippableLeftRotation:" << _equippableLeftRotation;
+    qCDebug(entities) << "            _equippableRightPosition:" << _equippableRightPosition;
+    qCDebug(entities) << "            _equippableRightRotation:" << _equippableRightRotation;
+}
+
+void GrabPropertyGroup::listChangedProperties(QList<QString>& out) {
+    if (grabbableChanged()) {
+        out << "grab-grabbable";
+    }
+    if (grabKinematicChanged()) {
+        out << "grab-grabKinematic";
+    }
+    if (grabFollowsControllerChanged()) {
+        out << "grab-followsController";
+    }
+    if (triggerableChanged()) {
+        out << "grab-triggerable";
+    }
+    if (equippableChanged()) {
+        out << "grab-equippable";
+    }
+    if (equippableLeftPositionChanged()) {
+        out << "grab-equippableLeftPosition";
+    }
+    if (equippableLeftRotationChanged()) {
+        out << "grab-equippableLeftRotation";
+    }
+    if (equippableRightPositionChanged()) {
+        out << "grab-equippableRightPosition";
+    }
+    if (equippableRightRotationChanged()) {
+        out << "grab-equippableRightRotation";
+    }
+}
+
+bool GrabPropertyGroup::appendToEditPacket(OctreePacketData* packetData,
+                                           EntityPropertyFlags& requestedProperties,
+                                           EntityPropertyFlags& propertyFlags,
+                                           EntityPropertyFlags& propertiesDidntFit,
+                                           int& propertyCount,
+                                           OctreeElement::AppendState& appendState) const {
+
+    bool successPropertyFits = true;
+
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_GRABBABLE, getGrabbable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_KINEMATIC, getGrabKinematic());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_FOLLOWS_CONTROLLER, getGrabFollowsController());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_TRIGGERABLE, getTriggerable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE, getEquippable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, getEquippableLeftPosition());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, getEquippableLeftRotation());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, getEquippableRightPosition());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, getEquippableRightRotation());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, getEquippableIndicatorURL());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, getEquippableIndicatorScale());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, getEquippableIndicatorOffset());
+
+    return true;
+}
+
+bool GrabPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlags,
+                                             const unsigned char*& dataAt , int& processedBytes) {
+
+    int bytesRead = 0;
+    bool overwriteLocalData = true;
+    bool somethingChanged = false;
+
+    READ_ENTITY_PROPERTY(PROP_GRAB_GRABBABLE, bool, setGrabbable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_KINEMATIC, bool, setGrabKinematic);
+    READ_ENTITY_PROPERTY(PROP_GRAB_FOLLOWS_CONTROLLER, bool, setGrabFollowsController);
+    READ_ENTITY_PROPERTY(PROP_GRAB_TRIGGERABLE, bool, setTriggerable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE, bool, setEquippable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, glm::vec3, setEquippableLeftPosition);
+    READ_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, glm::quat, setEquippableLeftRotation);
+    READ_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, glm::vec3, setEquippableRightPosition);
+    READ_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, glm::quat, setEquippableRightRotation);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, QString, setEquippableIndicatorURL);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, glm::vec3, setEquippableIndicatorScale);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, glm::vec3, setEquippableIndicatorOffset);
+
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_GRABBABLE, Grabbable);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_KINEMATIC, GrabKinematic);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_FOLLOWS_CONTROLLER, GrabFollowsController);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_TRIGGERABLE, Triggerable);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_EQUIPPABLE, Equippable);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, EquippableLeftPosition);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, EquippableLeftRotation);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, EquippableRightPosition);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, EquippableRightRotation);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, EquippableIndicatorURL);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, EquippableIndicatorScale);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, EquippableIndicatorOffset);
+
+    processedBytes += bytesRead;
+
+    Q_UNUSED(somethingChanged);
+
+    return true;
+}
+
+void GrabPropertyGroup::markAllChanged() {
+    _grabbableChanged = true;
+    _grabKinematicChanged = true;
+    _grabFollowsControllerChanged = true;
+    _triggerableChanged = true;
+    _equippableChanged = true;
+    _equippableLeftPositionChanged = true;
+    _equippableLeftRotationChanged = true;
+    _equippableRightPositionChanged = true;
+    _equippableRightRotationChanged = true;
+}
+
+EntityPropertyFlags GrabPropertyGroup::getChangedProperties() const {
+    EntityPropertyFlags changedProperties;
+
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_GRABBABLE, grabbable);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_KINEMATIC, grabKinematic);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_FOLLOWS_CONTROLLER, grabFollowsController);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_TRIGGERABLE, triggerable);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_EQUIPPABLE, equippable);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, equippableLeftPosition);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, equippableLeftRotation);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, equippableRightPosition);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, equippableRightRotation);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, equippableIndicatorURL);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, equippableIndicatorScale);
+    CHECK_PROPERTY_CHANGE(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, equippableIndicatorOffset);
+
+    return changedProperties;
+}
+
+void GrabPropertyGroup::getProperties(EntityItemProperties& properties) const {
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, Grabbable, getGrabbable);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, GrabKinematic, getGrabKinematic);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, GrabFollowsController, getGrabFollowsController);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, Triggerable, getTriggerable);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, Equippable, getEquippable);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, EquippableLeftPosition, getEquippableLeftPosition);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, EquippableLeftRotation, getEquippableLeftRotation);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, EquippableRightPosition, getEquippableRightPosition);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Grab, EquippableRightRotation, getEquippableRightRotation);
+}
+
+bool GrabPropertyGroup::setProperties(const EntityItemProperties& properties) {
+    bool somethingChanged = false;
+
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, Grabbable, grabbable, setGrabbable);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, GrabKinematic, grabKinematic, setGrabKinematic);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, GrabFollowsController, grabFollowsController, setGrabFollowsController);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, Triggerable, triggerable, setTriggerable);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, Equippable, equippable, setEquippable);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, EquippableLeftPosition, equippableLeftPosition, setEquippableLeftPosition);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, EquippableLeftRotation, equippableLeftRotation, setEquippableLeftRotation);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, EquippableRightPosition, equippableRightPosition,
+                                              setEquippableRightPosition);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Grab, EquippableRightRotation, equippableRightRotation,
+                                              setEquippableRightRotation);
+
+    return somethingChanged;
+}
+
+EntityPropertyFlags GrabPropertyGroup::getEntityProperties(EncodeBitstreamParams& params) const {
+    EntityPropertyFlags requestedProperties;
+
+    requestedProperties += PROP_GRAB_GRABBABLE;
+    requestedProperties += PROP_GRAB_KINEMATIC;
+    requestedProperties += PROP_GRAB_FOLLOWS_CONTROLLER;
+    requestedProperties += PROP_GRAB_TRIGGERABLE;
+    requestedProperties += PROP_GRAB_EQUIPPABLE;
+    requestedProperties += PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET;
+    requestedProperties += PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET;
+    requestedProperties += PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET;
+    requestedProperties += PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET;
+    requestedProperties += PROP_GRAB_EQUIPPABLE_INDICATOR_URL;
+    requestedProperties += PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE;
+    requestedProperties += PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET;
+
+    return requestedProperties;
+}
+
+void GrabPropertyGroup::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                           EntityTreeElementExtraEncodeDataPointer entityTreeElementExtraEncodeData,
+                                           EntityPropertyFlags& requestedProperties,
+                                           EntityPropertyFlags& propertyFlags,
+                                           EntityPropertyFlags& propertiesDidntFit,
+                                           int& propertyCount,
+                                           OctreeElement::AppendState& appendState) const {
+
+    bool successPropertyFits = true;
+
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_GRABBABLE, getGrabbable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_KINEMATIC, getGrabKinematic());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_FOLLOWS_CONTROLLER, getGrabFollowsController());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_TRIGGERABLE, getTriggerable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE, getEquippable());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, getEquippableLeftPosition());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, getEquippableLeftRotation());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, getEquippableRightPosition());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, getEquippableRightRotation());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, getEquippableIndicatorURL());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, getEquippableIndicatorScale());
+    APPEND_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, getEquippableIndicatorOffset());
+}
+
+int GrabPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                        ReadBitstreamToTreeParams& args,
+                                                        EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                        bool& somethingChanged) {
+
+    int bytesRead = 0;
+    const unsigned char* dataAt = data;
+
+    READ_ENTITY_PROPERTY(PROP_GRAB_GRABBABLE, bool, setGrabbable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_KINEMATIC, bool, setGrabKinematic);
+    READ_ENTITY_PROPERTY(PROP_GRAB_FOLLOWS_CONTROLLER, bool, setGrabFollowsController);
+    READ_ENTITY_PROPERTY(PROP_GRAB_TRIGGERABLE, bool, setTriggerable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE, bool, setEquippable);
+    READ_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, glm::vec3, setEquippableLeftPosition);
+    READ_ENTITY_PROPERTY(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, glm::quat, setEquippableLeftRotation);
+    READ_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, glm::vec3, setEquippableRightPosition);
+    READ_ENTITY_PROPERTY(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, glm::quat, setEquippableRightRotation);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, QString, setEquippableIndicatorURL);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, glm::vec3, setEquippableIndicatorScale);
+    READ_ENTITY_PROPERTY(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, glm::vec3, setEquippableIndicatorOffset);
+
+    return bytesRead;
+}

libraries/entities/src/GrabPropertyGroup.h

@@ -0,0 +1,141 @@
+//
+//  GrabPropertyGroup.h
+//  libraries/entities/src
+//
+//  Created by Seth Alves on 2018-8-8.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_GrabPropertyGroup_h
+#define hifi_GrabPropertyGroup_h
+
+#include <stdint.h>
+
+#include <glm/glm.hpp>
+
+#include <QtScript/QScriptEngine>
+
+#include "PropertyGroup.h"
+#include "EntityItemPropertiesMacros.h"
+
+class EntityItemProperties;
+class EncodeBitstreamParams;
+class OctreePacketData;
+class ReadBitstreamToTreeParams;
+
+static const bool INITIAL_GRABBABLE { true };
+static const bool INITIAL_KINEMATIC { true };
+static const bool INITIAL_FOLLOWS_CONTROLLER { true };
+static const bool INITIAL_TRIGGERABLE { false };
+static const bool INITIAL_EQUIPPABLE { false };
+static const glm::vec3 INITIAL_LEFT_EQUIPPABLE_POSITION { glm::vec3(0.0f) };
+static const glm::quat INITIAL_LEFT_EQUIPPABLE_ROTATION { glm::quat() };
+static const glm::vec3 INITIAL_RIGHT_EQUIPPABLE_POSITION { glm::vec3(0.0f) };
+static const glm::quat INITIAL_RIGHT_EQUIPPABLE_ROTATION { glm::quat() };
+static const glm::vec3 INITIAL_EQUIPPABLE_INDICATOR_SCALE { glm::vec3(1.0f) };
+static const glm::vec3 INITIAL_EQUIPPABLE_INDICATOR_OFFSET { glm::vec3(0.0f) };
+
+
+/**jsdoc
+ * Grab is defined by the following properties.
+ * @typedef {object} Entities.Grab
+ *
+ * @property {boolean} grabbable=true - If <code>true</code> the entity can be grabbed.
+ * @property {boolean} grabKinematic=true - If <code>true</code> the entity is updated in a kinematic manner.
+ *     If <code>false</code> it will be grabbed using a tractor action.  A kinematic grab will make the item appear more
+ *     tightly held, but will cause it to behave poorly when interacting with dynamic entities.
+ * @property {boolean} grabFollowsController=true - If <code>true</code> the entity will follow the motions of the
+ *     hand-controller even if the avatar's hand can't get to the implied position.  This should be <code>true</code>
+ *     for tools, pens, etc and false for things meant to decorate the hand.
+ *
+ * @property {boolean} triggerable=false - If <code>true</code> the entity will receive calls to trigger
+ *     {@link Controller|Controller entity methods}.
+ *
+ * @property {boolean} equippable=true - If <code>true</code> the entity can be equipped.
+ * @property {Vec3} equippableLeftPosition=0,0,0 - Positional offset from the left hand, when equipped.
+ * @property {Quat} equippableLeftRotation=0,0,0,1 - Rotational offset from the left hand, when equipped.
+ * @property {Vec3} equippableRightPosition=0,0,0 - Positional offset from the right hand, when equipped.
+ * @property {Quat} equippableRightRotation=0,0,0,1 - Rotational offset from the right hand, when equipped.
+ *
+ * @property {string} equippableIndicatorURL="" - If non-empty, this model will be used to indicate that an
+ *     entity is equippable, rather than the default.
+ * @property {Vec3} equippableIndicatorScale=1,1,1 - If equippableIndicatorURL is non-empty, this controls the
+       scale of the displayed overlay.
+ * @property {Vec3} equippableIndicatorOffset=0,0,0 - If equippableIndicatorURL is non-empty, this controls the
+       relative offset of the displayed overlay from the equippable entity.
+ */
+
+
+class GrabPropertyGroup : public PropertyGroup {
+public:
+    // EntityItemProperty related helpers
+    virtual void copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties,
+                                   QScriptEngine* engine, bool skipDefaults,
+                                   EntityItemProperties& defaultEntityProperties) const override;
+    virtual void copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) override;
+
+    void merge(const GrabPropertyGroup& other);
+
+    virtual void debugDump() const override;
+    virtual void listChangedProperties(QList<QString>& out) override;
+
+    virtual bool appendToEditPacket(OctreePacketData* packetData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount,
+                                    OctreeElement::AppendState& appendState) const override;
+
+    virtual bool decodeFromEditPacket(EntityPropertyFlags& propertyFlags,
+                                      const unsigned char*& dataAt, int& processedBytes) override;
+    virtual void markAllChanged() override;
+    virtual EntityPropertyFlags getChangedProperties() const override;
+
+    // EntityItem related helpers
+    // methods for getting/setting all properties of an entity
+    virtual void getProperties(EntityItemProperties& propertiesOut) const override;
+
+    // returns true if something changed
+    virtual bool setProperties(const EntityItemProperties& properties) override;
+
+    virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const override;
+
+    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                    EntityTreeElementExtraEncodeDataPointer entityTreeElementExtraEncodeData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount,
+                                    OctreeElement::AppendState& appendState) const override;
+
+    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                ReadBitstreamToTreeParams& args,
+                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                bool& somethingChanged) override;
+
+    // grab properties
+    DEFINE_PROPERTY(PROP_GRAB_GRABBABLE, Grabbable, grabbable, bool, INITIAL_GRABBABLE);
+    DEFINE_PROPERTY(PROP_GRAB_KINEMATIC, GrabKinematic, grabKinematic, bool, INITIAL_KINEMATIC);
+    DEFINE_PROPERTY(PROP_GRAB_FOLLOWS_CONTROLLER, GrabFollowsController, grabFollowsController, bool,
+                    INITIAL_FOLLOWS_CONTROLLER);
+    DEFINE_PROPERTY(PROP_GRAB_TRIGGERABLE, Triggerable, triggerable, bool, INITIAL_TRIGGERABLE);
+    DEFINE_PROPERTY(PROP_GRAB_EQUIPPABLE, Equippable, equippable, bool, INITIAL_EQUIPPABLE);
+    DEFINE_PROPERTY_REF(PROP_GRAB_LEFT_EQUIPPABLE_POSITION_OFFSET, EquippableLeftPosition, equippableLeftPosition,
+                        glm::vec3, INITIAL_LEFT_EQUIPPABLE_POSITION);
+    DEFINE_PROPERTY_REF(PROP_GRAB_LEFT_EQUIPPABLE_ROTATION_OFFSET, EquippableLeftRotation, equippableLeftRotation,
+                        glm::quat, INITIAL_LEFT_EQUIPPABLE_ROTATION);
+    DEFINE_PROPERTY_REF(PROP_GRAB_RIGHT_EQUIPPABLE_POSITION_OFFSET, EquippableRightPosition, equippableRightPosition,
+                        glm::vec3, INITIAL_RIGHT_EQUIPPABLE_POSITION);
+    DEFINE_PROPERTY_REF(PROP_GRAB_RIGHT_EQUIPPABLE_ROTATION_OFFSET, EquippableRightRotation, equippableRightRotation,
+                        glm::quat, INITIAL_RIGHT_EQUIPPABLE_ROTATION);
+    DEFINE_PROPERTY_REF(PROP_GRAB_EQUIPPABLE_INDICATOR_URL, EquippableIndicatorURL, equippableIndicatorURL, QString, "");
+    DEFINE_PROPERTY_REF(PROP_GRAB_EQUIPPABLE_INDICATOR_SCALE, EquippableIndicatorScale, equippableIndicatorScale,
+                        glm::vec3, INITIAL_EQUIPPABLE_INDICATOR_SCALE);
+    DEFINE_PROPERTY_REF(PROP_GRAB_EQUIPPABLE_INDICATOR_OFFSET, EquippableIndicatorOffset, equippableIndicatorOffset,
+                        glm::vec3, INITIAL_EQUIPPABLE_INDICATOR_OFFSET);
+};
+
+#endif // hifi_GrabPropertyGroup_h

libraries/entities/src/HazePropertyGroup.cpp

@@ -18,8 +18,8 @@
 
 void HazePropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_HAZE_RANGE, Haze, haze, HazeRange, hazeRange);
-    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_HAZE_COLOR, Haze, haze, HazeColor, hazeColor);
-    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_HAZE_GLARE_COLOR, Haze, haze, HazeGlareColor, hazeGlareColor);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_HAZE_COLOR, Haze, haze, HazeColor, hazeColor, u8vec3Color);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_HAZE_GLARE_COLOR, Haze, haze, HazeGlareColor, hazeGlareColor, u8vec3Color);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_HAZE_ENABLE_GLARE, Haze, haze, HazeEnableGlare, hazeEnableGlare);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_HAZE_GLARE_ANGLE, Haze, haze, HazeGlareAngle, hazeGlareAngle);
 
@@ -36,8 +36,8 @@ void HazePropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProp
 
 void HazePropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeRange, float, setHazeRange);
-    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeColor, xColor, setHazeColor);
-    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareColor, xColor, setHazeGlareColor);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeColor, u8vec3Color, setHazeColor);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareColor, u8vec3Color, setHazeGlareColor);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeEnableGlare, bool, setHazeEnableGlare);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(haze, hazeGlareAngle, float, setHazeGlareAngle);
 
@@ -167,8 +167,8 @@ bool HazePropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlags,
     bool somethingChanged = false;
 
     READ_ENTITY_PROPERTY(PROP_HAZE_RANGE, float, setHazeRange);
-    READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, xColor, setHazeColor);
-    READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, xColor, setHazeGlareColor);
+    READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, u8vec3Color, setHazeColor);
+    READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, u8vec3Color, setHazeGlareColor);
     READ_ENTITY_PROPERTY(PROP_HAZE_ENABLE_GLARE, bool, setHazeEnableGlare);
     READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_ANGLE, float, setHazeGlareAngle);
 
@@ -343,8 +343,8 @@ int HazePropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* dat
     const unsigned char* dataAt = data;
 
     READ_ENTITY_PROPERTY(PROP_HAZE_RANGE, float, setHazeRange);
-    READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, xColor, setHazeColor);
-    READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, xColor, setHazeGlareColor);
+    READ_ENTITY_PROPERTY(PROP_HAZE_COLOR, u8vec3Color, setHazeColor);
+    READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_COLOR, u8vec3Color, setHazeGlareColor);
     READ_ENTITY_PROPERTY(PROP_HAZE_ENABLE_GLARE, bool, setHazeEnableGlare);
     READ_ENTITY_PROPERTY(PROP_HAZE_GLARE_ANGLE, float, setHazeGlareAngle);
 

libraries/entities/src/HazePropertyGroup.h

@@ -28,8 +28,8 @@ class EntityTreeElementExtraEncodeData;
 class ReadBitstreamToTreeParams;
 
 static const float INITIAL_HAZE_RANGE{ 1000.0f };
-static const xColor initialHazeGlareColorXcolor{ 255, 229, 179 };
-static const xColor initialHazeColorXcolor{ 128, 154, 179 };
+static const glm::u8vec3 initialHazeGlareColor { 255, 229, 179 };
+static const glm::u8vec3 initialHazeColor { 128, 154, 179 };
 static const float INITIAL_HAZE_GLARE_ANGLE{ 20.0f };
 
 static const float INITIAL_HAZE_BASE_REFERENCE{ 0.0f };
@@ -118,8 +118,8 @@ public:
 
     // Range only parameters
     DEFINE_PROPERTY(PROP_HAZE_RANGE, HazeRange, hazeRange, float, INITIAL_HAZE_RANGE);
-    DEFINE_PROPERTY_REF(PROP_HAZE_COLOR, HazeColor, hazeColor, xColor, initialHazeColorXcolor);
-    DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_COLOR, HazeGlareColor, hazeGlareColor, xColor, initialHazeGlareColorXcolor);
+    DEFINE_PROPERTY_REF(PROP_HAZE_COLOR, HazeColor, hazeColor, glm::u8vec3, initialHazeColor);
+    DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_COLOR, HazeGlareColor, hazeGlareColor, glm::u8vec3, initialHazeGlareColor);
     DEFINE_PROPERTY(PROP_HAZE_ENABLE_GLARE, HazeEnableGlare, hazeEnableGlare, bool, false);
     DEFINE_PROPERTY_REF(PROP_HAZE_GLARE_ANGLE, HazeGlareAngle, hazeGlareAngle, float, INITIAL_HAZE_GLARE_ANGLE);
 

libraries/entities/src/KeyLightPropertyGroup.cpp

@@ -17,7 +17,7 @@
 #include "EntityItemProperties.h"
 #include "EntityItemPropertiesMacros.h"
 
-const xColor KeyLightPropertyGroup::DEFAULT_KEYLIGHT_COLOR = { 255, 255, 255 };
+const glm::u8vec3 KeyLightPropertyGroup::DEFAULT_KEYLIGHT_COLOR = { 255, 255, 255 };
 const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_INTENSITY = 1.0f;
 const float KeyLightPropertyGroup::DEFAULT_KEYLIGHT_AMBIENT_INTENSITY = 0.5f;
 const glm::vec3 KeyLightPropertyGroup::DEFAULT_KEYLIGHT_DIRECTION = { 0.0f, -1.0f, 0.0f };
@@ -26,20 +26,20 @@ const bool KeyLightPropertyGroup::DEFAULT_KEYLIGHT_CAST_SHADOWS { false };
 void KeyLightPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, 
     QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
         
-    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_COLOR, KeyLight, keyLight, Color, color);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_KEYLIGHT_COLOR, KeyLight, keyLight, Color, color, u8vec3Color);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_INTENSITY, KeyLight, keyLight, Intensity, intensity);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_DIRECTION, KeyLight, keyLight, Direction, direction);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_CAST_SHADOW, KeyLight, keyLight, CastShadows, castShadows);
 }
 
 void KeyLightPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
-    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, color, xColor, setColor);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, color, u8vec3Color, setColor);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, intensity, float, setIntensity);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, direction, vec3, setDirection);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(keyLight, castShadows, bool, setCastShadows);
 
     // legacy property support
-    COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightColor, xColor, setColor, getColor);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightColor, u8vec3Color, setColor, getColor);
     COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightIntensity, float, setIntensity, getIntensity);
     COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightDirection, vec3, setDirection, getDirection);
     COPY_PROPERTY_FROM_QSCRIPTVALUE_GETTER(keyLightCastShadows, bool, setCastShadows, getCastShadows);
@@ -99,7 +99,7 @@ bool KeyLightPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFl
     bool overwriteLocalData = true;
     bool somethingChanged = false;
     
-    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, xColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, u8vec3Color, setColor);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);
@@ -187,7 +187,7 @@ int KeyLightPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char*
     int bytesRead = 0;
     const unsigned char* dataAt = data;
     
-    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, xColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_KEYLIGHT_COLOR, u8vec3Color, setColor);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_INTENSITY, float, setIntensity);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_DIRECTION, glm::vec3, setDirection);
     READ_ENTITY_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, bool, setCastShadows);

libraries/entities/src/KeyLightPropertyGroup.h

@@ -84,13 +84,13 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                 bool& somethingChanged) override;
 
-    static const xColor DEFAULT_KEYLIGHT_COLOR;
+    static const glm::u8vec3 DEFAULT_KEYLIGHT_COLOR;
     static const float DEFAULT_KEYLIGHT_INTENSITY;
     static const float DEFAULT_KEYLIGHT_AMBIENT_INTENSITY;
     static const glm::vec3 DEFAULT_KEYLIGHT_DIRECTION;
     static const bool DEFAULT_KEYLIGHT_CAST_SHADOWS;
 
-    DEFINE_PROPERTY_REF(PROP_KEYLIGHT_COLOR, Color, color, xColor, DEFAULT_KEYLIGHT_COLOR);
+    DEFINE_PROPERTY_REF(PROP_KEYLIGHT_COLOR, Color, color, glm::u8vec3, DEFAULT_KEYLIGHT_COLOR);
     DEFINE_PROPERTY(PROP_KEYLIGHT_INTENSITY, Intensity, intensity, float, DEFAULT_KEYLIGHT_INTENSITY);
     DEFINE_PROPERTY_REF(PROP_KEYLIGHT_DIRECTION, Direction, direction, glm::vec3, DEFAULT_KEYLIGHT_DIRECTION);
     DEFINE_PROPERTY(PROP_KEYLIGHT_CAST_SHADOW, CastShadows, castShadows, bool, DEFAULT_KEYLIGHT_CAST_SHADOWS);

libraries/entities/src/LightEntityItem.cpp

@@ -38,7 +38,6 @@ EntityItemPointer LightEntityItem::factory(const EntityItemID& entityID, const E
 // our non-pure virtual subclass for now...
 LightEntityItem::LightEntityItem(const EntityItemID& entityItemID) : EntityItem(entityItemID) {
     _type = EntityTypes::Light;
-    _color[RED_INDEX] = _color[GREEN_INDEX] = _color[BLUE_INDEX] = 0;
 }
 
 void LightEntityItem::setUnscaledDimensions(const glm::vec3& value) {
@@ -73,7 +72,7 @@ EntityItemProperties LightEntityItem::getProperties(const EntityPropertyFlags& d
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
 
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(isSpotlight, getIsSpotlight);
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getXColor);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(intensity, getIntensity);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(exponent, getExponent);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(cutoff, getCutoff);
@@ -176,7 +175,7 @@ int LightEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     const unsigned char* dataAt = data;
 
     READ_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
     READ_ENTITY_PROPERTY(PROP_INTENSITY, float, setIntensity);
     READ_ENTITY_PROPERTY(PROP_EXPONENT, float, setExponent);
     READ_ENTITY_PROPERTY(PROP_CUTOFF, float, setCutoff);
@@ -214,26 +213,15 @@ void LightEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
     APPEND_ENTITY_PROPERTY(PROP_FALLOFF_RADIUS, getFalloffRadius());
 }
 
-const rgbColor& LightEntityItem::getColor() const { 
-    return _color; 
-}
-
-xColor LightEntityItem::getXColor() const {
-    xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color;
-}
-
-void LightEntityItem::setColor(const rgbColor& value) { 
-    withWriteLock([&] {
-        memcpy(_color, value, sizeof(_color));
-        _lightPropertiesChanged = true;
+glm::u8vec3 LightEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _color;
     });
 }
 
-void LightEntityItem::setColor(const xColor& value) {
+void LightEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
-        _color[RED_INDEX] = value.red;
-        _color[GREEN_INDEX] = value.green;
-        _color[BLUE_INDEX] = value.blue;
+        _color = value;
         _lightPropertiesChanged = true;
     });
 }

libraries/entities/src/LightEntityItem.h

@@ -52,18 +52,12 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                 bool& somethingChanged) override;
 
-    const rgbColor& getColor() const;
-    xColor getXColor() const;
-
-    void setColor(const rgbColor& value);
-    void setColor(const xColor& value);
+    glm::u8vec3 getColor() const;
+    void setColor(const glm::u8vec3& value);
 
     bool getIsSpotlight() const;
     void setIsSpotlight(bool value);
 
-    void setIgnoredColor(const rgbColor& value) { }
-    void setIgnoredAttenuation(float value) { }
-
     float getIntensity() const;
     void setIntensity(float value);
     float getFalloffRadius() const;
@@ -96,7 +90,7 @@ public:
 
 private:
     // properties of a light
-    rgbColor _color;
+    glm::u8vec3 _color;
     bool _isSpotlight { DEFAULT_IS_SPOTLIGHT };
     float _intensity { DEFAULT_INTENSITY };
     float _falloffRadius { DEFAULT_FALLOFF_RADIUS };

libraries/entities/src/LineEntityItem.cpp

@@ -41,13 +41,8 @@ EntityItemProperties LineEntityItem::getProperties(const EntityPropertyFlags& de
     
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
 
-    
-    properties._color = getXColor();
-    properties._colorChanged = false;
-    
-    
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineWidth, getLineWidth);
-    
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(linePoints, getLinePoints);
 
     return properties;
@@ -56,12 +51,11 @@ EntityItemProperties LineEntityItem::getProperties(const EntityPropertyFlags& de
 bool LineEntityItem::setProperties(const EntityItemProperties& properties) {
     bool somethingChanged = false;
     somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
-    
+
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(color, setColor);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(lineWidth, setLineWidth);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(linePoints, setLinePoints);
 
-
     if (somethingChanged) {
         bool wantDebug = false;
         if (wantDebug) {
@@ -120,7 +114,7 @@ int LineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     int bytesRead = 0;
     const unsigned char* dataAt = data;
 
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
     READ_ENTITY_PROPERTY(PROP_LINE_WIDTH, float, setLineWidth);
     READ_ENTITY_PROPERTY(PROP_LINE_POINTS, QVector<glm::vec3>, setLinePoints);
 
@@ -154,36 +148,21 @@ void LineEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
 void LineEntityItem::debugDump() const {
     quint64 now = usecTimestampNow();
     qCDebug(entities) << "   LINE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
-    qCDebug(entities) << "               color:" << _color[0] << "," << _color[1] << "," << _color[2];
+    qCDebug(entities) << "               color:" << _color;
     qCDebug(entities) << "            position:" << debugTreeVector(getWorldPosition());
     qCDebug(entities) << "          dimensions:" << debugTreeVector(getScaledDimensions());
     qCDebug(entities) << "       getLastEdited:" << debugTime(getLastEdited(), now);
 }
 
-
-const rgbColor& LineEntityItem::getColor() const { 
-    return _color; 
-}
-
-xColor LineEntityItem::getXColor() const { 
-    xColor result;
-    withReadLock([&] {
-        result = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] };
-    });
-    return result; 
-}
-
-void LineEntityItem::setColor(const rgbColor& value) { 
-    withWriteLock([&] {
-        memcpy(_color, value, sizeof(_color));
+glm::u8vec3 LineEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _color;
     });
 }
 
-void LineEntityItem::setColor(const xColor& value) {
+void LineEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
-        _color[RED_INDEX] = value.red;
-        _color[GREEN_INDEX] = value.green;
-        _color[BLUE_INDEX] = value.blue;
+        _color = value;
     });
 }
 

libraries/entities/src/LineEntityItem.h

@@ -41,11 +41,8 @@ class LineEntityItem : public EntityItem {
                                                  EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                  bool& somethingChanged) override;
 
-    const rgbColor& getColor() const;
-    xColor getXColor() const;
-
-    void setColor(const rgbColor& value);
-    void setColor(const xColor& value);
+    glm::u8vec3 getColor() const;
+    void setColor(const glm::u8vec3& value);
 
     void setLineWidth(float lineWidth);
     float getLineWidth() const;
@@ -76,7 +73,7 @@ class LineEntityItem : public EntityItem {
     static const int MAX_POINTS_PER_LINE;
 
  private:
-    rgbColor _color;
+    glm::u8vec3 _color;
     float _lineWidth { DEFAULT_LINE_WIDTH };
     QVector<glm::vec3> _points;
     bool _pointsChanged { true };

libraries/entities/src/MaterialEntityItem.cpp

@@ -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());
@@ -314,8 +314,25 @@ void MaterialEntityItem::applyMaterial() {
     _retryApply = true;
 }
 
+AACube MaterialEntityItem::calculateInitialQueryAACube(bool& success) {
+    AACube aaCube = EntityItem::calculateInitialQueryAACube(success);
+    // A Material entity's queryAACube contains its parent's queryAACube
+    auto parent = getParentPointer(success);
+    if (success && parent) {
+        success = false;
+        AACube parentQueryAACube = parent->calculateInitialQueryAACube(success);
+        if (success) {
+            aaCube += parentQueryAACube.getMinimumPoint();
+            aaCube += parentQueryAACube.getMaximumPoint();
+        }
+    }
+    return aaCube;
+}
+
 void MaterialEntityItem::postParentFixup() {
     removeMaterial();
+    _queryAACubeSet = false; // force an update so we contain our parent
+    updateQueryAACube();
     applyMaterial();
 }
 

libraries/entities/src/MaterialEntityItem.h

@@ -85,6 +85,8 @@ public:
 
     void postParentFixup() override;
 
+    AACube calculateInitialQueryAACube(bool& success) override;
+
 private:
     // URL for this material.  Currently, only JSON format is supported.  Set to "materialData" to use the material data to live edit a material.
     // The following fields are supported in the JSON:

libraries/entities/src/ModelEntityItem.cpp

@@ -39,7 +39,6 @@ ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID) : EntityItem(
     // set the last animated when interface (re)starts
     _type = EntityTypes::Model;
     _lastKnownCurrentFrame = -1;
-    _color[0] = _color[1] = _color[2] = 0;
     _visuallyReady = false;
 }
 
@@ -56,7 +55,7 @@ void ModelEntityItem::setTextures(const QString& textures) {
 
 EntityItemProperties ModelEntityItem::getProperties(const EntityPropertyFlags& desiredProperties, bool allowEmptyDesiredProperties) const {
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getXColor);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(modelURL, getModelURL);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(compoundShapeURL, getCompoundShapeURL);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(textures, getTextures);
@@ -117,7 +116,7 @@ int ModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     const unsigned char* dataAt = data;
     bool animationPropertiesChanged = false;
 
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
     READ_ENTITY_PROPERTY(PROP_MODEL_URL, QString, setModelURL);
     READ_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);
     READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
@@ -154,6 +153,7 @@ int ModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
 EntityPropertyFlags ModelEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
     EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
 
+    requestedProperties += PROP_COLOR;
     requestedProperties += PROP_MODEL_URL;
     requestedProperties += PROP_COMPOUND_SHAPE_URL;
     requestedProperties += PROP_TEXTURES;
@@ -520,9 +520,6 @@ QVector<bool> ModelEntityItem::getJointTranslationsSet() const {
 }
 
 
-xColor ModelEntityItem::getXColor() const { 
-    xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; 
-}
 bool ModelEntityItem::hasModel() const { 
     return resultWithReadLock<bool>([&] {
         return !_modelURL.isEmpty();
@@ -558,17 +555,15 @@ QString ModelEntityItem::getCollisionShapeURL() const {
     return getShapeType() == SHAPE_TYPE_COMPOUND ? getCompoundShapeURL() : getModelURL();
 }
 
-void ModelEntityItem::setColor(const rgbColor& value) { 
+void ModelEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
-        memcpy(_color, value, sizeof(_color));
+        _color = value;
     });
 }
 
-void ModelEntityItem::setColor(const xColor& value) {
-    withWriteLock([&] {
-        _color[RED_INDEX] = value.red;
-        _color[GREEN_INDEX] = value.green;
-        _color[BLUE_INDEX] = value.blue;
+glm::u8vec3 ModelEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _color;
     });
 }
 

libraries/entities/src/ModelEntityItem.h

@@ -55,12 +55,11 @@ public:
     void setShapeType(ShapeType type) override;
     virtual ShapeType getShapeType() const override;
 
-
     // TODO: Move these to subclasses, or other appropriate abstraction
     // getters/setters applicable to models and particles
+    glm::u8vec3 getColor() const;
+    void setColor(const glm::u8vec3& value);
 
-    const rgbColor& getColor() const { return _color; }
-    xColor getXColor() const;
     bool hasModel() const;
     virtual bool hasCompoundShapeURL() const;
 
@@ -73,9 +72,6 @@ public:
     // Returns the URL used for the collision shape
     QString getCollisionShapeURL() const;
 
-    void setColor(const rgbColor& value);
-    void setColor(const xColor& value);
-
     // model related properties
     virtual void setModelURL(const QString& url);
     virtual void setCompoundShapeURL(const QString& url);
@@ -160,7 +156,7 @@ protected:
     QVector<ModelJointData> _localJointData;
     int _lastKnownCurrentFrame{-1};
 
-    rgbColor _color;
+    glm::u8vec3 _color;
     QString _modelURL;
     bool _relayParentJoints;
 

libraries/entities/src/ParticleEffectEntityItem.cpp

@@ -151,9 +151,6 @@ uint64_t Properties::emitIntervalUsecs() const {
     return 0;
 }
 
-const xColor ParticleEffectEntityItem::DEFAULT_XCOLOR = xColor(static_cast<unsigned char>(DEFAULT_COLOR.r), static_cast<unsigned char>(DEFAULT_COLOR.g), static_cast<unsigned char>(DEFAULT_COLOR.b));
-const xColor ParticleEffectEntityItem::DEFAULT_XCOLOR_SPREAD = xColor(static_cast<unsigned char>(DEFAULT_COLOR_SPREAD.r), static_cast<unsigned char>(DEFAULT_COLOR_SPREAD.g), static_cast<unsigned char>(DEFAULT_COLOR_SPREAD.b));
-
 EntityItemPointer ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     EntityItemPointer entity(new ParticleEffectEntityItem(entityID), [](EntityItem* ptr) { ptr->deleteLater(); });
     entity->setProperties(properties);
@@ -165,7 +162,6 @@ ParticleEffectEntityItem::ParticleEffectEntityItem(const EntityItemID& entityIte
     EntityItem(entityItemID)
 {
     _type = EntityTypes::ParticleEffect;
-    setColor(DEFAULT_COLOR);
     _visuallyReady = false;
 }
 
@@ -412,7 +408,7 @@ void ParticleEffectEntityItem::computeAndUpdateDimensions() {
 EntityItemProperties ParticleEffectEntityItem::getProperties(const EntityPropertyFlags& desiredProperties, bool allowEmptyDesiredProperties) const {
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
 
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getXColor);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(alpha, getAlpha);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(shapeType, getShapeType); // FIXME - this doesn't appear to get used
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(maxParticles, getMaxParticles);
@@ -503,28 +499,12 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert
     return somethingChanged;
 }
 
-void ParticleEffectEntityItem::setColor(const vec3& value) {
+void ParticleEffectEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
         _particleProperties.color.gradient.target = value;
     });
 }
 
-void ParticleEffectEntityItem::setColor(const xColor& value) {
-    withWriteLock([&] {
-        _particleProperties.color.gradient.target.r = value.red;
-        _particleProperties.color.gradient.target.g = value.green;
-        _particleProperties.color.gradient.target.b = value.blue;
-    });
-}
-
-xColor ParticleEffectEntityItem::getXColor() const {
-    xColor color;
-    color.red = _particleProperties.color.gradient.target.r;
-    color.green = _particleProperties.color.gradient.target.g;
-    color.blue = _particleProperties.color.gradient.target.b;
-    return color;
-}
-
 int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
                                                                ReadBitstreamToTreeParams& args,
                                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
@@ -533,15 +513,15 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
     int bytesRead = 0;
     const unsigned char* dataAt = data;
 
-    READ_ENTITY_PROPERTY(PROP_COLOR, xColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, u8vec3Color, setColor);
     READ_ENTITY_PROPERTY(PROP_EMITTING_PARTICLES, bool, setIsEmitting);
     READ_ENTITY_PROPERTY(PROP_SHAPE_TYPE, ShapeType, setShapeType);
     READ_ENTITY_PROPERTY(PROP_MAX_PARTICLES, quint32, setMaxParticles);
     READ_ENTITY_PROPERTY(PROP_LIFESPAN, float, setLifespan);
     READ_ENTITY_PROPERTY(PROP_EMIT_RATE, float, setEmitRate);
 
-    READ_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, vec3, setEmitAcceleration);
-    READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, vec3, setAccelerationSpread);
+    READ_ENTITY_PROPERTY(PROP_EMIT_ACCELERATION, glm::vec3, setEmitAcceleration);
+    READ_ENTITY_PROPERTY(PROP_ACCELERATION_SPREAD, glm::vec3, setAccelerationSpread);
     READ_ENTITY_PROPERTY(PROP_PARTICLE_RADIUS, float, setParticleRadius);
     READ_ENTITY_PROPERTY(PROP_TEXTURES, QString, setTextures);
 
@@ -549,9 +529,9 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
     READ_ENTITY_PROPERTY(PROP_RADIUS_START, float, setRadiusStart);
     READ_ENTITY_PROPERTY(PROP_RADIUS_FINISH, float, setRadiusFinish);
 
-    READ_ENTITY_PROPERTY(PROP_COLOR_SPREAD, xColor, setColorSpread);
-    READ_ENTITY_PROPERTY(PROP_COLOR_START, vec3, setColorStart);
-    READ_ENTITY_PROPERTY(PROP_COLOR_FINISH, vec3, setColorFinish);
+    READ_ENTITY_PROPERTY(PROP_COLOR_SPREAD, u8vec3Color, setColorSpread);
+    READ_ENTITY_PROPERTY(PROP_COLOR_START, vec3Color, setColorStart);
+    READ_ENTITY_PROPERTY(PROP_COLOR_FINISH, vec3Color, setColorFinish);
     READ_ENTITY_PROPERTY(PROP_ALPHA, float, setAlpha);
     READ_ENTITY_PROPERTY(PROP_ALPHA_SPREAD, float, setAlphaSpread);
     READ_ENTITY_PROPERTY(PROP_ALPHA_START, float, setAlphaStart);
@@ -560,7 +540,7 @@ int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
     READ_ENTITY_PROPERTY(PROP_EMIT_SPEED, float, setEmitSpeed);
     READ_ENTITY_PROPERTY(PROP_SPEED_SPREAD, float, setSpeedSpread);
     READ_ENTITY_PROPERTY(PROP_EMIT_ORIENTATION, quat, setEmitOrientation);
-    READ_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, vec3, setEmitDimensions);
+    READ_ENTITY_PROPERTY(PROP_EMIT_DIMENSIONS, glm::vec3, setEmitDimensions);
     READ_ENTITY_PROPERTY(PROP_EMIT_RADIUS_START, float, setEmitRadiusStart);
     READ_ENTITY_PROPERTY(PROP_POLAR_START, float, setPolarStart);
     READ_ENTITY_PROPERTY(PROP_POLAR_FINISH, float, setPolarFinish);
@@ -629,7 +609,7 @@ void ParticleEffectEntityItem::appendSubclassData(OctreePacketData* packetData,
                                                   OctreeElement::AppendState& appendState) const {
 
     bool successPropertyFits = true;
-    APPEND_ENTITY_PROPERTY(PROP_COLOR, getXColor());
+    APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
     APPEND_ENTITY_PROPERTY(PROP_EMITTING_PARTICLES, getIsEmitting());
     APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
     APPEND_ENTITY_PROPERTY(PROP_MAX_PARTICLES, getMaxParticles());
@@ -713,22 +693,12 @@ void ParticleEffectEntityItem::setColorFinish(const vec3& colorFinish) {
     });
 }
 
-void ParticleEffectEntityItem::setColorSpread(const xColor& value) {
+void ParticleEffectEntityItem::setColorSpread(const glm::u8vec3& value) {
     withWriteLock([&] {
-        _particleProperties.color.gradient.spread.r = value.red;
-        _particleProperties.color.gradient.spread.g = value.green;
-        _particleProperties.color.gradient.spread.b = value.blue;
+        _particleProperties.color.gradient.spread = value;
     });
 }
 
-xColor ParticleEffectEntityItem::getColorSpread() const {
-    xColor color;
-    color.red = _particleProperties.color.gradient.spread.r;
-    color.green = _particleProperties.color.gradient.spread.g;
-    color.blue = _particleProperties.color.gradient.spread.b;
-    return color;
-}
-
 void ParticleEffectEntityItem::setEmitterShouldTrail(bool emitterShouldTrail) {
     withWriteLock([&] {
         _particleProperties.emission.shouldTrail = emitterShouldTrail;

libraries/entities/src/ParticleEffectEntityItem.h

@@ -20,9 +20,9 @@
 namespace particle {
     static const float SCRIPT_MAXIMUM_PI = 3.1416f;  // Round up so that reasonable property values work
     static const float UNINITIALIZED = NAN;
-    static const vec3 DEFAULT_COLOR = { 255, 255, 255 };
+    static const u8vec3 DEFAULT_COLOR = { 255, 255, 255 };
     static const vec3 DEFAULT_COLOR_UNINITIALIZED = { UNINITIALIZED, UNINITIALIZED, UNINITIALIZED };
-    static const vec3 DEFAULT_COLOR_SPREAD = { 0, 0, 0 };
+    static const u8vec3 DEFAULT_COLOR_SPREAD = { 0, 0, 0 };
     static const float DEFAULT_ALPHA = 1.0f;
     static const float DEFAULT_ALPHA_SPREAD = 0.0f;
     static const float DEFAULT_ALPHA_START = UNINITIALIZED;
@@ -42,8 +42,8 @@ namespace particle {
     static const float MINIMUM_EMIT_SPEED = -1000.0f;
     static const float MAXIMUM_EMIT_SPEED = 1000.0f;  // Approx mach 3
     static const float DEFAULT_SPEED_SPREAD = 1.0f;
-    static const glm::quat DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, Vectors::UNIT_X);  // Vertical
-    static const glm::vec3 DEFAULT_EMIT_DIMENSIONS = Vectors::ZERO;  // Emit from point
+    static const quat DEFAULT_EMIT_ORIENTATION = glm::angleAxis(-PI_OVER_TWO, Vectors::UNIT_X);  // Vertical
+    static const vec3 DEFAULT_EMIT_DIMENSIONS = Vectors::ZERO;  // Emit from point
     static const float MINIMUM_EMIT_DIMENSION = 0.0f;
     static const float MAXIMUM_EMIT_DIMENSION = (float)TREE_SCALE;
     static const float DEFAULT_EMIT_RADIUS_START = 1.0f;  // Emit from surface (when emitDimensions > 0)
@@ -57,10 +57,10 @@ namespace particle {
     static const float MAXIMUM_AZIMUTH = SCRIPT_MAXIMUM_PI;
     static const float DEFAULT_AZIMUTH_START = -PI;  // Emit full circumference (when polarFinish > 0)
     static const float DEFAULT_AZIMUTH_FINISH = PI;  // ""
-    static const glm::vec3 DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f);
+    static const vec3 DEFAULT_EMIT_ACCELERATION(0.0f, -9.8f, 0.0f);
     static const float MINIMUM_EMIT_ACCELERATION = -100.0f; // ~ 10g
     static const float MAXIMUM_EMIT_ACCELERATION = 100.0f;
-    static const glm::vec3 DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f);
+    static const vec3 DEFAULT_ACCELERATION_SPREAD(0.0f, 0.0f, 0.0f);
     static const float MINIMUM_ACCELERATION_SPREAD = 0.0f;
     static const float MAXIMUM_ACCELERATION_SPREAD = 100.0f;
     static const float DEFAULT_PARTICLE_RADIUS = 0.025f;
@@ -189,10 +189,10 @@ namespace particle {
             return *this;
         }
 
-        vec4 getColorStart() const { return vec4(ColorUtils::sRGBToLinearVec3(color.range.start / 255.0f), alpha.range.start); }
-        vec4 getColorMiddle() const { return vec4(ColorUtils::sRGBToLinearVec3(color.gradient.target / 255.0f), alpha.gradient.target); }
-        vec4 getColorFinish() const { return vec4(ColorUtils::sRGBToLinearVec3(color.range.finish / 255.0f), alpha.range.finish); }
-        vec4 getColorSpread() const { return vec4(ColorUtils::sRGBToLinearVec3(color.gradient.spread / 255.0f), alpha.gradient.spread); }
+        vec4 getColorStart() const { return vec4(ColorUtils::sRGBToLinearVec3(toGlm(color.range.start)), alpha.range.start); }
+        vec4 getColorMiddle() const { return vec4(ColorUtils::sRGBToLinearVec3(toGlm(color.gradient.target)), alpha.gradient.target); }
+        vec4 getColorFinish() const { return vec4(ColorUtils::sRGBToLinearVec3(toGlm(color.range.finish)), alpha.range.finish); }
+        vec4 getColorSpread() const { return vec4(ColorUtils::sRGBToLinearVec3(toGlm(color.gradient.spread)), alpha.gradient.spread); }
     };
 } // namespace particles
 
@@ -228,11 +228,8 @@ public:
                                                  EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                  bool& somethingChanged) override;
 
-    xColor getXColor() const;
-    vec3 getColor() const { return _particleProperties.color.gradient.target; }
-
-    void setColor(const vec3& value);
-    void setColor(const xColor& value);
+    void setColor(const glm::u8vec3& value);
+    glm::u8vec3 getColor() const { return _particleProperties.color.gradient.target; }
 
     void setColorStart(const vec3& colorStart);
     vec3 getColorStart() const { return _particleProperties.color.range.start; }
@@ -240,8 +237,8 @@ public:
     void setColorFinish(const vec3& colorFinish);
     vec3 getColorFinish() const { return _particleProperties.color.range.finish; }
 
-    void setColorSpread(const xColor& colorSpread);
-    xColor getColorSpread() const;
+    void setColorSpread(const glm::u8vec3& colorSpread);
+    glm::u8vec3 getColorSpread() const { return _particleProperties.color.gradient.spread; }
 
     void setAlpha(float alpha);
     float getAlpha() const { return _particleProperties.alpha.gradient.target; }
@@ -344,9 +341,6 @@ public:
 
     particle::Properties getParticleProperties() const;
 
-    static const xColor DEFAULT_XCOLOR;
-    static const xColor DEFAULT_XCOLOR_SPREAD;
-
 protected:
     particle::Properties _particleProperties;
     bool _isEmitting { true };

libraries/entities/src/PolyLineEntityItem.cpp

@@ -39,12 +39,8 @@ PolyLineEntityItem::PolyLineEntityItem(const EntityItemID& entityItemID) : Entit
 EntityItemProperties PolyLineEntityItem::getProperties(const EntityPropertyFlags& desiredProperties, bool allowEmptyDesiredProperties) const {
     QWriteLocker lock(&_quadReadWriteLock);
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
-
-
-    properties._color = getXColor();
-    properties._colorChanged = false;
     
-
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineWidth, getLineWidth);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(linePoints, getLinePoints);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(normals, getNormals);
@@ -204,7 +200,7 @@ int PolyLineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
     int bytesRead = 0;
     const unsigned char* dataAt = data;
 
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
     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);
@@ -253,7 +249,7 @@ void PolyLineEntityItem::appendSubclassData(OctreePacketData* packetData, Encode
 void PolyLineEntityItem::debugDump() const {
     quint64 now = usecTimestampNow();
     qCDebug(entities) << "   QUAD EntityItem id:" << getEntityItemID() << "---------------------------------------------";
-    qCDebug(entities) << "               color:" << _color[0] << "," << _color[1] << "," << _color[2];
+    qCDebug(entities) << "               color:" << _color;
     qCDebug(entities) << "            position:" << debugTreeVector(getWorldPosition());
     qCDebug(entities) << "          dimensions:" << debugTreeVector(getScaledDimensions());
     qCDebug(entities) << "       getLastEdited:" << debugTime(getLastEdited(), now);
@@ -261,7 +257,7 @@ void PolyLineEntityItem::debugDump() const {
 
 
 
-QVector<glm::vec3> PolyLineEntityItem::getLinePoints() const { 
+QVector<glm::vec3> PolyLineEntityItem::getLinePoints() const {
     QVector<glm::vec3> result;
     withReadLock([&] {
         result = _points;
@@ -269,7 +265,7 @@ QVector<glm::vec3> PolyLineEntityItem::getLinePoints() const {
     return result; 
 }
 
-QVector<glm::vec3> PolyLineEntityItem::getNormals() const { 
+QVector<glm::vec3> PolyLineEntityItem::getNormals() const {
     QVector<glm::vec3> result;
     withReadLock([&] {
         result = _normals;
@@ -309,3 +305,16 @@ void PolyLineEntityItem::setTextures(const QString& textures) {
         }
     });
 }
+
+void PolyLineEntityItem::setColor(const glm::u8vec3& value) {
+    withWriteLock([&] {
+        _strokeColorsChanged = true;
+        _color = value;
+    });
+}
+
+glm::u8vec3 PolyLineEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _color;
+    });
+}

libraries/entities/src/PolyLineEntityItem.h

@@ -41,19 +41,8 @@ class PolyLineEntityItem : public EntityItem {
                                                  EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                  bool& somethingChanged) override;
 
-    const rgbColor& getColor() const { return _color; }
-    xColor getXColor() const { xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; }
-
-    void setColor(const rgbColor& value) {
-        _strokeColorsChanged = true;
-        memcpy(_color, value, sizeof(_color));
-    }
-    void setColor(const xColor& value) {
-        _strokeColorsChanged = true;
-        _color[RED_INDEX] = value.red;
-        _color[GREEN_INDEX] = value.green;
-        _color[BLUE_INDEX] = value.blue;
-    }
+    glm::u8vec3 getColor() const;
+    void setColor(const glm::u8vec3& value);
 
     void setLineWidth(float lineWidth){ _lineWidth = lineWidth; }
     float getLineWidth() const{ return _lineWidth; }
@@ -109,7 +98,7 @@ private:
     void calculateScaleAndRegistrationPoint();
     
  protected:
-    rgbColor _color;
+    glm::u8vec3 _color;
     float _lineWidth { DEFAULT_LINE_WIDTH };
     bool _pointsChanged { true };
     bool _normalsChanged { true };

libraries/entities/src/PolyVoxEntityItem.cpp

@@ -70,7 +70,7 @@ PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID) : EntityI
     _type = EntityTypes::PolyVox;
 }
 
-void PolyVoxEntityItem::setVoxelVolumeSize(const vec3& voxelVolumeSize) {
+void PolyVoxEntityItem::setVoxelVolumeSize(const glm::vec3& voxelVolumeSize) {
     withWriteLock([&] {
         assert(!glm::any(glm::isnan(voxelVolumeSize)));
 

libraries/entities/src/PolyVoxEntityItem.h

@@ -54,7 +54,7 @@ class PolyVoxEntityItem : public EntityItem {
 
     virtual void debugDump() const override;
 
-    virtual void setVoxelVolumeSize(const vec3& voxelVolumeSize);
+    virtual void setVoxelVolumeSize(const glm::vec3& voxelVolumeSize);
     virtual glm::vec3 getVoxelVolumeSize() const;
 
     virtual void setVoxelData(const QByteArray& voxelData);

libraries/entities/src/ShapeEntityItem.cpp

@@ -73,7 +73,7 @@ namespace entity {
         return Shape::Sphere;
     }
 
-    ::QString stringFromShape(Shape shape) {
+    QString stringFromShape(Shape shape) {
         return shapeStrings[shape];
     }
 }
@@ -117,8 +117,10 @@ ShapeEntityItem::ShapeEntityItem(const EntityItemID& entityItemID) : EntityItem(
 
 EntityItemProperties ShapeEntityItem::getProperties(const EntityPropertyFlags& desiredProperties, bool allowEmptyDesiredProperties) const {
     EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class
+
     properties.setShape(entity::stringFromShape(getShape()));
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getXColor);
+    properties._shapeChanged = false;
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(color, getColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(alpha, getAlpha);
 
     return properties;
@@ -182,7 +184,7 @@ int ShapeEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     const unsigned char* dataAt = data;
 
     READ_ENTITY_PROPERTY(PROP_SHAPE, QString, setShape);
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_COLOR, glm::u8vec3, setColor);
     READ_ENTITY_PROPERTY(PROP_ALPHA, float, setAlpha);
 
     return bytesRead;
@@ -210,32 +212,24 @@ void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
     APPEND_ENTITY_PROPERTY(PROP_ALPHA, getAlpha());
 }
 
-void ShapeEntityItem::setColor(const rgbColor& value) {
-    memcpy(_color, value, sizeof(rgbColor));
-    _material->setAlbedo(glm::vec3(_color[0], _color[1], _color[2]) / 255.0f);
+void ShapeEntityItem::setColor(const glm::u8vec3& value) {
+    withWriteLock([&] {
+        _color = value;
+        _material->setAlbedo(toGlm(_color));
+    });
 }
 
-xColor ShapeEntityItem::getXColor() const {
-    return xColor { _color[0], _color[1], _color[2] };
-}
-
-void ShapeEntityItem::setColor(const xColor& value) {
-    setColor(rgbColor { value.red, value.green, value.blue });
-}
-
-QColor ShapeEntityItem::getQColor() const {
-    auto& color = getColor();
-    return QColor(color[0], color[1], color[2], (int)(getAlpha() * 255));
-}
-
-void ShapeEntityItem::setColor(const QColor& value) {
-    setColor(rgbColor { (uint8_t)value.red(), (uint8_t)value.green(), (uint8_t)value.blue() });
-    setAlpha(value.alpha());
+glm::u8vec3 ShapeEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _color;
+    });
 }
 
 void ShapeEntityItem::setAlpha(float alpha) {
-    _alpha = alpha;
-    _material->setOpacity(alpha);
+    withWriteLock([&] {
+        _alpha = alpha;
+        _material->setOpacity(alpha);
+    });
 }
 
 void ShapeEntityItem::setUnscaledDimensions(const glm::vec3& value) {
@@ -313,7 +307,7 @@ void ShapeEntityItem::debugDump() const {
     qCDebug(entities) << "               name:" << _name;
     qCDebug(entities) << "              shape:" << stringFromShape(_shape) << " (EnumId: " << _shape << " )";
     qCDebug(entities) << " collisionShapeType:" << ShapeInfo::getNameForShapeType(getShapeType());
-    qCDebug(entities) << "              color:" << _color[0] << "," << _color[1] << "," << _color[2];
+    qCDebug(entities) << "              color:" << _color;
     qCDebug(entities) << "           position:" << debugTreeVector(getWorldPosition());
     qCDebug(entities) << "         dimensions:" << debugTreeVector(getScaledDimensions());
     qCDebug(entities) << "      getLastEdited:" << debugTime(getLastEdited(), now);
@@ -419,5 +413,4 @@ void ShapeEntityItem::computeShapeInfo(ShapeInfo& info) {
 // This value specifies how the shape should be treated by physics calculations.
 ShapeType ShapeEntityItem::getShapeType() const {
     return _collisionShapeType;
-}
-
+}

libraries/entities/src/ShapeEntityItem.h

@@ -31,7 +31,7 @@ namespace entity {
     };
 
     Shape shapeFromString(const ::QString& shapeString);
-    ::QString stringFromShape(Shape shape);
+    QString stringFromShape(Shape shape);
 }
 
 class ShapeEntityItem : public EntityItem {
@@ -77,17 +77,11 @@ public:
     float getAlpha() const { return _alpha; };
     void setAlpha(float alpha);
 
-    const rgbColor& getColor() const { return _color; }
-    void setColor(const rgbColor& value);
+    glm::u8vec3 getColor() const;
+    void setColor(const glm::u8vec3& value);
 
     void setUnscaledDimensions(const glm::vec3& value) override;
 
-    xColor getXColor() const;
-    void setColor(const xColor& value);
-
-    QColor getQColor() const;
-    void setColor(const QColor& value);
-
     bool shouldBePhysical() const override { return !isDead(); }
     
     bool supportsDetailedIntersection() const override;
@@ -110,7 +104,7 @@ public:
 protected:
 
     float _alpha { 1.0f };
-    rgbColor _color;
+    glm::u8vec3 _color;
     entity::Shape _shape { entity::Shape::Sphere };
 
     //! This is SHAPE_TYPE_ELLIPSOID rather than SHAPE_TYPE_NONE to maintain

libraries/entities/src/SkyboxPropertyGroup.cpp

@@ -16,15 +16,15 @@
 #include "EntityItemProperties.h"
 #include "EntityItemPropertiesMacros.h"
 
-const xColor SkyboxPropertyGroup::DEFAULT_COLOR = { 0, 0, 0 };
+const glm::u8vec3 SkyboxPropertyGroup::DEFAULT_COLOR = { 0, 0, 0 };
 
 void SkyboxPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
-    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_SKYBOX_COLOR, Skybox, skybox, Color, color);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE_TYPED(PROP_SKYBOX_COLOR, Skybox, skybox, Color, color, u8vec3Color);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_SKYBOX_URL, Skybox, skybox, URL, url);
 }
 
 void SkyboxPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
-    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, color, xColor, setColor);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, color, u8vec3Color, setColor);
     COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(skybox, url, QString, setURL);
 }
 
@@ -71,7 +71,7 @@ bool SkyboxPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlag
     bool overwriteLocalData = true;
     bool somethingChanged = false;
 
-    READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, xColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, u8vec3Color, setColor);
     READ_ENTITY_PROPERTY(PROP_SKYBOX_URL, QString, setURL);
 
     DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_SKYBOX_COLOR, Color);
@@ -143,7 +143,7 @@ int SkyboxPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* d
     int bytesRead = 0;
     const unsigned char* dataAt = data;
 
-    READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, xColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_SKYBOX_COLOR, u8vec3Color, setColor);
     READ_ENTITY_PROPERTY(PROP_SKYBOX_URL, QString, setURL);
 
     return bytesRead;

libraries/entities/src/SkyboxPropertyGroup.h

@@ -32,7 +32,7 @@ class ReadBitstreamToTreeParams;
 /**jsdoc
  * A skybox is defined by the following properties.
  * @typedef {object} Entities.Skybox
- * @property {Color} color=0,0,0 - Sets the color of the sky if <code>url</code> is <code>""</code>, otherwise modifies the 
+ * @property {Color} color=0,0,0 - Sets the color of the sky if <code>url</code> is <code>""</code>, otherwise modifies the
  *     color of the cube map image.
  * @property {string} url="" - A cube map image that is used to render the sky.
  */
@@ -83,16 +83,8 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                 bool& somethingChanged) override;
 
-    glm::vec3 getColorVec3() const {
-        const quint8 MAX_COLOR = 255;
-        glm::vec3 color = { (float)_color.red / (float)MAX_COLOR,
-                            (float)_color.green / (float)MAX_COLOR,
-                            (float)_color.blue / (float)MAX_COLOR };
-        return color;
-    }
-
-    static const xColor DEFAULT_COLOR;
-    DEFINE_PROPERTY_REF(PROP_SKYBOX_COLOR, Color, color, xColor, DEFAULT_COLOR);
+    static const glm::u8vec3 DEFAULT_COLOR;
+    DEFINE_PROPERTY_REF(PROP_SKYBOX_COLOR, Color, color, glm::u8vec3, DEFAULT_COLOR);
     DEFINE_PROPERTY_REF(PROP_SKYBOX_URL, URL, url, QString, "");
 };
 

libraries/entities/src/TextEntityItem.cpp

@@ -25,8 +25,8 @@
 
 const QString TextEntityItem::DEFAULT_TEXT("");
 const float TextEntityItem::DEFAULT_LINE_HEIGHT = 0.1f;
-const xColor TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
-const xColor TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
+const glm::u8vec3 TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
+const glm::u8vec3 TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
 const bool TextEntityItem::DEFAULT_FACE_CAMERA = false;
 
 EntityItemPointer TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
@@ -51,8 +51,8 @@ EntityItemProperties TextEntityItem::getProperties(const EntityPropertyFlags& de
 
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(text, getText);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineHeight, getLineHeight);
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(textColor, getTextColorX);
-    COPY_ENTITY_PROPERTY_TO_PROPERTIES(backgroundColor, getBackgroundColorX);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(textColor, getTextColor);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(backgroundColor, getBackgroundColor);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(faceCamera, getFaceCamera);
     return properties;
 }
@@ -91,8 +91,8 @@ int TextEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
 
     READ_ENTITY_PROPERTY(PROP_TEXT, QString, setText);
     READ_ENTITY_PROPERTY(PROP_LINE_HEIGHT, float, setLineHeight);
-    READ_ENTITY_PROPERTY(PROP_TEXT_COLOR, rgbColor, setTextColor);
-    READ_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, rgbColor, setBackgroundColor);
+    READ_ENTITY_PROPERTY(PROP_TEXT_COLOR, glm::u8vec3, setTextColor);
+    READ_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, glm::u8vec3, setBackgroundColor);
     READ_ENTITY_PROPERTY(PROP_FACE_CAMERA, bool, setFaceCamera);
     
     return bytesRead;
@@ -206,55 +206,27 @@ float TextEntityItem::getLineHeight() const {
     return result;
 }
 
-const rgbColor& TextEntityItem::getTextColor() const { 
-    return _textColor;
-}
-
-const rgbColor& TextEntityItem::getBackgroundColor() const {
-    return _backgroundColor;
-}
-
-xColor TextEntityItem::getTextColorX() const { 
-    xColor result;
-    withReadLock([&] {
-        result = { _textColor[RED_INDEX], _textColor[GREEN_INDEX], _textColor[BLUE_INDEX] };
-    });
-    return result;
-}
-
-void TextEntityItem::setTextColor(const rgbColor& value) { 
+void TextEntityItem::setTextColor(const glm::u8vec3& value) {
     withWriteLock([&] {
-        memcpy(_textColor, value, sizeof(_textColor));
+        _textColor = value;
     });
 }
 
-void TextEntityItem::setTextColor(const xColor& value) {
+glm::u8vec3 TextEntityItem::getTextColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _textColor;
+    });
+}
+
+void TextEntityItem::setBackgroundColor(const glm::u8vec3& value) {
     withWriteLock([&] {
-        _textColor[RED_INDEX] = value.red;
-        _textColor[GREEN_INDEX] = value.green;
-        _textColor[BLUE_INDEX] = value.blue;
+        _backgroundColor = value;
     });
 }
 
-xColor TextEntityItem::getBackgroundColorX() const { 
-    xColor result;
-    withReadLock([&] {
-        result = { _backgroundColor[RED_INDEX], _backgroundColor[GREEN_INDEX], _backgroundColor[BLUE_INDEX] };
-    });
-    return result;
-}
-
-void TextEntityItem::setBackgroundColor(const rgbColor& value) { 
-    withWriteLock([&] {
-        memcpy(_backgroundColor, value, sizeof(_backgroundColor));
-    });
-}
-
-void TextEntityItem::setBackgroundColor(const xColor& value) {
-    withWriteLock([&] {
-        _backgroundColor[RED_INDEX] = value.red;
-        _backgroundColor[GREEN_INDEX] = value.green;
-        _backgroundColor[BLUE_INDEX] = value.blue;
+glm::u8vec3 TextEntityItem::getBackgroundColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _backgroundColor;
     });
 }
 

libraries/entities/src/TextEntityItem.h

@@ -63,21 +63,13 @@ public:
     void setLineHeight(float value);
     float getLineHeight() const;
 
-    static const xColor DEFAULT_TEXT_COLOR;
-    // FIXME should not return a reference because of thread safety, but can't return an array
-    const rgbColor& getTextColor() const;
-    xColor getTextColorX() const;
+    static const glm::u8vec3 DEFAULT_TEXT_COLOR;
+    glm::u8vec3 getTextColor() const;
+    void setTextColor(const glm::u8vec3& value);
 
-    void setTextColor(const rgbColor& value);
-    void setTextColor(const xColor& value);
-
-    static const xColor DEFAULT_BACKGROUND_COLOR;
-    // FIXME should not return a reference because of thread safety, but can't return an array
-    const rgbColor& getBackgroundColor() const;
-    xColor getBackgroundColorX() const;
-
-    void setBackgroundColor(const rgbColor& value);
-    void setBackgroundColor(const xColor& value);
+    static const glm::u8vec3 DEFAULT_BACKGROUND_COLOR;
+    glm::u8vec3 getBackgroundColor() const;
+    void setBackgroundColor(const glm::u8vec3& value);
 
     static const bool DEFAULT_FACE_CAMERA;
     bool getFaceCamera() const;
@@ -86,8 +78,8 @@ public:
 private:
     QString _text;
     float _lineHeight;
-    rgbColor _textColor;
-    rgbColor _backgroundColor;
+    glm::u8vec3 _textColor;
+    glm::u8vec3 _backgroundColor;
     bool _faceCamera;
 };
 

libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp

@@ -67,6 +67,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::gl::GLBackend::do_clearFramebuffer),
     (&::gpu::gl::GLBackend::do_blit),
     (&::gpu::gl::GLBackend::do_generateTextureMips),
+    (&::gpu::gl::GLBackend::do_generateTextureMipsWithPipeline),
 
     (&::gpu::gl::GLBackend::do_advance),
 
@@ -166,6 +167,10 @@ GLBackend::GLBackend() {
 GLBackend::~GLBackend() {}
 
 void GLBackend::shutdown() {
+    if (_mipGenerationFramebufferId) {
+        glDeleteFramebuffers(1, &_mipGenerationFramebufferId);
+        _mipGenerationFramebufferId = 0;
+    }
     killInput();
     killTransform();
     killTextureManagementStage();

libraries/gpu-gl-common/src/gpu/gl/GLBackend.h

@@ -288,6 +288,7 @@ public:
     virtual void do_setIndexBuffer(const Batch& batch, size_t paramOffset) final;
     virtual void do_setIndirectBuffer(const Batch& batch, size_t paramOffset) final;
     virtual void do_generateTextureMips(const Batch& batch, size_t paramOffset) final;
+    virtual void do_generateTextureMipsWithPipeline(const Batch& batch, size_t paramOffset) final;
 
     // Transform Stage
     virtual void do_setModelTransform(const Batch& batch, size_t paramOffset) final;
@@ -407,6 +408,8 @@ public:
 protected:
     virtual GLint getRealUniformLocation(GLint location) const;
 
+    virtual void draw(GLenum mode, uint32 numVertices, uint32 startVertex) = 0;
+
     void recycle() const override;
 
     // FIXME instead of a single flag, create a features struct similar to
@@ -696,6 +699,8 @@ protected:
     virtual void initTextureManagementStage();
     virtual void killTextureManagementStage();
 
+    GLuint _mipGenerationFramebufferId{ 0 };
+
     typedef void (GLBackend::*CommandCall)(const Batch&, size_t);
     static CommandCall _commandCalls[Batch::NUM_COMMANDS];
     friend class GLState;

libraries/gpu-gl-common/src/gpu/gl/GLBackendTexture.cpp

@@ -79,3 +79,55 @@ void GLBackend::do_generateTextureMips(const Batch& batch, size_t paramOffset) {
 
     object->generateMips();
 }
+
+void GLBackend::do_generateTextureMipsWithPipeline(const Batch& batch, size_t paramOffset) {
+    TexturePointer resourceTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
+    if (!resourceTexture) {
+        return;
+    }
+
+    // Always make sure the GLObject is in sync
+    GLTexture* object = syncGPUObject(resourceTexture);
+    if (object) {
+        GLuint to = object->_texture;
+        glActiveTexture(GL_TEXTURE0 + gpu::slot::texture::MipCreationInput);
+        glBindTexture(object->_target, to);
+        (void)CHECK_GL_ERROR();
+    } else {
+        return;
+    }
+
+    auto numMips = batch._params[paramOffset + 1]._int;
+    if (numMips < 0) {
+        numMips = resourceTexture->getNumMips();
+    } else {
+        numMips = std::min(numMips, (int)resourceTexture->getNumMips());
+    }
+
+    if (_mipGenerationFramebufferId == 0) {
+        glGenFramebuffers(1, &_mipGenerationFramebufferId);
+        Q_ASSERT(_mipGenerationFramebufferId > 0);
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, _mipGenerationFramebufferId);
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
+
+    for (int level = 1; level < numMips; level++) {
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, object->_id, level);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, level - 1);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level - 1);
+
+        const auto mipDimensions = resourceTexture->evalMipDimensions(level);
+        glViewport(0, 0, mipDimensions.x, mipDimensions.y);
+        draw(GL_TRIANGLE_STRIP, 4, 0);
+    }
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numMips - 1);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    resetOutputStage();
+    // Restore viewport
+    ivec4& vp = _transform._viewport;
+    glViewport(vp.x, vp.y, vp.z, vp.w);
+}

libraries/gpu-gl/src/gpu/gl41/GL41Backend.cpp

@@ -20,6 +20,29 @@ using namespace gpu::gl41;
 
 const std::string GL41Backend::GL41_VERSION { "GL41" };
 
+void GL41Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GL41Backend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gl/src/gpu/gl41/GL41Backend.h

@@ -130,6 +130,9 @@ public:
     };
 
 protected:
+
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
+
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;
     GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer) override;
 

libraries/gpu-gl/src/gpu/gl45/GL45Backend.cpp

@@ -42,6 +42,30 @@ void GL45Backend::recycle() const {
     Parent::recycle();
 }
 
+void GL45Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GL45Backend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gl/src/gpu/gl45/GL45Backend.h

@@ -229,6 +229,7 @@ public:
 
 protected:
 
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
     void recycle() const override;
 
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;

libraries/gpu-gles/src/gpu/gles/GLESBackend.cpp

@@ -20,6 +20,29 @@ using namespace gpu::gles;
 
 const std::string GLESBackend::GLES_VERSION { "GLES" };
 
+void GLESBackend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GLESBackend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gles/src/gpu/gles/GLESBackend.h

@@ -126,6 +126,9 @@ public:
     };
 
 protected:
+
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
+
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;
     GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer) override;
 

libraries/gpu/src/gpu/Batch.cpp

@@ -426,6 +426,13 @@ void Batch::generateTextureMips(const TexturePointer& texture) {
     _params.emplace_back(_textures.cache(texture));
 }
 
+void Batch::generateTextureMipsWithPipeline(const TexturePointer& texture, int numMips) {
+    ADD_COMMAND(generateTextureMipsWithPipeline);
+
+    _params.emplace_back(_textures.cache(texture));
+    _params.emplace_back(numMips);
+}
+
 void Batch::beginQuery(const QueryPointer& query) {
     ADD_COMMAND(beginQuery);
 

libraries/gpu/src/gpu/Batch.h

@@ -226,6 +226,8 @@ public:
 
     // Generate the mips for a texture
     void generateTextureMips(const TexturePointer& texture);
+    // Generate the mips for a texture using the current pipeline
+    void generateTextureMipsWithPipeline(const TexturePointer& destTexture, int numMips = -1);
 
     // Query Section
     void beginQuery(const QueryPointer& query);
@@ -326,6 +328,7 @@ public:
         COMMAND_clearFramebuffer,
         COMMAND_blit,
         COMMAND_generateTextureMips,
+        COMMAND_generateTextureMipsWithPipeline,
 
         COMMAND_advance,
 

libraries/gpu/src/gpu/MipGeneration.slh

@@ -0,0 +1,20 @@
+<!
+//  MipGeneration.slh
+//  libraries/gpu/src
+//
+//  Created by Olivier Prat on 10/16/18.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+!>
+<@if not MIP_GENERATION_SLH@>
+<@def MIP_GENERATION_SLH@>
+
+<@include gpu/ShaderConstants.h@>
+
+layout(binding=GPU_TEXTURE_MIP_CREATION_INPUT) uniform sampler2D texMap;
+
+in vec2 varTexCoord0;
+
+<@endif@>

libraries/gpu/src/gpu/ShaderConstants.h

@@ -21,6 +21,9 @@
 
 #define GPU_TEXTURE_TRANSFORM_OBJECT 31
 
+// Mip creation
+#define GPU_TEXTURE_MIP_CREATION_INPUT 30
+
 #define GPU_STORAGE_TRANSFORM_OBJECT 7
 
 #define GPU_ATTR_POSITION 0
@@ -67,7 +70,8 @@ enum Buffer {
 namespace texture {
 enum Texture {
     ObjectTransforms = GPU_TEXTURE_TRANSFORM_OBJECT,
-}; 
+    MipCreationInput = GPU_TEXTURE_MIP_CREATION_INPUT,
+};
 } // namespace texture
 
 namespace storage {