Merge branch 'master' into avatar-mixer-improvements

2025-04-10 04:53:04 +02:00 · 2018-10-23 15:56:56 -07:00 · 2018-10-23 15:56:56 -07:00 · 0a78eeaf1a
commit 0a78eeaf1a
parent 0b2ee35907 04d251c321
462 changed files with 10427 additions and 5435 deletions
--- a/.eslintrc.js
+++ b/.eslintrc.js
@ -36,6 +36,7 @@ module.exports = {
        "GlobalServices": false,
        "GooglePoly": false,
        "Graphics": false,
+        "HifiAbout": false,
        "HMD": false,
        "LaserPointers": false,
        "location": true,
--- a/BUILD.md
+++ b/BUILD.md
@ -9,6 +9,7 @@

 - [cmake](https://cmake.org/download/):  3.9
 - [Qt](https://www.qt.io/download-open-source):   5.10.1
+- [Python](https://www.python.org/downloads/): 3.6 or higher
 - [OpenSSL](https://www.openssl.org/): Use the latest available 1.0 version (**NOT** 1.1) of OpenSSL to avoid security vulnerabilities.
 - [VHACD](https://github.com/virneo/v-hacd)(clone this repository)(Optional)

--- a/BUILD_LINUX.md
+++ b/BUILD_LINUX.md
@ -40,6 +40,11 @@ Install build tools:
 sudo apt-get install cmake
 ```

+Install Python 3:
+```bash
+sudo apt-get install python3.6
+```
+

 ### Get code and checkout the tag you need

--- a/BUILD_OSX.md
+++ b/BUILD_OSX.md
@ -6,6 +6,10 @@ Please read the [general build guide](BUILD.md) for information on dependencies

    brew install cmake openssl qt

+### Python 3
+
+Download an install Python 3.6.6 or higher from [here](https://www.python.org/downloads/).  Execute the `Update Shell Profile.command` script that is provided with the installer.
+
 ### OpenSSL

 Assuming you've installed OpenSSL using the homebrew instructions above, you'll need to set OPENSSL_ROOT_DIR so CMake can find your installations.
@ -28,7 +32,9 @@ Note that this uses the version from the homebrew formula at the time of this wr

 If Xcode is your editor of choice, you can ask CMake to generate Xcode project files instead of Unix Makefiles.

-    cmake .. -GXcode
+    cmake .. -G Xcode
+
+If `cmake` complains about Python 3 being missing, you may need to update your CMake binary with command `brew upgrade cmake`, or by downloading and running the latest CMake installer, depending on how you originally instaled CMake 

 After running cmake, you will have the make files or Xcode project file necessary to build all of the components. Open the hifi.xcodeproj file, choose ALL_BUILD from the Product > Scheme menu (or target drop down), and click Run.

--- a/BUILD_WIN.md
+++ b/BUILD_WIN.md
@ -5,11 +5,17 @@ Note: We are now using Visual Studio 2017 and Qt 5.10.1. If you are upgrading fr

 Note: The prerequisites will require about 10 GB of space on your drive. You will also need a system with at least 8GB of main memory.

-### Step 1. Visual Studio 2017
+### Step 1. Visual Studio 2017 & Python

 If you don’t have Community or Professional edition of Visual Studio 2017, download [Visual Studio Community 2017](https://www.visualstudio.com/downloads/).

-When selecting components, check "Desktop development with C++." Also on the right on the Summary toolbar, check "Windows 8.1 SDK and UCRT SDK" and "VC++ 2015.3 v140 toolset (x86,x64)".
+When selecting components, check "Desktop development with C++".  Also on the right on the Summary toolbar, check "Windows 8.1 SDK and UCRT SDK" and "VC++ 2015.3 v140 toolset (x86,x64)".  If you do not already have a python development environment installed, also check  "Python Development" in this screen.
+
+If you already have Visual Studio installed and need to add python, open the "Add or remove programs" control panel and find the "Microsoft Visual Studio Installer".  Select it and click "Modify".  In the installer, select "Modify" again, then check "Python Development" and allow the installer to apply the changes.
+
+### Step 1a.  Alternate Python
+
+If you do not wish to use the Python installation bundled with Visual Studio, you can download the installer from [here](https://www.python.org/downloads/).  Ensure you get version 3.6.6 or higher.

 ### Step 2. Installing CMake

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -7,6 +7,11 @@ else()
  cmake_minimum_required(VERSION 3.2)
 endif()

+# squelch the Policy CMP0074 warning without requiring an update to cmake 3.12.
+if ((${CMAKE_MAJOR_VERSION} EQUAL 3 AND ${CMAKE_MINOR_VERSION} GREATER 11) OR ${CMAKE_MAJOR_VERSION} GREATER 3)
+   cmake_policy(SET CMP0074 NEW)
+endif()
+
 project(hifi)

 include("cmake/init.cmake")
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@ -24,7 +24,6 @@ android {
                    '-DANDROID_STL=c++_shared',
                    '-DQT_CMAKE_PREFIX_PATH=' + HIFI_ANDROID_PRECOMPILED + '/qt/lib/cmake',
                    '-DNATIVE_SCRIBE=' + HIFI_ANDROID_PRECOMPILED + '/scribe' + EXEC_SUFFIX,
-                    '-DNATIVE_SHREFLECT=' + HIFI_ANDROID_PRECOMPILED + '/shreflect' + EXEC_SUFFIX,
                    '-DHIFI_ANDROID_PRECOMPILED=' + HIFI_ANDROID_PRECOMPILED,
                    '-DRELEASE_NUMBER=' + RELEASE_NUMBER,
                    '-DRELEASE_TYPE=' + RELEASE_TYPE,
--- a/android/build.gradle
+++ b/android/build.gradle
@ -161,31 +161,19 @@ def packages = [
    ]
 ]

-
 def scribeLocalFile='scribe' + EXEC_SUFFIX
 def scribeFile='scribe_linux_x86_64'
-def scribeChecksum='ca4b904f52f4f993c29175ba96798fa6'
-def scribeVersion='u_iTrJDaE95i2abTPXOpPZckGBIim53G'
-
-def shreflectLocalFile='shreflect' + EXEC_SUFFIX
-def shreflectFile='shreflect_linux_x86_64'
-def shreflectChecksum='d6094a8580066c0b6f4e80b5adfb1d98'
-def shreflectVersion='jnrpudh6fptIg6T2.Z6fgKP2ultAdKmE'
+def scribeChecksum='4635c28192724281d2367ce9e94380ab'
+def scribeVersion='mPAY_N846oZH1tPY1bwChB_hzqkiYyoC'

 if (Os.isFamily(Os.FAMILY_MAC)) {
    scribeFile = 'scribe_osx_x86_64'
-    scribeChecksum='72db9d32d4e1e50add755570ac5eb749'
-    scribeVersion='DAW0DmnjCRib4MD8x93bgc2Z2MpPojZC'
-    shreflectFile='shreflect_osx_x86_64'
-    shreflectChecksum='d613ef0703c21371fee93fd2e54b964f'
-    shreflectVersion='.rYNzjSFq6WtWDnE5KIKRIAGyJtr__ad'
+    scribeChecksum='1ead61c285d265eba9a5ef91ae3b7c26'
+    scribeVersion='4TAXWdo9fviw60N2wUA8HNyQ9TabjZa3'
 } else if (Os.isFamily(Os.FAMILY_WINDOWS)) {
    scribeFile = 'scribe_win32_x86_64.exe'
-    scribeChecksum='678e43d290c90fda670c6fefe038a06d'
-    scribeVersion='PuullrA_bPlO9kXZRt8rLe536X1UI.m7'
-    shreflectFile='shreflect_win32_x86_64.exe'
-    shreflectChecksum='6f4a77b8cceb3f1bbc655132c3665060'
-    shreflectVersion='iIyCyza1nelkbI7ihybF59bBlwrfAC3D'
+    scribeChecksum='9c29a62595daf4844f95f6744d568c15'
+    scribeVersion='DUoxjufeX8ZAIVRBKRczWTuZwT13enTv'
 }

 def options = [
@ -461,27 +449,11 @@ task fixScribePermissions(type: Exec, dependsOn: verifyScribe) {
    commandLine 'chmod', 'a+x', HIFI_ANDROID_PRECOMPILED + '/' + scribeLocalFile
 }

-task downloadShreflect(type: Download) {
-    src baseUrl + shreflectFile + '?versionId=' + shreflectVersion
-    dest new File(baseFolder, shreflectLocalFile)
-    onlyIfNewer true
-}
-
-task verifyShreflect(type: Verify, dependsOn: downloadShreflect) {
-    src new File(baseFolder, shreflectLocalFile);
-    checksum shreflectChecksum
-}
-
-task fixShreflectPermissions(type: Exec, dependsOn: verifyShreflect) {
-    commandLine 'chmod', 'a+x', HIFI_ANDROID_PRECOMPILED + '/' + shreflectLocalFile
-}
-
-task setupScribe(dependsOn: [verifyScribe, verifyShreflect]) { }
+task setupScribe(dependsOn: [verifyScribe]) { }

 // On Windows, we don't need to set the executable bit, but on OSX and Unix we do
 if (!Os.isFamily(Os.FAMILY_WINDOWS)) {
    setupScribe.dependsOn fixScribePermissions
-    setupScribe.dependsOn fixShreflectPermissions
 }

 task extractGvrBinaries(dependsOn: extractDependencies) {
--- a/android/gradle.properties
+++ b/android/gradle.properties
@ -0,0 +1 @@
+org.gradle.jvmargs=-Xms2g -Xmx4g
--- a/assignment-client/src/Agent.cpp
+++ b/assignment-client/src/Agent.cpp
@ -368,11 +368,7 @@ void Agent::executeScript() {

        // setup an Avatar for the script to use
        auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
-
        scriptedAvatar->setID(getSessionUUID());
-
-        connect(_scriptEngine.data(), SIGNAL(update(float)),
-                scriptedAvatar.data(), SLOT(update(float)), Qt::ConnectionType::QueuedConnection);
        scriptedAvatar->setForceFaceTrackerConnected(true);

        // call model URL setters with empty URLs so our avatar, if user, will have the default models
@ -504,8 +500,6 @@ void Agent::executeScript() {

        DependencyManager::set<AssignmentParentFinder>(_entityViewer.getTree());

-        _avatarAudioTimer.start();
-
        // Agents should run at 45hz
        static const int AVATAR_DATA_HZ = 45;
        static const int AVATAR_DATA_IN_MSECS = MSECS_PER_SECOND / AVATAR_DATA_HZ;
@ -530,7 +524,8 @@ void Agent::executeScript() {
        }

        avatarDataTimer->stop();
-        _avatarAudioTimer.stop();
+
+        setIsAvatar(false); // will stop timers for sending identity packets
    }

    setFinished(true);
@ -582,28 +577,33 @@ void Agent::setIsAvatar(bool isAvatar) {
    }
    _isAvatar = isAvatar;

-    if (_isAvatar && !_avatarIdentityTimer) {
-        // set up the avatar timers
-        _avatarIdentityTimer = new QTimer(this);
-        _avatarQueryTimer = new QTimer(this);
+    auto scriptableAvatar = DependencyManager::get<ScriptableAvatar>();
+    if (_isAvatar) {
+        if (!_avatarIdentityTimer) {
+            // set up the avatar timers
+            _avatarIdentityTimer = new QTimer(this);
+            _avatarQueryTimer = new QTimer(this);

-        // connect our slot
-        connect(_avatarIdentityTimer, &QTimer::timeout, this, &Agent::sendAvatarIdentityPacket);
-        connect(_avatarQueryTimer, &QTimer::timeout, this, &Agent::queryAvatars);
+            // connect our slot
+            connect(_avatarIdentityTimer, &QTimer::timeout, this, &Agent::sendAvatarIdentityPacket);
+            connect(_avatarQueryTimer, &QTimer::timeout, this, &Agent::queryAvatars);

-        static const int AVATAR_IDENTITY_PACKET_SEND_INTERVAL_MSECS = 1000;
-        static const int AVATAR_VIEW_PACKET_SEND_INTERVAL_MSECS = 1000;
+            static const int AVATAR_IDENTITY_PACKET_SEND_INTERVAL_MSECS = 1000;
+            static const int AVATAR_VIEW_PACKET_SEND_INTERVAL_MSECS = 1000;

-        // start the timers
-        _avatarIdentityTimer->start(AVATAR_IDENTITY_PACKET_SEND_INTERVAL_MSECS);  // FIXME - we shouldn't really need to constantly send identity packets
-        _avatarQueryTimer->start(AVATAR_VIEW_PACKET_SEND_INTERVAL_MSECS);
+            // start the timers
+            _avatarIdentityTimer->start(AVATAR_IDENTITY_PACKET_SEND_INTERVAL_MSECS);  // FIXME - we shouldn't really need to constantly send identity packets
+            _avatarQueryTimer->start(AVATAR_VIEW_PACKET_SEND_INTERVAL_MSECS);

-        // tell the avatarAudioTimer to start ticking
-        QMetaObject::invokeMethod(&_avatarAudioTimer, "start");
-    }
+            connect(_scriptEngine.data(), &ScriptEngine::update,
+                    scriptableAvatar.data(), &ScriptableAvatar::update, Qt::QueuedConnection);

-    if (!_isAvatar) {
+            // tell the avatarAudioTimer to start ticking
+            QMetaObject::invokeMethod(&_avatarAudioTimer, "start");
+        }

+        _entityEditSender.setMyAvatar(scriptableAvatar.data());
+    } else {
        if (_avatarIdentityTimer) {
            _avatarIdentityTimer->stop();
            delete _avatarIdentityTimer;
@ -630,14 +630,14 @@ void Agent::setIsAvatar(bool isAvatar) {
                packet->writePrimitive(KillAvatarReason::NoReason);
                nodeList->sendPacket(std::move(packet), *node);
            });
+
+            disconnect(_scriptEngine.data(), &ScriptEngine::update,
+                       scriptableAvatar.data(), &ScriptableAvatar::update);
+
+            QMetaObject::invokeMethod(&_avatarAudioTimer, "stop");
        }

-        QMetaObject::invokeMethod(&_avatarAudioTimer, "stop");
-
        _entityEditSender.setMyAvatar(nullptr);
-    } else {
-        auto scriptableAvatar = DependencyManager::get<ScriptableAvatar>();
-        _entityEditSender.setMyAvatar(scriptableAvatar.data());
    }
 }

@ -788,7 +788,7 @@ void Agent::processAgentAvatarAudio() {
        // seek past the sequence number, will be packed when destination node is known
        audioPacket->seek(sizeof(quint16));

-        if (silentFrame) {
+        if (silentFrame && !_flushEncoder) {

            if (!_isListeningToAudioStream) {
                // if we have a silent frame and we're not listening then just send nothing and break out of here
@ -810,7 +810,7 @@ void Agent::processAgentAvatarAudio() {

            // no matter what, the loudness should be set to 0
            computeLoudness(nullptr, scriptedAvatar);
-        } else if (nextSoundOutput) {
+        } else if (nextSoundOutput || _flushEncoder) {

            // write the codec
            audioPacket->writeString(_selectedCodecName);
@ -864,8 +864,6 @@ void Agent::processAgentAvatarAudio() {
 }

 void Agent::aboutToFinish() {
-    setIsAvatar(false);// will stop timers for sending identity packets
-
    // our entity tree is going to go away so tell that to the EntityScriptingInterface
    DependencyManager::get<EntityScriptingInterface>()->setEntityTree(nullptr);

--- a/assignment-client/src/audio/AudioMixerClientData.cpp
+++ b/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()));
    }
 }

--- a/assignment-client/src/avatars/AvatarMixerSlave.cpp
+++ b/assignment-client/src/avatars/AvatarMixerSlave.cpp
@ -372,6 +372,11 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
            if (lastSeqToReceiver == lastSeqFromSender && lastSeqToReceiver != 0) {
                ++numAvatarsHeldBack;
                shouldIgnore = true;
+            } else if (lastSeqFromSender == 0) {
+                // We have have not yet recieved any data about this avatar. Ignore it for now
+                // This is important for Agent scripts that are not avatar
+                // so that they don't appear to be an avatar at the origin
+                shouldIgnore = true;
            } else if (lastSeqFromSender - lastSeqToReceiver > 1) {
                // this is a skip - we still send the packet but capture the presence of the skip so we see it happening
                ++numAvatarsWithSkippedFrames;
--- a/assignment-client/src/avatars/ScriptableAvatar.h
+++ b/assignment-client/src/avatars/ScriptableAvatar.h
@ -164,7 +164,7 @@ public:
    void setHasAudioEnabledFaceMovement(bool hasAudioEnabledFaceMovement);
    bool getHasAudioEnabledFaceMovement() const override { return _headData->getHasAudioEnabledFaceMovement(); }

-private slots:
+public slots:
    void update(float deltatime);

 private:
--- a/cmake/compiler.cmake
+++ b/cmake/compiler.cmake
@ -6,6 +6,10 @@ if (NOT "${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
  message( FATAL_ERROR "Only 64 bit builds supported." )
 endif()

+if (USE_CCACHE OR "$ENV{USE_CCACHE}")
+  configure_ccache()
+endif()
+
 if (WIN32)
  add_definitions(-DNOMINMAX -D_CRT_SECURE_NO_WARNINGS)

--- a/cmake/externals/glslang/CMakeLists.txt
+++ b/cmake/externals/glslang/CMakeLists.txt
@ -0,0 +1,42 @@
+set(EXTERNAL_NAME glslang)
+string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
+
+include(ExternalProject)
+
+ExternalProject_Add(
+  ${EXTERNAL_NAME}
+  URL https://github.com/KhronosGroup/glslang/archive/7.8.2853.zip
+  URL_MD5 4f93e3818528176c622c137fba05cbf8
+  CMAKE_ARGS  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>-$<CONFIG> 
+  LOG_DOWNLOAD 1
+  LOG_CONFIGURE 1
+  LOG_BUILD 1
+)
+
+# Hide this external target (for ide users)
+set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
+
+# includes
+ExternalProject_Get_Property(${EXTERNAL_NAME} INSTALL_DIR)
+set(SUFFIXED_INSTALL_DIR "${INSTALL_DIR}-$<CONFIG>")
+
+list(APPEND INCLUDE_DIRS ${SUFFIXED_INSTALL_DIR}/include)
+#list(APPEND INCLUDE_DIRS ${INSTALL_DIR}/include)
+set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIR ${INCLUDE_DIRS} CACHE PATH "List of glslang include directories")
+set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${${EXTERNAL_NAME_UPPER}_INCLUDE_DIR} CACHE PATH "List of glslang include directories")
+
+
+set(LIB_DIR ${SUFFIXED_INSTALL_DIR}/lib)
+list(APPEND LIB_NAMES glslang HLSL OGLCompiler OSDependent SPIRV SPVRemapper)
+include(SelectLibraryConfigurations)
+
+foreach(BASE_LIB ${LIB_NAMES})
+    string(TOUPPER ${BASE_LIB} BASE_LIB_UPPER)
+    list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE "${LIB_DIR}/${BASE_LIB}.lib")
+    list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARY_DEBUG "${LIB_DIR}/${BASE_LIB}d.lib")
+endforeach()
+
+select_library_configurations(${EXTERNAL_NAME_UPPER})
+
+set(${EXTERNAL_NAME_UPPER}_LIBRARY ${${EXTERNAL_NAME_UPPER}_LIBRARY} CACHE FILEPATH "Location of glslang libraries")
+set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${${EXTERNAL_NAME_UPPER}_LIBRARIES} CACHE FILEPATH "Location of glslang libraries")
--- a/cmake/externals/spirv_binaries/CMakeLists.txt
+++ b/cmake/externals/spirv_binaries/CMakeLists.txt
@ -0,0 +1,34 @@
+set(EXTERNAL_NAME spirv_binaries)
+string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
+
+include(ExternalProject)
+if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+  set(DOWNLOAD_URL https://public.highfidelity.com/dependencies/vulkan/vulkansdk-win32-1.1.82.1.tar.gz)
+  set(DOWNLOAD_MD5 3a83ef490bce248b1a4d6726a3e5893e)
+  set(BIN_DIR "Bin")
+elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+  set(DOWNLOAD_URL https://public.highfidelity.com/dependencies/vulkan/vulkansdk-macos-1.1.82.1.tar.gz)
+  set(DOWNLOAD_MD5 a57d37275b2c5db023ba8e84a63461ff)
+  set(BIN_DIR "macOS/bin")
+else ()
+  set(DOWNLOAD_URL https://public.highfidelity.com/dependencies/vulkan/vulkansdk-linux-x86_64-1.1.82.1.tar.gz)
+  set(DOWNLOAD_MD5 5a7c9eeda8cee6b36724da7f7cbe5ec6)
+  set(BIN_DIR "x86_64/bin")
+endif ()
+
+ExternalProject_Add(
+  ${EXTERNAL_NAME}
+  URL ${DOWNLOAD_URL}
+  URL_MD5 ${DOWNLOAD_MD5}
+  BUILD_COMMAND ""
+  CONFIGURE_COMMAND ""
+  INSTALL_COMMAND ""
+  LOG_DOWNLOAD ON
+)
+
+# Hide this external target (for ide users)
+set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
+ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)
+
+set(${EXTERNAL_NAME_UPPER}_DIR "${SOURCE_DIR}/${BIN_DIR}" CACHE FILEPATH "SPIRV binary tools location")
+
--- a/cmake/externals/spirv_cross/CMakeLists.txt
+++ b/cmake/externals/spirv_cross/CMakeLists.txt
@ -0,0 +1,35 @@
+set(EXTERNAL_NAME spirv_cross)
+
+include(ExternalProject)
+ExternalProject_Add(
+  ${EXTERNAL_NAME}
+  URL https://github.com/KhronosGroup/SPIRV-Cross/archive/2018-08-07.zip
+  URL_MD5 11198e4dc6a815ffbdb7a0a56d2d9261
+  CONFIGURE_COMMAND CMAKE_ARGS  ${ANDROID_CMAKE_ARGS} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>-$<CONFIG> ${EXTRA_CMAKE_FLAGS}
+  LOG_DOWNLOAD 1
+  LOG_CONFIGURE 1
+  LOG_BUILD 1
+)
+
+# Hide this external target (for ide users)
+set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
+
+ExternalProject_Get_Property(${EXTERNAL_NAME} INSTALL_DIR)
+set(SUFFIXED_INSTALL_DIR "${INSTALL_DIR}-$<CONFIG>")
+
+string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
+
+set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${SUFFIXED_INSTALL_DIR}/include CACHE PATH "List of Draco include directories")
+
+if (UNIX)
+  set(LIB_PREFIX "lib")
+  set(LIB_EXT "a")
+elseif (WIN32)
+  set(LIB_EXT "lib")
+endif ()
+
+foreach(lib glsl msl cpp hlsl reflect util core)
+    list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARIES ${SUFFIXED_INSTALL_DIR}/lib/spirv-cross-${lib}.${LIB_EXT})
+endforeach()
+
+set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${${EXTERNAL_NAME_UPPER}_LIBRARIES} CACHE FILEPATH "Path to SPIRV-Cross libraries")
--- a/cmake/externals/spirv_headers/CMakeLists.txt
+++ b/cmake/externals/spirv_headers/CMakeLists.txt
@ -0,0 +1,18 @@
+set(EXTERNAL_NAME spirv_headers)
+string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
+
+include(ExternalProject)
+ExternalProject_Add(
+  ${EXTERNAL_NAME}
+  URL https://github.com/KhronosGroup/SPIRV-Headers/archive/2c512180ca03b5d4f56283efc85745775b45fdc4.zip
+  URL_MD5 83e652221b5f21d5fdb61c45f5b4d9f9
+  CONFIGURE_COMMAND CMAKE_ARGS  ${ANDROID_CMAKE_ARGS} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> ${EXTRA_CMAKE_FLAGS}
+  LOG_DOWNLOAD 1
+  LOG_CONFIGURE 1
+  LOG_BUILD 1
+)
+
+# Hide this external target (for ide users)
+set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
+ExternalProject_Get_Property(${EXTERNAL_NAME} INSTALL_DIR)
+set(${EXTERNAL_NAME_UPPER}_ROOT ${INSTALL_DIR} CACHE PATH "List of  include directories")
--- a/cmake/externals/spirv_tools/CMakeLists.txt
+++ b/cmake/externals/spirv_tools/CMakeLists.txt
@ -0,0 +1,33 @@
+set(EXTERNAL_NAME spirv_tools)
+string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
+
+include(ExternalProject)
+ExternalProject_Add(
+  ${EXTERNAL_NAME}
+  URL https://github.com/KhronosGroup/SPIRV-Tools/archive/v2018.4.zip
+  URL_MD5 7a7c69cf6ff0318910b4bfbdf30bcfc9
+  CONFIGURE_COMMAND CMAKE_ARGS  ${ANDROID_CMAKE_ARGS} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DSPIRV-Headers_SOURCE_DIR=${SPIRV_HEADERS_ROOT} -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>-$<CONFIG> ${EXTRA_CMAKE_FLAGS} 
+  LOG_DOWNLOAD 1
+  LOG_CONFIGURE 1
+  LOG_BUILD 1
+)
+
+# Hide this external target (for ide users)
+set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
+
+ExternalProject_Get_Property(${EXTERNAL_NAME} INSTALL_DIR)
+set(SUFFIXED_INSTALL_DIR "${INSTALL_DIR}-$<CONFIG>")
+
+set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${SUFFIXED_INSTALL_DIR}/include CACHE PATH "List of SPIRV-Tools include directories")
+
+if (UNIX)
+  set(LIB_PREFIX "lib")
+  set(LIB_EXT "a")
+elseif (WIN32)
+  set(LIB_EXT "lib")
+endif ()
+
+list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARIES ${SUFFIXED_INSTALL_DIR}/lib/SPIRV-Tools-opt.${LIB_EXT})
+list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARIES ${SUFFIXED_INSTALL_DIR}/lib/SPIRV-Tools-link.${LIB_EXT})
+list(APPEND ${EXTERNAL_NAME_UPPER}_LIBRARIES ${SUFFIXED_INSTALL_DIR}/lib/SPIRV-Tools.${LIB_EXT})
+set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${${EXTERNAL_NAME_UPPER}_LIBRARIES} CACHE FILEPATH "Path to SPIRV-Tool libraries")
--- a/cmake/init.cmake
+++ b/cmake/init.cmake
@ -10,6 +10,10 @@ if (POLICY CMP0042)
  cmake_policy(SET CMP0042 NEW)
 endif ()

+if (POLICY CMP0074)
+  cmake_policy(SET CMP0074 OLD)
+endif ()
+
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "CMakeTargets")
 # Hide automoc folders (for IDEs)
--- a/cmake/macros/AutoScribeShader.cmake
+++ b/cmake/macros/AutoScribeShader.cmake
@ -8,34 +8,132 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 #

+# FIXME use the built tools 
+
+macro(AUTOSCRIBE_APPEND_QRC)
+    string(CONCAT SHADER_QRC "${SHADER_QRC}" "<file alias=\"${ARGV0}\">${ARGV1}</file>\n")
+endmacro()
+
+set(VULKAN_DIR $ENV{VULKAN_SDK})
+set(GLSLANG_EXEC  "${VULKAN_DIR}/Bin/glslangValidator.exe")
+set(SPIRV_CROSS_EXEC  "${VULKAN_DIR}/Bin/spirv-cross.exe")
+set(SPIRV_OPT_EXEC  "${VULKAN_DIR}/Bin/spirv-opt.exe")
+set(GLSLC_EXEC  "${VULKAN_DIR}/Bin/glslc.exe")
+set(SCRIBE_EXEC "D:/scribe.exe")
+
+macro(AUTOSCRIBE_PLATFORM_SHADER)
+    set(AUTOSCRIBE_PLATFORM_PATH "${ARGV0}")
+    string(REGEX MATCH "([0-9]+(es)?)(/stereo)?" PLATFORM_PATH_REGEX ${AUTOSCRIBE_PLATFORM_PATH})
+    set(AUTOSCRIBE_DIALECT "${CMAKE_MATCH_1}")
+    if (CMAKE_MATCH_3)
+        set(AUTOSCRIBE_VARIANT "stereo")
+    else()
+        set(AUTOSCRIBE_VARIANT "mono")
+    endif()
+    string(REGEX REPLACE "/" "\\\\" SOURCE_GROUP_PATH ${AUTOSCRIBE_PLATFORM_PATH})
+    set(SOURCE_GROUP_PATH "${SHADER_LIB}\\${SOURCE_GROUP_PATH}")
+    set(AUTOSCRIBE_DIALECT_HEADER "${AUTOSCRIBE_HEADER_DIR}/${AUTOSCRIBE_DIALECT}/header.glsl")
+    set(AUTOSCRIBE_VARIANT_HEADER "${AUTOSCRIBE_HEADER_DIR}/${AUTOSCRIBE_VARIANT}.glsl")
+
+    set(AUTOSCRIBE_OUTPUT_FILE "${SHADERS_DIR}/${SHADER_LIB}/${AUTOSCRIBE_PLATFORM_PATH}/${SHADER_NAME}.${SHADER_TYPE}")
+    AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/${AUTOSCRIBE_PLATFORM_PATH}/scribe" "${AUTOSCRIBE_OUTPUT_FILE}")
+    source_group(${SOURCE_GROUP_PATH} FILES ${AUTOSCRIBE_OUTPUT_FILE})
+    set_property(SOURCE ${AUTOSCRIBE_OUTPUT_FILE} PROPERTY SKIP_AUTOMOC ON)
+    list(APPEND SCRIBED_SHADERS ${AUTOSCRIBE_OUTPUT_FILE})
+
+    set(AUTOSCRIBE_SPIRV_FILE "${AUTOSCRIBE_OUTPUT_FILE}.spv")
+    # don't add unoptimized spirv to the QRC
+    #AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/${AUTOSCRIBE_PLATFORM_PATH}/spirv_unopt" "${AUTOSCRIBE_SPIRV_FILE}")
+    source_group(${SOURCE_GROUP_PATH} FILES ${AUTOSCRIBE_SPIRV_FILE})
+    set_property(SOURCE ${AUTOSCRIBE_SPIRV_FILE} PROPERTY SKIP_AUTOMOC ON)
+    list(APPEND SPIRV_SHADERS ${AUTOSCRIBE_SPIRV_FILE})
+
+    set(AUTOSCRIBE_SPIRV_OPT_FILE "${AUTOSCRIBE_OUTPUT_FILE}.opt.spv")
+    AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/${AUTOSCRIBE_PLATFORM_PATH}/spirv" "${AUTOSCRIBE_SPIRV_OPT_FILE}")
+    source_group(${SOURCE_GROUP_PATH} FILES ${AUTOSCRIBE_SPIRV_OPT_FILE})
+    set_property(SOURCE ${AUTOSCRIBE_SPIRV_OPT_FILE} PROPERTY SKIP_AUTOMOC ON)
+    list(APPEND SPIRV_SHADERS ${AUTOSCRIBE_SPIRV_OPT_FILE})
+
+    set(AUTOSCRIBE_SPIRV_GLSL_FILE "${AUTOSCRIBE_OUTPUT_FILE}.glsl")
+    AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/${AUTOSCRIBE_PLATFORM_PATH}/glsl" "${AUTOSCRIBE_SPIRV_GLSL_FILE}")
+    source_group(${SOURCE_GROUP_PATH} FILES ${AUTOSCRIBE_SPIRV_GLSL_FILE})
+    set_property(SOURCE ${AUTOSCRIBE_SPIRV_GLSL_FILE} PROPERTY SKIP_AUTOMOC ON)
+    list(APPEND SPIRV_SHADERS ${AUTOSCRIBE_SPIRV_GLSL_FILE})
+
+    set(AUTOSCRIBE_SPIRV_JSON_FILE "${AUTOSCRIBE_OUTPUT_FILE}.json")
+    AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/${AUTOSCRIBE_PLATFORM_PATH}/json" "${AUTOSCRIBE_SPIRV_JSON_FILE}")
+    source_group(${SOURCE_GROUP_PATH} FILES ${AUTOSCRIBE_SPIRV_JSON_FILE})
+    set_property(SOURCE ${AUTOSCRIBE_SPIRV_JSON_FILE} PROPERTY SKIP_AUTOMOC ON)
+    list(APPEND REFLECTED_SHADERS ${AUTOSCRIBE_SPIRV_JSON_FILE})
+
+    unset(SHADER_GEN_LINE)
+    list(APPEND SHADER_GEN_LINE ${AUTOSCRIBE_DIALECT})
+    list(APPEND SHADER_GEN_LINE ${AUTOSCRIBE_VARIANT})
+    file(RELATIVE_PATH TEMP_PATH ${CMAKE_SOURCE_DIR} ${SHADER_FILE})
+    list(APPEND SHADER_GEN_LINE ${TEMP_PATH})
+    file(RELATIVE_PATH TEMP_PATH ${CMAKE_SOURCE_DIR} ${AUTOSCRIBE_OUTPUT_FILE})
+    list(APPEND SHADER_GEN_LINE ${TEMP_PATH})
+    list(APPEND SHADER_GEN_LINE ${AUTOSCRIBE_SHADER_SEEN_LIBS})
+    string(CONCAT AUTOSCRIBE_SHADERGEN_COMMANDS "${AUTOSCRIBE_SHADERGEN_COMMANDS}" "${SHADER_GEN_LINE}\n")
+
+    # # FIXME need better mechanism for determining the include files
+    # add_custom_command(
+    #     OUTPUT ${AUTOSCRIBE_OUTPUT_FILE}
+    #     COMMAND ${SCRIBE_COMMAND} ${SHADER_FILE} ${SCRIBE_ARGS} -o ${AUTOSCRIBE_OUTPUT_FILE} -h ${AUTOSCRIBE_DIALECT_HEADER} -h ${AUTOSCRIBE_VARIANT_HEADER}
+    #     DEPENDS ${SCRIBE_COMMAND} ${SHADER_FILE} ${AUTOSCRIBE_DIALECT_HEADER} ${AUTOSCRIBE_VARIANT_HEADER})
+
+    # # Generate the spirv file
+    # add_custom_command(
+    #     OUTPUT ${AUTOSCRIBE_SPIRV_FILE}
+    #     COMMAND ${GLSLANG_EXEC} -V110 -o ${AUTOSCRIBE_SPIRV_FILE} ${AUTOSCRIBE_OUTPUT_FILE}
+    #     DEPENDS ${AUTOSCRIBE_OUTPUT_FILE} ${GLSLANG_EXEC})
+
+    # # Generate the optimized spirv file
+    # add_custom_command(
+    #     OUTPUT ${AUTOSCRIBE_SPIRV_OPT_FILE}
+    #     COMMAND ${SPIRV_OPT_EXEC} -O ${AUTOSCRIBE_SPIRV_FILE} -o ${AUTOSCRIBE_SPIRV_OPT_FILE} 
+    #     DEPENDS ${AUTOSCRIBE_SPIRV_FILE} ${SPIRV_OPT_EXEC})
+
+    # # Generate the optimized GLSL file
+    # add_custom_command(
+    #     OUTPUT ${AUTOSCRIBE_SPIRV_GLSL_FILE}
+    #     COMMAND ${SPIRV_CROSS_EXEC} ${SPIRV_CROSS_ARGS} ${AUTOSCRIBE_SPIRV_OPT_FILE} --output ${AUTOSCRIBE_SPIRV_GLSL_FILE} 
+    #     DEPENDS ${AUTOSCRIBE_SPIRV_OPT_FILE} ${SPIRV_CROSS_EXEC})
+
+    # # Generate the optimized spirv file
+    # add_custom_command(
+    #     OUTPUT ${AUTOSCRIBE_SPIRV_JSON_FILE}
+    #     COMMAND ${SPIRV_CROSS_EXEC} --reflect json ${AUTOSCRIBE_SPIRV_OPT_FILE} --output ${AUTOSCRIBE_SPIRV_JSON_FILE} 
+    #     DEPENDS ${AUTOSCRIBE_SPIRV_OPT_FILE} ${SPIRV_CROSS_EXEC})
+endmacro()
+
 macro(AUTOSCRIBE_SHADER)
+    #
+    # Set the include paths
+    #
+    # FIXME base the include paths off of output from the scribe tool,
+    # instead of treating every previously seen shader as a possible header
    unset(SHADER_INCLUDE_FILES)
-    # Grab include files
    foreach(includeFile  ${ARGN})
        list(APPEND SHADER_INCLUDE_FILES ${includeFile})
    endforeach()
-
    foreach(SHADER_INCLUDE ${SHADER_INCLUDE_FILES})
        get_filename_component(INCLUDE_DIR ${SHADER_INCLUDE} PATH)
        list(APPEND SHADER_INCLUDES_PATHS ${INCLUDE_DIR})
    endforeach()
-
-    list(REMOVE_DUPLICATES SHADER_INCLUDES_PATHS)
-    #Extract the unique include shader paths
    set(INCLUDES ${HIFI_LIBRARIES_SHADER_INCLUDE_FILES})
    foreach(EXTRA_SHADER_INCLUDE ${INCLUDES})
        list(APPEND SHADER_INCLUDES_PATHS ${EXTRA_SHADER_INCLUDE})
    endforeach()
-
    list(REMOVE_DUPLICATES SHADER_INCLUDES_PATHS)
-    #message(ready for includes ${SHADER_INCLUDES_PATHS})
-
-    # make the scribe include arguments
-    set(SCRIBE_INCLUDES)
+    unset(SCRIBE_INCLUDES)
    foreach(INCLUDE_PATH ${SHADER_INCLUDES_PATHS})
        set(SCRIBE_INCLUDES ${SCRIBE_INCLUDES} -I ${INCLUDE_PATH}/)
    endforeach()

+    #
+    # Figure out the various output names
+    #
    # Define the final name of the generated shader file
    get_filename_component(SHADER_NAME ${SHADER_FILE} NAME_WE)
    get_filename_component(SHADER_EXT ${SHADER_FILE} EXT)
@ -46,38 +144,36 @@ macro(AUTOSCRIBE_SHADER)
    elseif(${SHADER_EXT} STREQUAL .slg)
        set(SHADER_TYPE geom)
    endif()
-    file(MAKE_DIRECTORY "${SHADERS_DIR}/${SHADER_LIB}")
-    set(SHADER_TARGET "${SHADERS_DIR}/${SHADER_LIB}/${SHADER_NAME}.${SHADER_TYPE}")
-    file(TO_CMAKE_PATH "${SHADER_TARGET}" COMPILED_SHADER)
-    set(REFLECTED_SHADER "${COMPILED_SHADER}.json") 

-    set(SCRIBE_ARGS -T ${SHADER_TYPE} -D GLPROFILE ${GLPROFILE} ${SCRIBE_INCLUDES} -o ${SHADER_TARGET} ${SHADER_FILE})
+    set(SCRIBE_ARGS -D GLPROFILE ${GLPROFILE} -T ${SHADER_TYPE} ${SCRIBE_INCLUDES} )

-    # Generate the frag/vert file
-    add_custom_command(
-        OUTPUT ${SHADER_TARGET}
-        COMMAND ${SCRIBE_COMMAND} ${SCRIBE_ARGS} 
-        DEPENDS ${SHADER_FILE} ${SCRIBE_COMMAND} ${SHADER_INCLUDE_FILES})
+    # SHADER_SCRIBED -> the output of scribe
+    set(SHADER_SCRIBED "${SHADERS_DIR}/${SHADER_LIB}/${SHADER_NAME}.${SHADER_TYPE}")

-    # Generate the json reflection
-    # FIXME move to spirv-cross for this task after we have spirv compatible shaders
-    add_custom_command(
-        OUTPUT ${REFLECTED_SHADER}
-        COMMAND ${SHREFLECT_COMMAND} ${COMPILED_SHADER}
-        DEPENDS ${SHREFLECT_DEPENDENCY} ${COMPILED_SHADER})
+    # SHADER_NAME_FILE -> a file containing the shader name and extension (useful for debugging and for 
+    # determining the type of shader from the filename)
+    set(SHADER_NAME_FILE "${SHADER_SCRIBED}.name")
+    file(TO_CMAKE_PATH "${SHADER_SCRIBED}" SHADER_SCRIBED)
+    file(WRITE "${SHADER_SCRIBED}.name" "${SHADER_NAME}.${SHADER_TYPE}")
+    AUTOSCRIBE_APPEND_QRC("${SHADER_COUNT}/name" "${SHADER_NAME_FILE}")

-    #output the generated file name
-    source_group("Compiled/${SHADER_LIB}" FILES ${COMPILED_SHADER})
-    set_property(SOURCE ${COMPILED_SHADER} PROPERTY SKIP_AUTOMOC ON)
-    list(APPEND COMPILED_SHADERS ${COMPILED_SHADER})
+    if (USE_GLES)
+        set(SPIRV_CROSS_ARGS --version 310es)
+        AUTOSCRIBE_PLATFORM_SHADER("310es")
+        AUTOSCRIBE_PLATFORM_SHADER("310es/stereo")
+    else()
+        set(SPIRV_CROSS_ARGS --version 410 --no-420pack-extension)
+        AUTOSCRIBE_PLATFORM_SHADER("410")
+        AUTOSCRIBE_PLATFORM_SHADER("410/stereo")
+        if (NOT APPLE)
+            set(SPIRV_CROSS_ARGS --version 450)
+            AUTOSCRIBE_PLATFORM_SHADER("450")
+            AUTOSCRIBE_PLATFORM_SHADER("450/stereo")
+        endif()
+    endif()

-    source_group("Reflected/${SHADER_LIB}" FILES ${REFLECTED_SHADER})
-    list(APPEND REFLECTED_SHADERS ${REFLECTED_SHADER})
-
-    string(CONCAT SHADER_QRC "${SHADER_QRC}" "<file alias=\"${SHADER_COUNT}\">${COMPILED_SHADER}</file>\n")
-    string(CONCAT SHADER_QRC "${SHADER_QRC}" "<file alias=\"${SHADER_COUNT}_reflection\">${REFLECTED_SHADER}</file>\n")
    string(CONCAT SHADER_ENUMS "${SHADER_ENUMS}" "${SHADER_NAME} = ${SHADER_COUNT},\n")
-
+    string(CONCAT SHADER_SHADERS_ARRAY  "${SHADER_SHADERS_ARRAY}" "${SHADER_COUNT},\n")
    MATH(EXPR SHADER_COUNT "${SHADER_COUNT}+1")
 endmacro()

@ -86,6 +182,8 @@ macro(AUTOSCRIBE_SHADER_LIB)
        message(FATAL_ERROR "AUTOSCRIBE_SHADER_LIB can only be used by the shaders library")
    endif()

+    file(MAKE_DIRECTORY "${SHADERS_DIR}/${SHADER_LIB}")
+
    list(APPEND HIFI_LIBRARIES_SHADER_INCLUDE_FILES "${CMAKE_SOURCE_DIR}/libraries/${SHADER_LIB}/src") 
    string(REGEX REPLACE "[-]" "_" SHADER_NAMESPACE ${SHADER_LIB})
    string(CONCAT SHADER_ENUMS "${SHADER_ENUMS}" "namespace ${SHADER_NAMESPACE} {\n")
@ -165,66 +263,103 @@ macro(AUTOSCRIBE_SHADER_LIB)

    # Finish the shader enums 
    string(CONCAT SHADER_ENUMS "${SHADER_ENUMS}" "} // namespace ${SHADER_NAMESPACE}\n")
-    #file(RELATIVE_PATH RELATIVE_LIBRARY_DIR_PATH ${CMAKE_CURRENT_SOURCE_DIR} "${HIFI_LIBRARY_DIR}")
-    #foreach(HIFI_LIBRARY ${ARGN})
-    #list(APPEND HIFI_LIBRARIES_SHADER_INCLUDE_FILES ${HIFI_LIBRARY_DIR}/${HIFI_LIBRARY}/src)
-    #endforeach()
-    #endif()
 endmacro()

 macro(AUTOSCRIBE_SHADER_LIBS)
-    set(SCRIBE_COMMAND scribe)
-    set(SHREFLECT_COMMAND shreflect)
-    set(SHREFLECT_DEPENDENCY shreflect)
-
-    # Target dependant Custom rule on the SHADER_FILE
-    if (ANDROID)
-        set(GLPROFILE LINUX_GL)
-        set(SCRIBE_COMMAND ${NATIVE_SCRIBE})
-        set(SHREFLECT_COMMAND ${NATIVE_SHREFLECT})
-        unset(SHREFLECT_DEPENDENCY)
-    else() 
-        if (APPLE)
-            set(GLPROFILE MAC_GL)
-        elseif(UNIX)
-            set(GLPROFILE LINUX_GL)
-        else()
-            set(GLPROFILE PC_GL)
-        endif()
-    endif()
-
+    message(STATUS "Shader processing start")
+    set(AUTOSCRIBE_HEADER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/headers)
    # Start the shader IDs
-    set(SHADER_COUNT 1)
    set(SHADERS_DIR "${CMAKE_CURRENT_BINARY_DIR}/shaders")
-    set(SHADER_ENUMS "")
    file(MAKE_DIRECTORY ${SHADERS_DIR})
+    set(SHADER_ENUMS "")
+    set(SHADER_COUNT 1)

    #
    # Scribe generation & program defintiion
    # 
    foreach(SHADER_LIB ${ARGN})
+        list(APPEND AUTOSCRIBE_SHADER_SEEN_LIBS ${SHADER_LIB})
        AUTOSCRIBE_SHADER_LIB(${SHADER_LIB})
    endforeach()

    # Generate the library files
    configure_file(
        ShaderEnums.cpp.in 
-        ${CMAKE_CURRENT_BINARY_DIR}/shaders/ShaderEnums.cpp)
+        ${CMAKE_CURRENT_BINARY_DIR}/ShaderEnums.cpp)
    configure_file(
        ShaderEnums.h.in 
-        ${CMAKE_CURRENT_BINARY_DIR}/shaders/ShaderEnums.h)
-    configure_file(
-        shaders.qrc.in 
-        ${CMAKE_CURRENT_BINARY_DIR}/shaders.qrc)
+        ${CMAKE_CURRENT_BINARY_DIR}/ShaderEnums.h)

-    set(AUTOSCRIBE_SHADER_LIB_SRC "${CMAKE_CURRENT_BINARY_DIR}/shaders/ShaderEnums.h;${CMAKE_CURRENT_BINARY_DIR}/shaders/ShaderEnums.cpp")
-    set(QT_RESOURCES_FILE ${CMAKE_CURRENT_BINARY_DIR}/shaders.qrc)
+    configure_file(shaders.qrc.in ${CMAKE_CURRENT_BINARY_DIR}/shaders.qrc)
+    list(APPEND QT_RESOURCES_FILE ${CMAKE_CURRENT_BINARY_DIR}/shaders.qrc)
+
+    list(APPEND AUTOSCRIBE_SHADER_HEADERS ${AUTOSCRIBE_HEADER_DIR}/mono.glsl ${AUTOSCRIBE_HEADER_DIR}/stereo.glsl)
+    list(APPEND AUTOSCRIBE_SHADER_HEADERS ${AUTOSCRIBE_HEADER_DIR}/450/header.glsl ${AUTOSCRIBE_HEADER_DIR}/410/header.glsl ${AUTOSCRIBE_HEADER_DIR}/310es/header.glsl)
+    source_group("Shader Headers" FILES ${AUTOSCRIBE_HEADER_DIR}/mono.glsl ${AUTOSCRIBE_HEADER_DIR}/stereo.glsl)
+    source_group("Shader Headers\\450" FILES ${AUTOSCRIBE_HEADER_DIR}/450/header.glsl)
+    source_group("Shader Headers\\410" FILES ${AUTOSCRIBE_HEADER_DIR}/410/header.glsl)
+    source_group("Shader Headers\\310es" FILES ${AUTOSCRIBE_HEADER_DIR}/310es/header.glsl)
+
+    list(APPEND AUTOSCRIBE_SHADER_LIB_SRC ${AUTOSCRIBE_SHADER_HEADERS})
+    list(APPEND AUTOSCRIBE_SHADER_LIB_SRC ${CMAKE_CURRENT_BINARY_DIR}/ShaderEnums.h ${CMAKE_CURRENT_BINARY_DIR}/ShaderEnums.cpp)
    
+    # Write the shadergen command list
+    set(AUTOSCRIBE_SHADERGEN_COMMANDS_FILE ${CMAKE_CURRENT_BINARY_DIR}/shadergen.txt)
+    file(WRITE ${AUTOSCRIBE_SHADERGEN_COMMANDS_FILE} "${AUTOSCRIBE_SHADERGEN_COMMANDS}")
+
+    # grab the SPIRV binaries we require
+    # note we don't use the normal ADD_DEPENDENCY_EXTERNAL_PROJECTS macro because only a custom command 
+    # depends on these, not any of our build artifacts, so there's no valid target for the add_dependencies
+    # call in ADD_DEPENDENCY_EXTERNAL_PROJECTS to use
+    add_subdirectory(${EXTERNAL_PROJECT_DIR}/spirv_binaries ${EXTERNALS_BINARY_DIR}/spirv_binaries)
+
+    target_python()
+
+    # A custom python script which will generate 
+    if (ANDROID)
+        add_custom_command(
+            OUTPUT ${SCRIBED_SHADERS} ${SPIRV_SHADERS} ${REFLECTED_SHADERS}
+            COMMENT "Generating/updating shaders"
+            COMMAND ${HIFI_PYTHON_EXEC} ${CMAKE_SOURCE_DIR}/tools/shadergen.py 
+                --commands ${AUTOSCRIBE_SHADERGEN_COMMANDS_FILE} 
+                --spirv-binaries ${SPIRV_BINARIES_DIR} 
+                --scribe ${NATIVE_SCRIBE}
+                --build-dir ${CMAKE_CURRENT_BINARY_DIR}
+                --source-dir ${CMAKE_SOURCE_DIR}
+            DEPENDS ${AUTOSCRIBE_SHADER_HEADERS} spirv_binaries ${CMAKE_SOURCE_DIR}/tools/shadergen.py ${ALL_SCRIBE_SHADERS})
+    else() 
+        add_custom_command(
+            OUTPUT ${SCRIBED_SHADERS} ${SPIRV_SHADERS} ${REFLECTED_SHADERS}
+            COMMENT "Generating/updating shaders"
+            COMMAND ${HIFI_PYTHON_EXEC} ${CMAKE_SOURCE_DIR}/tools/shadergen.py 
+                --commands ${AUTOSCRIBE_SHADERGEN_COMMANDS_FILE} 
+                --spirv-binaries ${SPIRV_BINARIES_DIR} 
+                --scribe $<TARGET_FILE:scribe>
+                --build-dir ${CMAKE_CURRENT_BINARY_DIR}
+                --source-dir ${CMAKE_SOURCE_DIR}
+            DEPENDS ${AUTOSCRIBE_SHADER_HEADERS} scribe spirv_binaries ${CMAKE_SOURCE_DIR}/tools/shadergen.py ${ALL_SCRIBE_SHADERS})
+    endif()
+
+    add_custom_target(shadergen DEPENDS ${SCRIBED_SHADERS} ${SPIRV_SHADERS} ${REFLECTED_SHADERS})
+    set_target_properties(shadergen PROPERTIES FOLDER "Shaders")
+
    # Custom targets required to force generation of the shaders via scribe
-    add_custom_target(scribe_shaders SOURCES ${ALL_SCRIBE_SHADERS})
-    add_custom_target(compiled_shaders SOURCES ${COMPILED_SHADERS})
-    add_custom_target(reflected_shaders SOURCES ${REFLECTED_SHADERS})
+    add_custom_target(scribe_shaders SOURCES ${ALL_SCRIBE_SHADERS} ${AUTOSCRIBE_SHADER_HEADERS})
    set_target_properties(scribe_shaders PROPERTIES FOLDER "Shaders")
-    set_target_properties(compiled_shaders PROPERTIES FOLDER "Shaders")
+
+    add_custom_target(scribed_shaders SOURCES ${SCRIBED_SHADERS})
+    set_target_properties(scribed_shaders PROPERTIES FOLDER "Shaders")
+    add_dependencies(scribed_shaders shadergen)
+
+    add_custom_target(spirv_shaders SOURCES ${SPIRV_SHADERS})
+    set_target_properties(spirv_shaders PROPERTIES FOLDER "Shaders")
+    add_dependencies(spirv_shaders shadergen)
+
+    add_custom_target(reflected_shaders SOURCES ${REFLECTED_SHADERS})
    set_target_properties(reflected_shaders PROPERTIES FOLDER "Shaders")
+    add_dependencies(reflected_shaders shadergen)
+
+    message(STATUS "Shader processing end")
 endmacro()
+
+
--- a/cmake/macros/ConfigureCCache.cmake
+++ b/cmake/macros/ConfigureCCache.cmake
@ -0,0 +1,45 @@
+#
+#  ConfigureCCache.cmake
+#  cmake/macros
+#
+#  Created by Clement Brisset on 10/10/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
+#
+
+macro(configure_ccache)
+  find_program(CCACHE_PROGRAM ccache)
+  if(CCACHE_PROGRAM)
+    message(STATUS "Configuring ccache")
+
+    # Set up wrapper scripts
+    set(C_LAUNCHER   "${CCACHE_PROGRAM}")
+    set(CXX_LAUNCHER "${CCACHE_PROGRAM}")
+    
+    set(LAUNCH_C_IN "${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/launch-c.in")
+    set(LAUNCH_CXX_IN "${CMAKE_CURRENT_SOURCE_DIR}/cmake/templates/launch-cxx.in")
+    set(LAUNCH_C "${CMAKE_BINARY_DIR}/CMakeFiles/launch-c")
+    set(LAUNCH_CXX "${CMAKE_BINARY_DIR}/CMakeFiles/launch-cxx")
+
+    configure_file(${LAUNCH_C_IN} ${LAUNCH_C})
+    configure_file(${LAUNCH_CXX_IN} ${LAUNCH_CXX})
+    execute_process(COMMAND chmod a+rx ${LAUNCH_C} ${LAUNCH_CXX})
+
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
+      # Set Xcode project attributes to route compilation and linking
+      # through our scripts
+      set(CMAKE_XCODE_ATTRIBUTE_CC ${LAUNCH_C})
+      set(CMAKE_XCODE_ATTRIBUTE_CXX ${LAUNCH_CXX})
+      set(CMAKE_XCODE_ATTRIBUTE_LD ${LAUNCH_C})
+      set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS ${LAUNCH_CXX})
+    else()
+      # Support Unix Makefiles and Ninja
+      set(CMAKE_C_COMPILER_LAUNCHER ${LAUNCH_C})
+      set(CMAKE_CXX_COMPILER_LAUNCHER ${LAUNCH_CXX})
+    endif()
+  else()
+    message(WARNING "Could not find ccache")
+  endif()
+endmacro()
--- a/cmake/macros/TargetPython.cmake
+++ b/cmake/macros/TargetPython.cmake
@ -0,0 +1,22 @@
+macro(TARGET_PYTHON)
+    if (NOT HIFI_PYTHON_EXEC)
+        # Find the python interpreter
+        if (CAME_VERSION VERSION_LESS 3.12)
+            # this logic is deprecated in CMake after 3.12
+            # FIXME eventually we should make 3.12 the min cmake verion and just use the Python3 find_package path
+            set(Python_ADDITIONAL_VERSIONS 3)
+            find_package(PythonInterp)
+            set(HIFI_PYTHON_VERSION ${PYTHON_VERSION_STRING})
+            set(HIFI_PYTHON_EXEC ${PYTHON_EXECUTABLE})
+        else()
+            # the new hotness
+            find_package(Python3)
+            set(HIFI_PYTHON_VERSION ${Python3_VERSION})
+            set(HIFI_PYTHON_EXEC ${Python3_EXECUTABLE})
+        endif()
+
+        if ((NOT HIFI_PYTHON_EXEC) OR (HIFI_PYTHON_VERSION VERSION_LESS 3.5))
+            message(FATAL_ERROR "Unable to locate Python interpreter 3.5 or higher")
+        endif()
+    endif()
+endmacro()
--- a/cmake/macros/TargetSPIRV.cmake
+++ b/cmake/macros/TargetSPIRV.cmake
@ -0,0 +1,15 @@
+macro(TARGET_SPIRV)
+    add_dependency_external_projects(spirv_cross)
+    target_link_libraries(${TARGET_NAME} ${SPIRV_CROSS_LIBRARIES})
+    target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${SPIRV_CROSS_INCLUDE_DIRS})
+    
+    # spirv-tools requires spirv-headers
+    add_dependency_external_projects(spirv_headers)
+    add_dependency_external_projects(spirv_tools)
+    target_link_libraries(${TARGET_NAME} ${SPIRV_TOOLS_LIBRARIES})
+    target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${SPIRV_TOOLS_INCLUDE_DIRS})
+    
+    add_dependency_external_projects(glslang)
+    target_link_libraries(${TARGET_NAME} ${GLSLANG_LIBRARIES})
+    target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${GLSLANG_INCLUDE_DIRS})
+endmacro()
--- a/cmake/macros/TargetSpirvBinaries.cmake
+++ b/cmake/macros/TargetSpirvBinaries.cmake
@ -0,0 +1,10 @@
+# 
+#  Created by Bradley Austin Davis on 2016/02/16
+#
+#  Distributed under the Apache License, Version 2.0.
+#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+# 
+macro(TARGET_SPIRV_BINARIES)
+    add_dependency_external_projects(spirv_binaries)
+endmacro()
+
--- a/cmake/macros/TargetVulkan.cmake
+++ b/cmake/macros/TargetVulkan.cmake
@ -0,0 +1,19 @@
+# 
+#  Created by Bradley Austin Davis on 2016/02/16
+#
+#  Distributed under the Apache License, Version 2.0.
+#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+# 
+macro(TARGET_VULKAN)
+    find_package(Vulkan)
+
+    if (Vulkan_FOUND)
+        add_definitions(-DHAVE_VULKAN) 
+        target_include_directories(${TARGET_NAME} PRIVATE ${Vulkan_INCLUDE_DIRS})
+        target_link_libraries(${TARGET_NAME} ${Vulkan_LIBRARIES})
+
+        add_dependency_external_projects(glslang)
+        target_include_directories(${TARGET_NAME} PRIVATE ${GLSLANG_INCLUDE_DIRS})
+        target_link_libraries(${TARGET_NAME} ${GLSLANG_LIBRARIES})
+    endif()
+endmacro()
--- a/cmake/templates/launch-c.in
+++ b/cmake/templates/launch-c.in
@ -0,0 +1,12 @@
+#!/bin/sh
+
+# Xcode generator doesn't include the compiler as the
+# first argument, Ninja and Makefiles do. Handle both cases.
+if [[ "$1" = "${CMAKE_C_COMPILER}" ]] ; then
+    shift
+fi
+
+export CCACHE_CPP2=true
+export CCACHE_HARDLINK=true
+export CCACHE_SLOPPINESS=file_macro,time_macros,include_file_mtime,include_file_ctime,file_stat_matches
+exec "${C_LAUNCHER}" "${CMAKE_C_COMPILER}" "$@"
--- a/cmake/templates/launch-cxx.in
+++ b/cmake/templates/launch-cxx.in
@ -0,0 +1,12 @@
+#!/bin/sh
+
+# Xcode generator doesn't include the compiler as the
+# first argument, Ninja and Makefiles do. Handle both cases.
+if [[ "$1" = "${CMAKE_CXX_COMPILER}" ]] ; then
+    shift
+fi
+
+export CCACHE_CPP2=true
+export CCACHE_HARDLINK=true
+export CCACHE_SLOPPINESS=file_macro,time_macros,include_file_mtime,include_file_ctime,file_stat_matches
+exec "${CXX_LAUNCHER}" "${CMAKE_CXX_COMPILER}" "$@"
--- a/domain-server/resources/web/content/js/content.js
+++ b/domain-server/resources/web/content/js/content.js
@ -59,6 +59,7 @@ $(document).ready(function(){
        $.ajax({
          url: '/content/upload',
          type: 'POST',
+          timeout: 3600000, // Set timeout to 1h
          cache: false,
          processData: false,
          contentType: false,
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@ -2906,7 +2906,7 @@ void DomainServer::updateReplicationNodes(ReplicationServerDirection direction)
        // collect them in a vector to separately remove them with handleKillNode (since eachNode has a read lock and
        // we cannot recursively take the write lock required by handleKillNode)
        std::vector<SharedNodePointer> nodesToKill;
-        nodeList->eachNode([direction, replicationNodesInSettings, replicationDirection, &nodesToKill](const SharedNodePointer& otherNode) {
+        nodeList->eachNode([&direction, &replicationNodesInSettings, &replicationDirection, &nodesToKill](const SharedNodePointer& otherNode) {
            if ((direction == Upstream && NodeType::isUpstream(otherNode->getType()))
                || (direction == Downstream && NodeType::isDownstream(otherNode->getType()))) {
                bool nodeInSettings = find(replicationNodesInSettings.cbegin(), replicationNodesInSettings.cend(),
--- a/interface/resources/controllers/keyboardMouse.json
+++ b/interface/resources/controllers/keyboardMouse.json
@ -133,7 +133,7 @@
        { "from": "Keyboard.W", "when": "!Keyboard.Control", "to": "Actions.LONGITUDINAL_FORWARD" },
        { "from": "Keyboard.S", "when": "!Keyboard.Control", "to": "Actions.LONGITUDINAL_BACKWARD" },
        { "from": "Keyboard.Shift", "when": ["!Keyboard.Left", "!Keyboard.Right"], "to": "Actions.SPRINT" },
-        { "from": "Keyboard.C", "to": "Actions.VERTICAL_DOWN" },
+        { "from": "Keyboard.C", "when": "!Keyboard.Control", "to": "Actions.VERTICAL_DOWN" },
        { "from": "Keyboard.Left", "when": "Keyboard.Shift", "to": "Actions.LATERAL_LEFT" },
        { "from": "Keyboard.Right", "when": "Keyboard.Shift", "to": "Actions.LATERAL_RIGHT" },
        { "from": "Keyboard.Up", "when": "Application.CameraFirstPerson", "to": "Actions.LONGITUDINAL_FORWARD" },
--- a/interface/resources/html/img/tablet-help-keyboard.jpg
+++ b/interface/resources/html/img/tablet-help-keyboard.jpg
--- a/interface/resources/meshes/controller/touch/touch_l_bumper.fbx
+++ b/interface/resources/meshes/controller/touch/touch_l_bumper.fbx
--- a/interface/resources/meshes/controller/touch/touch_l_button_x.fbx
+++ b/interface/resources/meshes/controller/touch/touch_l_button_x.fbx
--- a/interface/resources/meshes/controller/touch/touch_l_button_y.fbx
+++ b/interface/resources/meshes/controller/touch/touch_l_button_y.fbx
--- a/interface/resources/meshes/controller/touch/touch_l_joystick.fbx
+++ b/interface/resources/meshes/controller/touch/touch_l_joystick.fbx
--- a/interface/resources/meshes/controller/touch/touch_l_trigger.fbx
+++ b/interface/resources/meshes/controller/touch/touch_l_trigger.fbx
--- a/interface/resources/meshes/controller/touch/touch_r_bumper.fbx
+++ b/interface/resources/meshes/controller/touch/touch_r_bumper.fbx
--- a/interface/resources/meshes/controller/touch/touch_r_button_a.fbx
+++ b/interface/resources/meshes/controller/touch/touch_r_button_a.fbx
--- a/interface/resources/meshes/controller/touch/touch_r_button_b.fbx
+++ b/interface/resources/meshes/controller/touch/touch_r_button_b.fbx
--- a/interface/resources/meshes/controller/touch/touch_r_joystick.fbx
+++ b/interface/resources/meshes/controller/touch/touch_r_joystick.fbx
--- a/interface/resources/meshes/controller/touch/touch_r_trigger.fbx
+++ b/interface/resources/meshes/controller/touch/touch_r_trigger.fbx
--- a/interface/resources/qml/hifi/commerce/common/images/Purchase-First-Run-1.jpg
+++ b/interface/resources/qml/hifi/commerce/common/images/Purchase-First-Run-1.jpg
--- a/interface/resources/qml/hifi/commerce/common/images/Purchase-First-Run-2.jpg
+++ b/interface/resources/qml/hifi/commerce/common/images/Purchase-First-Run-2.jpg
--- a/interface/resources/qml/hifi/commerce/common/sendAsset/SendAsset.qml
+++ b/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)) {
--- a/interface/resources/qml/hifi/commerce/purchases/Purchases.qml
+++ b/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;
--- a/interface/resources/qml/hifi/commerce/wallet/Wallet.qml
+++ b/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;
--- a/interface/resources/qml/hifi/tablet/NewModelDialog.qml
+++ b/interface/resources/qml/hifi/tablet/NewModelDialog.qml
@ -116,9 +116,14 @@ Rectangle {
            Column {
                id: column2
                width: 200
-                height: 400
+                height: 600
                spacing: 10

+                CheckBox {
+                    id: grabbable
+                    text: qsTr("Grabbable")
+                }
+
                CheckBox {
                    id: dynamic
                    text: qsTr("Dynamic")
@ -217,9 +222,10 @@ Rectangle {
                            newModelDialog.sendToScript({
                                method: "newModelDialogAdd",
                                params: {
-                                    textInput: modelURL.text,
-                                    checkBox: dynamic.checked,
-                                    comboBox: collisionType.currentIndex
+                                    url: modelURL.text,
+                                    dynamic: dynamic.checked,
+                                    collisionShapeIndex: collisionType.currentIndex,
+                                    grabbable: grabbable.checked
                                }
                            });
                        }
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -3534,6 +3534,7 @@ void Application::setIsInterstitialMode(bool interstitialMode) {
    if (enableInterstitial) {
        if (_interstitialMode != interstitialMode) {
            _interstitialMode = interstitialMode;
+            emit interstitialModeChanged(_interstitialMode);

            DependencyManager::get<AudioClient>()->setAudioPaused(_interstitialMode);
            DependencyManager::get<AvatarManager>()->setMyAvatarDataPacketsPaused(_interstitialMode);
@ -8476,6 +8477,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;
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@ -52,7 +52,6 @@
 #include <RunningMarker.h>

 #include "avatar/MyAvatar.h"
-#include "BandwidthRecorder.h"
 #include "FancyCamera.h"
 #include "ConnectionMonitor.h"
 #include "CursorManager.h"
@ -298,6 +297,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; }
@ -334,6 +334,8 @@ signals:

    void uploadRequest(QString path);

+    void interstitialModeChanged(bool isInInterstitialMode);
+
    void loginDialogPoppedUp();

 public slots:
--- a/interface/src/AvatarBookmarks.cpp
+++ b/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();
--- a/interface/src/avatar/AvatarManager.cpp
+++ b/interface/src/avatar/AvatarManager.cpp
@ -55,15 +55,7 @@ static const quint64 MIN_TIME_BETWEEN_MY_AVATAR_DATA_SENDS = USECS_PER_SECOND /
 // We add _myAvatar into the hash with all the other AvatarData, and we use the default NULL QUid as the key.
 const QUuid MY_AVATAR_KEY;  // NULL key

-namespace {
-    // For an unknown avatar-data packet, wait this long before requesting the identity.
-    constexpr std::chrono::milliseconds REQUEST_UNKNOWN_IDENTITY_DELAY { 5 * 1000 };
-    constexpr int REQUEST_UNKNOWN_IDENTITY_TRANSMITS = 3;
-}
-using std::chrono::steady_clock;
-
 AvatarManager::AvatarManager(QObject* parent) :
-    _avatarsToFade(),
    _myAvatar(new MyAvatar(qApp->thread()), [](MyAvatar* ptr) { ptr->deleteLater(); })
 {
    // register a meta type for the weak pointer we'll use for the owning avatar mixer for each avatar
@ -322,28 +314,6 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {

    simulateAvatarFades(deltaTime);

-    // Check on avatars with pending identities:
-    steady_clock::time_point now = steady_clock::now();
-    QWriteLocker writeLock(&_hashLock);
-    for (auto pendingAvatar = _pendingAvatars.begin(); pendingAvatar != _pendingAvatars.end(); ++pendingAvatar) {
-        if (now - pendingAvatar->creationTime >= REQUEST_UNKNOWN_IDENTITY_DELAY) {
-            // Too long without an ID
-            sendIdentityRequest(pendingAvatar->avatar->getID());
-            if (++pendingAvatar->transmits >= REQUEST_UNKNOWN_IDENTITY_TRANSMITS) {
-                qCDebug(avatars) << "Requesting identity for unknown avatar (final request)" <<
-                    pendingAvatar->avatar->getID().toString();
-
-                pendingAvatar = _pendingAvatars.erase(pendingAvatar);
-                if (pendingAvatar == _pendingAvatars.end()) {
-                    break;
-                }
-            } else {
-                pendingAvatar->creationTime = now;
-                qCDebug(avatars) << "Requesting identity for unknown avatar" << pendingAvatar->avatar->getID().toString();
-            }
-        }
-    }
-
    _avatarSimulationTime = (float)(usecTimestampNow() - startTime) / (float)USECS_PER_MSEC;
 }

--- a/interface/src/avatar/AvatarManager.h
+++ b/interface/src/avatar/AvatarManager.h
@ -55,6 +55,7 @@ using SortedAvatar = std::pair<float, std::shared_ptr<Avatar>>;
 * @borrows AvatarList.sessionUUIDChanged as sessionUUIDChanged
 * @borrows AvatarList.processAvatarDataPacket as processAvatarDataPacket
 * @borrows AvatarList.processAvatarIdentityPacket as processAvatarIdentityPacket
+ * @borrows AvatarList.processBulkAvatarTraits as processBulkAvatarTraits
 * @borrows AvatarList.processKillAvatar as processKillAvatar
 */

@ -152,6 +153,13 @@ public:
                                                                        const QVector<EntityItemID>& avatarsToInclude,
                                                                        const QVector<EntityItemID>& avatarsToDiscard);

+    /**jsdoc
+     * @function AvatarManager.findParabolaIntersectionVector
+     * @param {PickParabola} pick
+     * @param {Uuid[]} avatarsToInclude
+     * @param {Uuid[]} avatarsToDiscard
+     * @returns {ParabolaToAvatarIntersectionResult}
+     */
    Q_INVOKABLE ParabolaToAvatarIntersectionResult findParabolaIntersectionVector(const PickParabola& pick,
                                                                                  const QVector<EntityItemID>& avatarsToInclude,
                                                                                  const QVector<EntityItemID>& avatarsToDiscard);
@ -176,7 +184,7 @@ public:
     * than iterating over each avatar and obtaining data about them in JavaScript, as that method
     * locks and unlocks each avatar's data structure potentially hundreds of times per update tick.
     * @function AvatarManager.getPalData
-     * @param {string[]} specificAvatarIdentifiers - A list of specific Avatar Identifiers about
+     * @param {string[]} [specificAvatarIdentifiers] - A list of specific Avatar Identifiers about
     * which you want to get PAL data
     * @returns {object}
     */
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/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");

--- a/interface/src/avatar/MyAvatar.h
+++ b/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;
--- a/interface/src/avatar/MySkeletonModel.cpp
+++ b/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 {
--- a/interface/src/avatar/OtherAvatar.cpp
+++ b/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;
--- a/interface/src/octree/OctreePacketProcessor.cpp
+++ b/interface/src/octree/OctreePacketProcessor.cpp
@ -91,7 +91,9 @@ void OctreePacketProcessor::processPacket(QSharedPointer<ReceivedMessage> messag
        return; // bail since piggyback version doesn't match
    }

-    qApp->trackIncomingOctreePacket(*message, sendingNode, wasStatsPacket);
+    if (packetType != PacketType::EntityQueryInitialResultsComplete) {
+        qApp->trackIncomingOctreePacket(*message, sendingNode, wasStatsPacket);
+    }
    
    // seek back to beginning of packet after tracking
    message->seek(0);
--- a/interface/src/raypick/CollisionPick.h
+++ b/interface/src/raypick/CollisionPick.h
@ -76,4 +76,4 @@ protected:
    bool _includeNormals;
 };

-#endif // hifi_CollisionPick_h
+#endif // hifi_CollisionPick_h
--- a/interface/src/raypick/ParabolaPointer.cpp
+++ b/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()) {
--- a/interface/src/raypick/PathPointer.h
+++ b/interface/src/raypick/PathPointer.h
@ -27,7 +27,7 @@ class StartEndRenderState {
 public:
    StartEndRenderState() {}
    StartEndRenderState(const OverlayID& startID, const OverlayID& endID);
-    virtual ~StartEndRenderState() {}
+    virtual ~StartEndRenderState() = default;

    const OverlayID& getStartID() const { return _startID; }
    const OverlayID& getEndID() const { return _endID; }
--- a/interface/src/scripting/SelectionScriptingInterface.cpp
+++ b/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;
--- a/interface/src/scripting/WindowScriptingInterface.cpp
+++ b/interface/src/scripting/WindowScriptingInterface.cpp
@ -54,6 +54,9 @@ WindowScriptingInterface::WindowScriptingInterface() {
    });

    connect(qApp->getWindow(), &MainWindow::windowGeometryChanged, this, &WindowScriptingInterface::onWindowGeometryChanged);
+    connect(qApp, &Application::interstitialModeChanged, [this] (bool interstitialMode) {
+        emit interstitialModeChanged(interstitialMode);
+    });
 }

 WindowScriptingInterface::~WindowScriptingInterface() {
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@ -619,6 +619,14 @@ signals:
     */
    void redirectErrorStateChanged(bool isInErrorState);

+    /**jsdoc
+     * Triggered when interstitial mode changes.
+     * @function Window.interstitialModeChanged
+     * @param {bool} interstitialMode - The mode of the interstitial is changed to.
+     * @returns {Signal}
+     */
+    void interstitialModeChanged(bool interstitialMode);
+
    /**jsdoc
     * Triggered when a still snapshot has been taken by calling {@link Window.takeSnapshot|takeSnapshot} with 
     *     <code>includeAnimated = false</code> or {@link Window.takeSecondaryCameraSnapshot|takeSecondaryCameraSnapshot}.
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/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);
--- a/interface/src/ui/overlays/Circle3DOverlay.h
+++ b/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 };
--- a/interface/src/ui/overlays/ContextOverlayInterface.cpp
+++ b/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);
--- a/interface/src/ui/overlays/Cube3DOverlay.cpp
+++ b/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) {
--- a/interface/src/ui/overlays/Grid3DOverlay.cpp
+++ b/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;

--- a/interface/src/ui/overlays/Image3DOverlay.cpp
+++ b/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
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/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());
--- a/interface/src/ui/overlays/Overlay.cpp
+++ b/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;
 }
--- a/interface/src/ui/overlays/Overlay.h
+++ b/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;
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/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);
--- a/interface/src/ui/overlays/Overlays.h
+++ b/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);
--- a/interface/src/ui/overlays/Planar3DOverlay.cpp
+++ b/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);
--- a/interface/src/ui/overlays/Rectangle3DOverlay.cpp
+++ b/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) {
--- a/interface/src/ui/overlays/Shape3DOverlay.cpp
+++ b/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);
        }
    }
 }
--- a/interface/src/ui/overlays/Sphere3DOverlay.cpp
+++ b/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;

--- a/interface/src/ui/overlays/Text3DOverlay.cpp
+++ b/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");
--- a/interface/src/ui/overlays/Text3DOverlay.h
+++ b/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 };
--- a/libraries/animation/src/AnimVariant.cpp
+++ b/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()));
@ -169,7 +169,8 @@ std::map<QString, QString> AnimVariantMap::toDebugMap() const {
            break;
            */
        default:
-            assert(("invalid AnimVariant::Type", false));
+            // invalid AnimVariant::Type
+            assert(false);
        }
    }
    return result;
--- a/libraries/animation/src/AnimationCache.h
+++ b/libraries/animation/src/AnimationCache.h
@ -22,7 +22,7 @@

 class Animation;

-typedef QSharedPointer<Animation> AnimationPointer;
+using AnimationPointer = QSharedPointer<Animation>;

 class AnimationCache : public ResourceCache, public Dependency  {
    Q_OBJECT
--- a/libraries/animation/src/Rig.cpp
+++ b/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");
--- a/libraries/animation/src/Rig.h
+++ b/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 };

--- a/libraries/audio/src/AudioInjectorOptions.cpp
+++ b/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));
--- a/libraries/avatars-renderer/CMakeLists.txt
+++ b/libraries/avatars-renderer/CMakeLists.txt
@ -1,6 +1,6 @@
 set(TARGET_NAME avatars-renderer)
 setup_hifi_library(Network Script)
-link_hifi_libraries(shared gpu graphics animation model-networking script-engine render render-utils image trackers entities-renderer)
+link_hifi_libraries(shared shaders gpu graphics animation model-networking script-engine render render-utils image trackers entities-renderer)
 include_hifi_library_headers(avatars)
 include_hifi_library_headers(networking)
 include_hifi_library_headers(fbx)
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/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);
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h
+++ b/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
--- a/libraries/avatars/src/AvatarData.cpp
+++ b/libraries/avatars/src/AvatarData.cpp
@ -2885,10 +2885,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;
--- a/libraries/avatars/src/AvatarHashMap.cpp
+++ b/libraries/avatars/src/AvatarHashMap.cpp
@ -259,7 +259,6 @@ AvatarSharedPointer AvatarHashMap::parseAvatarData(QSharedPointer<ReceivedMessag

        if (isNewAvatar) {
            QWriteLocker locker(&_hashLock);
-            _pendingAvatars.insert(sessionUUID, { std::chrono::steady_clock::now(), 0, avatar });
            avatar->setIsNewAvatar(true);
            auto replicaIDs = _replicas.getReplicaIDs(sessionUUID);
            for (auto replicaID : replicaIDs) {
@ -306,7 +305,6 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage>

        {
            QReadLocker locker(&_hashLock);
-            _pendingAvatars.remove(identityUUID);
            auto me = _avatarHash.find(EMPTY);
            if ((me != _avatarHash.end()) && (identityUUID == me.value()->getSessionUUID())) {
                // We add MyAvatar to _avatarHash with an empty UUID. Code relies on this. In order to correctly handle an
@ -325,7 +323,6 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage>
            // In this case, the "sendingNode" is the Avatar Mixer.
            avatar->processAvatarIdentity(avatarIdentityStream, identityChanged, displayNameChanged);
            _replicas.processAvatarIdentity(identityUUID, message->getMessage(), identityChanged, displayNameChanged);
-
        }
    }
 }
@ -427,7 +424,6 @@ void AvatarHashMap::removeAvatar(const QUuid& sessionUUID, KillAvatarReason remo
            }
        }

-        _pendingAvatars.remove(sessionUUID);
        auto removedAvatar = _avatarHash.take(sessionUUID);

        if (removedAvatar) {
--- a/libraries/avatars/src/AvatarHashMap.h
+++ b/libraries/avatars/src/AvatarHashMap.h
@ -161,6 +161,11 @@ protected slots:
     */
    void processAvatarIdentityPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
    
+    /**jsdoc
+     * @function AvatarList.processBulkAvatarTraits
+     * @param {} message
+     * @param {} sendingNode
+     */
    void processBulkAvatarTraits(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
    
    /**jsdoc
@ -183,15 +188,8 @@ protected:
    
    virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason);
    
-    AvatarHash _avatarHash;
-    struct PendingAvatar {
-        std::chrono::steady_clock::time_point creationTime;
-        int transmits;
-        AvatarSharedPointer avatar;
-    };
-    using AvatarPendingHash = QHash<QUuid, PendingAvatar>;
-    AvatarPendingHash _pendingAvatars;
    mutable QReadWriteLock _hashLock;
+    AvatarHash _avatarHash;

    std::unordered_map<QUuid, AvatarTraits::TraitVersions> _processedTraitVersions;
    AvatarReplicas _replicas;
--- a/libraries/controllers/src/controllers/InputDevice.h
+++ b/libraries/controllers/src/controllers/InputDevice.h
@ -98,7 +98,7 @@ enum Hand {
 class InputDevice {
 public:
    InputDevice(const QString& name) : _name(name) {}
-    virtual ~InputDevice() {}
+    virtual ~InputDevice() = default;

    using Pointer = std::shared_ptr<InputDevice>;

--- a/libraries/controllers/src/controllers/Pose.cpp
+++ b/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;
    }
--- a/libraries/controllers/src/controllers/impl/Conditional.h
+++ b/libraries/controllers/src/controllers/impl/Conditional.h
@ -30,6 +30,8 @@ namespace controller {
        using Factory = hifi::SimpleFactory<Conditional, QString>;
        using Lambda = std::function<bool()>;

+        virtual ~Conditional() = default;
+
        virtual bool satisfied() = 0;
        virtual bool parseParameters(const QJsonValue& parameters) { return true; }

--- a/libraries/controllers/src/controllers/impl/Filter.h
+++ b/libraries/controllers/src/controllers/impl/Filter.h
@ -35,6 +35,8 @@ namespace controller {
        using Lambda = std::function<float(float)>;
        using Factory = hifi::SimpleFactory<Filter, QString>;

+        virtual ~Filter() = default;
+
        virtual float apply(float value) const = 0;
        virtual Pose apply(Pose value) const = 0;

--- a/libraries/controllers/src/controllers/impl/conditionals/AndConditional.h
+++ b/libraries/controllers/src/controllers/impl/conditionals/AndConditional.h
@ -24,8 +24,6 @@ public:
    AndConditional(Conditional::Pointer& first, Conditional::Pointer& second)
        : _children({ first, second }) {}

-    virtual ~AndConditional() {}
-
    virtual bool satisfied() override;

 private:
--- a/libraries/controllers/src/controllers/impl/conditionals/EndpointConditional.h
+++ b/libraries/controllers/src/controllers/impl/conditionals/EndpointConditional.h
@ -18,7 +18,6 @@ namespace controller {
 class EndpointConditional : public Conditional {
 public:
    EndpointConditional(Endpoint::Pointer endpoint) : _endpoint(endpoint) {}
-    virtual ~EndpointConditional() {}
    virtual bool satisfied() override { return _endpoint && _endpoint->peek() != 0.0f; }
 private:
    Endpoint::Pointer _endpoint;
--- a/libraries/controllers/src/controllers/impl/conditionals/NotConditional.h
+++ b/libraries/controllers/src/controllers/impl/conditionals/NotConditional.h
@ -19,7 +19,6 @@ namespace controller {
        using Pointer = std::shared_ptr<NotConditional>;

        NotConditional(Conditional::Pointer operand) : _operand(operand) { }
-        virtual ~NotConditional() {}

        virtual bool satisfied() override;

--- a/libraries/controllers/src/controllers/impl/filters/ClampFilter.h
+++ b/libraries/controllers/src/controllers/impl/filters/ClampFilter.h
@ -18,7 +18,6 @@ class ClampFilter : public Filter {
    REGISTER_FILTER_CLASS(ClampFilter);
 public:
    ClampFilter(float min = 0.0, float max = 1.0) : _min(min), _max(max) {};
-    virtual ~ClampFilter() {}
    virtual float apply(float value) const override {
        return glm::clamp(value, _min, _max);
    }
--- a/Show more
+++ b/Show more