Merge remote-tracking branch 'origin/master' into android_avatar_name

2025-04-23 15:53:35 +02:00 · 2018-05-11 18:48:34 -03:00 · 2018-05-11 18:48:34 -03:00 · e3d7d65186
commit e3d7d65186
parent cd3836883b 4f7ce7345d
155 changed files with 2087 additions and 631 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -180,6 +180,7 @@ add_subdirectory(tools)

 if (BUILD_TESTS)
  add_subdirectory(tests)
+  add_subdirectory(tests-manual)
 endif()

 if (BUILD_INSTALLER)
--- a/cmake/macros/SetupHifiTestCase.cmake
+++ b/cmake/macros/SetupHifiTestCase.cmake
@ -124,15 +124,14 @@ macro(SETUP_HIFI_TESTCASE)
      # This target will also build + run the other test targets using ctest when built.

      add_custom_target(${TEST_TARGET}
-        COMMAND ctest .
        SOURCES ${TEST_PROJ_SRC_FILES}    # display source files under the testcase target
        DEPENDS ${${TEST_PROJ_NAME}_TARGETS})
+
      set_target_properties(${TEST_TARGET} PROPERTIES
+        FOLDER "Tests"
        EXCLUDE_FROM_DEFAULT_BUILD TRUE
        EXCLUDE_FROM_ALL TRUE)

-      set_target_properties(${TEST_TARGET} PROPERTIES FOLDER "Tests")
-
      list (APPEND ALL_TEST_TARGETS ${TEST_TARGET})
      set(ALL_TEST_TARGETS "${ALL_TEST_TARGETS}" PARENT_SCOPE)
    else ()
--- a/interface/resources/qml/LoginDialog/SignInBody.qml
+++ b/interface/resources/qml/LoginDialog/SignInBody.qml
@ -84,11 +84,9 @@ Item {
            height: undefined // invalidate so that the image's size sets the height
            focus: true

-            style: OriginalStyles.ButtonStyle {
-                background: Image {
-                    id: buttonImage
-                    source: "../../images/steam-sign-in.png"
-                }
+            background: Image {
+                id: buttonImage
+                source: "../../images/steam-sign-in.png"
            }
            onClicked: signInBody.login()
        }
--- a/interface/resources/qml/dialogs/assetDialog/AssetDialogContent.qml
+++ b/interface/resources/qml/dialogs/assetDialog/AssetDialogContent.qml
@ -20,15 +20,10 @@ import "../fileDialog"
 Item {
    // Set from OffscreenUi::assetDialog()
    property alias dir: assetTableModel.folder
-    property alias filter: selectionType.filtersString  // FIXME: Currently only supports simple filters, "*.xxx".
-    property int options  // Not used.
+    property alias filter: selectionType.filtersString
+    property int options

    property bool selectDirectory: false
-
-    // Not implemented.
-    //property bool saveDialog: false;
-    //property bool multiSelect: false;
-
    property bool singleClickNavigate: false

    HifiConstants { id: hifi }
@ -85,7 +80,6 @@ Item {
                size: 28
                width: height
                enabled: destination !== ""
-                //onClicked: d.navigateHome();
                onClicked: assetTableModel.folder = destination;
            }
        }
@ -228,7 +222,9 @@ Item {

            function onGetAllMappings(error, map) {
                var mappings,
-                    fileTypeFilter,
+                    fileTypeFilters = [],
+                    filterListStart,
+                    filterListEnd,
                    index,
                    path,
                    fileName,
@ -249,7 +245,16 @@ Item {

                if (error === "") {
                    mappings = Object.keys(map);
-                    fileTypeFilter = filter.replace("*", "").toLowerCase();
+                    filter = filter.replace(/\s/g, '');
+                    filterListStart = filter.indexOf("(");
+                    filterListEnd = filter.indexOf(")");
+                    if (filterListStart !== -1 && filterListEnd !== -1) {
+                        var FIRST_EXTENSION_OFFSET = 2;
+                        fileTypeFilters = filter.substring(filterListStart + FIRST_EXTENSION_OFFSET
+                            , filterListEnd).toLowerCase().split("*");
+                    } else if (filter !== "") {
+                        fileTypeFilters[0] = filter.replace("*", "").toLowerCase();
+                    }

                    for (i = 0, length = mappings.length; i < length; i++) {
                        index = mappings[i].lastIndexOf("/");
@ -260,7 +265,24 @@ Item {
                        fileIsDir = false;
                        isValid = false;

-                        if (fileType.toLowerCase() === fileTypeFilter) {
+                        if (fileTypeFilters.length > 1) {
+                            if (fileTypeFilters.indexOf(fileType.toLowerCase()) !== -1) {
+                                if (path === folder) {
+                                    isValid = !selectDirectory;
+                                } else if (path.length > folder.length) {
+                                    subDirectory = path.slice(folder.length);
+                                    index = subDirectory.indexOf("/");
+                                    if (index === subDirectory.lastIndexOf("/")) {
+                                        fileName = subDirectory.slice(0, index);
+                                        if (subDirectories.indexOf(fileName) === -1) {
+                                            fileIsDir = true;
+                                            isValid = true;
+                                            subDirectories.push(fileName);
+                                        }
+                                    }
+                                }
+                            }
+                        } else if (fileType.toLowerCase() === fileTypeFilters[0] || fileTypeFilters.length === 0) {
                            if (path === folder) {
                                isValid = !selectDirectory;
                            } else if (path.length > folder.length) {
--- a/interface/resources/qml/hifi/commerce/checkout/Checkout.qml
+++ b/interface/resources/qml/hifi/commerce/checkout/Checkout.qml
@ -787,7 +787,7 @@ Rectangle {
                    }
                    lightboxPopup.button2text = "CONFIRM";
                    lightboxPopup.button2method = function() {
-                        Commerce.replaceContentSet(root.itemHref);
+                        Commerce.replaceContentSet(root.itemHref, root.certificateId);
                        lightboxPopup.visible = false;
                        rezzedNotifContainer.visible = true;
                        rezzedNotifContainerTimer.start();
--- a/interface/resources/shaders/splashSkybox.frag
+++ b/interface/resources/shaders/splashSkybox.frag
@ -0,0 +1,47 @@
+const vec3 COLOR = vec3(0x00, 0xD8, 0x02) / vec3(0xFF);
+const float CUTOFF = 0.65;
+const float NOISE_MULT = 8.0;
+const float NOISE_POWER = 1.0;
+
+float noise4D(vec4 p) {
+	return fract(sin(dot(p ,vec4(12.9898,78.233,126.7235, 593.2241))) * 43758.5453);
+}
+
+float worley4D(vec4 p) {
+	float r = 3.0;
+    vec4 f = floor(p);
+    vec4 x = fract(p);
+	for(int i = -1; i<=1; i++)
+	{
+		for(int j = -1; j<=1; j++)
+		{
+			for(int k = -1; k<=1; k++)
+			{
+                for (int l = -1; l <= 1; l++) {
+                	vec4 q = vec4(float(i),float(j),float(k), float(l));
+    				vec4 v = q + vec4(noise4D((q+f)*1.11), noise4D((q+f)*1.14), noise4D((q+f)*1.17), noise4D((q+f)*1.20)) - x;
+    				float d = dot(v, v);
+					r = min(r, d);
+                }
+			}
+		}
+	}
+    return sqrt(r);
+}
+
+
+vec3 mainColor(vec3 direction) {
+    float n = worley4D(vec4(direction * NOISE_MULT, iGlobalTime / 3.0));
+    n = 1.0 - n;
+    n = pow(n, NOISE_POWER);
+    if (n < CUTOFF) {
+        return vec3(0.0);
+    }
+
+    n = (n - CUTOFF) / (1.0 - CUTOFF);
+	return COLOR * (1.0 - n);
+}
+
+vec3 getSkyboxColor() {
+	return mainColor(normalize(_normal));
+}
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -144,16 +144,7 @@
 #include <trackers/EyeTracker.h>
 #include <avatars-renderer/ScriptAvatar.h>
 #include <RenderableEntityItem.h>
-
-#include <AnimationLogging.h>
-#include <AvatarLogging.h>
-#include <ScriptEngineLogging.h>
-#include <ModelFormatLogging.h>
-#include <controllers/Logging.h>
-#include <NetworkLogging.h>
-#include <shared/StorageLogging.h>
-#include <ScriptEngineLogging.h>
-#include <ui/Logging.h>
+#include <procedural/ProceduralSkybox.h>

 #include "AudioClient.h"
 #include "audio/AudioScope.h"
@ -385,7 +376,7 @@ Setting::Handle<int> maxOctreePacketsPerSecond("maxOctreePPS", DEFAULT_MAX_OCTRE
 static const QString MARKETPLACE_CDN_HOSTNAME = "mpassets.highfidelity.com";
 static const int INTERVAL_TO_CHECK_HMD_WORN_STATUS = 500; // milliseconds
 static const QString DESKTOP_DISPLAY_PLUGIN_NAME = "Desktop";
-
+static const QString ACTIVE_DISPLAY_PLUGIN_SETTING_NAME = "activeDisplayPlugin";
 static const QString SYSTEM_TABLET = "com.highfidelity.interface.tablet.system";

 const std::vector<std::pair<QString, Application::AcceptURLMethod>> Application::_acceptedExtensions {
@ -743,6 +734,11 @@ extern DisplayPluginList getDisplayPlugins();
 extern InputPluginList getInputPlugins();
 extern void saveInputPluginSettings(const InputPluginList& plugins);

+// Parameters used for running tests from teh command line
+const QString TEST_SCRIPT_COMMAND { "--testScript" };
+const QString TEST_QUIT_WHEN_FINISHED_OPTION { "quitWhenFinished" };
+const QString TEST_SNAPSHOT_LOCATION_COMMAND { "--testSnapshotLocation" };
+
 bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {
    const char** constArgv = const_cast<const char**>(argv);

@ -777,7 +773,22 @@ bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {

    static const auto SUPPRESS_SETTINGS_RESET = "--suppress-settings-reset";
    bool suppressPrompt = cmdOptionExists(argc, const_cast<const char**>(argv), SUPPRESS_SETTINGS_RESET);
-    bool previousSessionCrashed = CrashHandler::checkForResetSettings(runningMarkerExisted, suppressPrompt);
+
+    // Ignore any previous crashes if running from command line with a test script.  
+    bool inTestMode { false };
+    for (int i = 0; i < argc; ++i) {
+        QString parameter(argv[i]);
+        if (parameter == TEST_SCRIPT_COMMAND) {
+            inTestMode = true;
+            break;
+        }
+    }
+
+    bool previousSessionCrashed { false };
+    if (!inTestMode) {
+        previousSessionCrashed = CrashHandler::checkForResetSettings(runningMarkerExisted, suppressPrompt);
+    }
+
    // get dir to use for cache
    static const auto CACHE_SWITCH = "--cache";
    QString cacheDir = getCmdOption(argc, const_cast<const char**>(argv), CACHE_SWITCH);
@ -996,13 +1007,30 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
    setProperty(hifi::properties::STEAM, (steamClient && steamClient->isRunning()));
    setProperty(hifi::properties::CRASHED, _previousSessionCrashed);
    {
-        const QString TEST_SCRIPT = "--testScript";
        const QStringList args = arguments();
+
        for (int i = 0; i < args.size() - 1; ++i) {
-            if (args.at(i) == TEST_SCRIPT) {
+            if (args.at(i) == TEST_SCRIPT_COMMAND && (i + 1) < args.size()) {
                QString testScriptPath = args.at(i + 1);
-                if (QFileInfo(testScriptPath).exists()) {
+
+                // If the URL scheme is http(s) or ftp, then use as is, else - treat it as a local file
+                // This is done so as not break previous command line scripts
+                if (testScriptPath.left(URL_SCHEME_HTTP.length()) == URL_SCHEME_HTTP || testScriptPath.left(URL_SCHEME_FTP.length()) == URL_SCHEME_FTP) {
+                    setProperty(hifi::properties::TEST, QUrl::fromUserInput(testScriptPath));
+                } else if (QFileInfo(testScriptPath).exists()) {
                    setProperty(hifi::properties::TEST, QUrl::fromLocalFile(testScriptPath));
+                }
+
+				// quite when finished parameter must directly follow the test script
+                if ((i + 2) < args.size() && args.at(i + 2) == TEST_QUIT_WHEN_FINISHED_OPTION) {
+                    quitWhenFinished = true;
+                }
+            } else if (args.at(i) == TEST_SNAPSHOT_LOCATION_COMMAND) {
+                // Set test snapshot location only if it is a writeable directory
+                QString pathname(args.at(i + 1));
+                QFileInfo fileInfo(pathname);
+                if (fileInfo.isDir() && fileInfo.isWritable()) {
+                    testSnapshotLocation = pathname;
                }
            }
        }
@ -1322,10 +1350,14 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
    QCoreApplication::processEvents();
    _glWidget->createContext();

-    // Create the main thread context, the GPU backend, and the display plugins
+    // Create the main thread context, the GPU backend
    initializeGL();
-    DependencyManager::get<TextureCache>()->setGPUContext(_gpuContext);
-    qCDebug(interfaceapp, "Initialized Display.");
+    qCDebug(interfaceapp, "Initialized GL");
+
+    // Initialize the display plugin architecture 
+    initializeDisplayPlugins();
+    qCDebug(interfaceapp, "Initialized Display");
+
    // Create the rendering engine.  This can be slow on some machines due to lots of 
    // GPU pipeline creation.
    initializeRenderEngine();
@ -1335,8 +1367,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
    // Needs to happen AFTER the render engine initialization to access its configuration
    initializeUi();

-    updateVerboseLogging();
-
    init();
    qCDebug(interfaceapp, "init() complete.");

@ -1676,6 +1706,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo

    loadSettings();

+    updateVerboseLogging();
+
    // Now that we've loaded the menu and thus switched to the previous display plugin
    // we can unlock the desktop repositioning code, since all the positions will be
    // relative to the desktop size for this plugin
@ -2128,14 +2160,24 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
        return entityServerNode && !isPhysicsEnabled();
    });

-    _snapshotSound = DependencyManager::get<SoundCache>()->getSound(PathUtils::resourcesUrl("sounds/snap.wav"));
+    _snapshotSound = DependencyManager::get<SoundCache>()->getSound(PathUtils::resourcesUrl("sounds/snapshot/snap.wav"));

    QVariant testProperty = property(hifi::properties::TEST);
    qDebug() << testProperty;
    if (testProperty.isValid()) {
        auto scriptEngines = DependencyManager::get<ScriptEngines>();
        const auto testScript = property(hifi::properties::TEST).toUrl();
-        scriptEngines->loadScript(testScript, false);
+       
+        // Set last parameter to exit interface when the test script finishes, if so requested
+        scriptEngines->loadScript(testScript, false, false, false, false, quitWhenFinished);
+
+        // This is done so we don't get a "connection time-out" message when we haven't passed in a URL.
+        if (arguments().contains("--url")) {
+            auto reply = SandboxUtils::getStatus();
+            connect(reply, &QNetworkReply::finished, this, [=] {
+                handleSandboxStatus(reply);
+            });
+        }
    } else {
        PROFILE_RANGE(render, "GetSandboxStatus");
        auto reply = SandboxUtils::getStatus();
@ -2210,43 +2252,19 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
 }

 void Application::updateVerboseLogging() {
-    bool enable = Menu::getInstance()->isOptionChecked(MenuOption::VerboseLogging);
+    auto menu = Menu::getInstance();
+    if (!menu) {
+        return;
+    }
+    bool enable = menu->isOptionChecked(MenuOption::VerboseLogging);

-    const_cast<QLoggingCategory*>(&animation())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&animation())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&avatars())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&avatars())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&scriptengine())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&scriptengine())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&modelformat())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&modelformat())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&controllers())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&controllers())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&resourceLog())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&resourceLog())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&networking())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&networking())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&asset_client())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&asset_client())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&messages_client())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&messages_client())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&storagelogging())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&storagelogging())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&uiLogging())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&uiLogging())->setEnabled(QtInfoMsg, enable);
-
-    const_cast<QLoggingCategory*>(&glLogging())->setEnabled(QtDebugMsg, enable);
-    const_cast<QLoggingCategory*>(&glLogging())->setEnabled(QtInfoMsg, enable);
+    QString rules =
+        "hifi.*.debug=%1\n"
+        "hifi.*.info=%1\n"
+        "hifi.audio-stream.debug=false\n"
+        "hifi.audio-stream.info=false";
+    rules = rules.arg(enable ? "true" : "false");
+    QLoggingCategory::setFilterRules(rules);
 }

 void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCodeInt, const QString& extraInfo) {
@ -2359,6 +2377,10 @@ void Application::onAboutToQuit() {
        }
    }

+    // The active display plugin needs to be loaded before the menu system is active, 
+    // so its persisted explicitly here
+    Setting::Handle<QString>{ ACTIVE_DISPLAY_PLUGIN_SETTING_NAME }.set(getActiveDisplayPlugin()->getName());
+
    getActiveDisplayPlugin()->deactivate();
    if (_autoSwitchDisplayModeSupportedHMDPlugin
        && _autoSwitchDisplayModeSupportedHMDPlugin->isSessionActive()) {
@ -2598,10 +2620,84 @@ void Application::initializeGL() {
    _glWidget->makeCurrent();
    _gpuContext = std::make_shared<gpu::Context>();

+    DependencyManager::get<TextureCache>()->setGPUContext(_gpuContext);
+
    // Restore the default main thread context
    _offscreenContext->makeCurrent();
+}

-    updateDisplayMode();
+static const QString SPLASH_SKYBOX{ "{\"ProceduralEntity\":{ \"version\":2, \"shaderUrl\":\"qrc:///shaders/splashSkybox.frag\" } }" };
+
+void Application::initializeDisplayPlugins() {
+    auto displayPlugins = PluginManager::getInstance()->getDisplayPlugins();
+    Setting::Handle<QString> activeDisplayPluginSetting{ ACTIVE_DISPLAY_PLUGIN_SETTING_NAME, displayPlugins.at(0)->getName() };
+    auto lastActiveDisplayPluginName = activeDisplayPluginSetting.get();
+
+    auto defaultDisplayPlugin = displayPlugins.at(0);
+    // Once time initialization code 
+    DisplayPluginPointer targetDisplayPlugin;
+    foreach(auto displayPlugin, displayPlugins) {
+        displayPlugin->setContext(_gpuContext);
+        if (displayPlugin->getName() == lastActiveDisplayPluginName) {
+            targetDisplayPlugin = displayPlugin;
+        }
+        QObject::connect(displayPlugin.get(), &DisplayPlugin::recommendedFramebufferSizeChanged,
+            [this](const QSize& size) { resizeGL(); });
+        QObject::connect(displayPlugin.get(), &DisplayPlugin::resetSensorsRequested, this, &Application::requestReset);
+    }
+
+    // The default display plugin needs to be activated first, otherwise the display plugin thread
+    // may be launched by an external plugin, which is bad 
+    setDisplayPlugin(defaultDisplayPlugin);
+
+    // Now set the desired plugin if it's not the same as the default plugin
+    if (targetDisplayPlugin != defaultDisplayPlugin) {
+        setDisplayPlugin(targetDisplayPlugin);
+    }
+
+    // Submit a default frame to render until the engine starts up
+    updateRenderArgs(0.0f);
+
+    _offscreenContext->makeCurrent();
+
+#define ENABLE_SPLASH_FRAME 0
+#if ENABLE_SPLASH_FRAME
+    {
+        QMutexLocker viewLocker(&_renderArgsMutex);
+
+        if (_appRenderArgs._isStereo) {
+            _gpuContext->enableStereo(true);
+            _gpuContext->setStereoProjections(_appRenderArgs._eyeProjections);
+            _gpuContext->setStereoViews(_appRenderArgs._eyeOffsets);
+        }
+
+        // Frame resources
+        auto framebufferCache = DependencyManager::get<FramebufferCache>();
+        gpu::FramebufferPointer finalFramebuffer = framebufferCache->getFramebuffer();
+        std::shared_ptr<ProceduralSkybox> procedural = std::make_shared<ProceduralSkybox>();
+        procedural->parse(SPLASH_SKYBOX);
+
+        _gpuContext->beginFrame(_appRenderArgs._view, _appRenderArgs._headPose);
+        gpu::doInBatch("splashFrame", _gpuContext, [&](gpu::Batch& batch) {
+            batch.resetStages();
+            batch.enableStereo(false);
+            batch.setFramebuffer(finalFramebuffer);
+            batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, { 0, 0, 0, 1 });
+            batch.enableSkybox(true);
+            batch.enableStereo(_appRenderArgs._isStereo);
+            batch.setViewportTransform({ 0, 0, finalFramebuffer->getSize() });
+            procedural->render(batch, _appRenderArgs._renderArgs.getViewFrustum());
+        });
+        auto frame = _gpuContext->endFrame();
+        frame->frameIndex = 0;
+        frame->framebuffer = finalFramebuffer;
+        frame->pose = _appRenderArgs._headPose;
+        frame->framebufferRecycler = [framebufferCache, procedural](const gpu::FramebufferPointer& framebuffer) {
+            framebufferCache->releaseFramebuffer(framebuffer);
+        };
+        _displayPlugin->submitFrame(frame);
+    }
+#endif
 }

 void Application::initializeRenderEngine() {
@ -2625,6 +2721,7 @@ void Application::initializeRenderEngine() {
 }

 extern void setupPreferences();
+static void addDisplayPluginToMenu(const DisplayPluginPointer& displayPlugin, bool active);

 void Application::initializeUi() {
    // Build a shared canvas / context for the Chromium processes
@ -2766,10 +2863,25 @@ void Application::initializeUi() {
    offscreenSurfaceCache->reserve(TabletScriptingInterface::QML, 1);
    offscreenSurfaceCache->reserve(Web3DOverlay::QML, 2);

-    // Now that the menu is instantiated, ensure the display plugin menu is properly updated
-    updateDisplayMode();
    flushMenuUpdates();

+    // Now that the menu is instantiated, ensure the display plugin menu is properly updated
+    {
+        auto displayPlugins = PluginManager::getInstance()->getDisplayPlugins();
+        // first sort the plugins into groupings: standard, advanced, developer
+        std::stable_sort(displayPlugins.begin(), displayPlugins.end(),
+            [](const DisplayPluginPointer& a, const DisplayPluginPointer& b)->bool { return a->getGrouping() < b->getGrouping(); });
+
+        // concatenate the groupings into a single list in the order: standard, advanced, developer
+        for(const auto& displayPlugin : displayPlugins) {
+            addDisplayPluginToMenu(displayPlugin, _displayPlugin == displayPlugin);
+        }
+
+        // after all plugins have been added to the menu, add a separator to the menu
+        auto parent = getPrimaryMenu()->getMenu(MenuOption::OutputMenu);
+        parent->addSeparator();
+    }
+
    // The display plugins are created before the menu now, so we need to do this here to hide the menu bar
    // now that it exists
    if (_window && _window->isFullScreen()) {
@ -2920,7 +3032,7 @@ void Application::updateCamera(RenderArgs& renderArgs, float deltaTime) {
            _thirdPersonHMDCameraBoomValid = false;

            _myCamera.setOrientation(myAvatar->getHead()->getOrientation());
-            if (Menu::getInstance()->isOptionChecked(MenuOption::CenterPlayerInView)) {
+            if (isOptionChecked(MenuOption::CenterPlayerInView)) {
                _myCamera.setPosition(myAvatar->getDefaultEyePosition()
                    + _myCamera.getOrientation() * boomOffset);
            }
@ -3175,7 +3287,6 @@ void Application::handleSandboxStatus(QNetworkReply* reply) {
        qCDebug(interfaceapp) << "First run... going to" << qPrintable(addressLookupString.isEmpty() ? QString("default location") : addressLookupString);
        DependencyManager::get<AddressManager>()->loadSettings(addressLookupString);
 #else
-        showHelp();
        DependencyManager::get<AddressManager>()->goToEntry();
        sentTo = SENT_TO_ENTRY;
 #endif
@ -5723,6 +5834,32 @@ void Application::update(float deltaTime) {
    }


+    updateRenderArgs(deltaTime);
+
+    // HACK
+    // load the view frustum
+    // FIXME: This preDisplayRender call is temporary until we create a separate render::scene for the mirror rendering.
+    // Then we can move this logic into the Avatar::simulate call.
+    myAvatar->preDisplaySide(&_appRenderArgs._renderArgs);
+
+
+    {
+        PerformanceTimer perfTimer("limitless");
+        AnimDebugDraw::getInstance().update();
+    }
+
+    {
+        PerformanceTimer perfTimer("limitless");
+        DependencyManager::get<LimitlessVoiceRecognitionScriptingInterface>()->update();
+    }
+
+    { // Game loop is done, mark the end of the frame for the scene transactions and the render loop to take over
+        PerformanceTimer perfTimer("enqueueFrame");
+        getMain3DScene()->enqueueFrame();
+    }
+}
+
+void Application::updateRenderArgs(float deltaTime) {
    editRenderArgs([this, deltaTime](AppRenderArgs& appRenderArgs) {
        PerformanceTimer perfTimer("editRenderArgs");
        appRenderArgs._headPose = getHMDSensorPose();
@ -5746,9 +5883,9 @@ void Application::update(float deltaTime) {
                QMutexLocker viewLocker(&_viewMutex);
                // adjust near clip plane to account for sensor scaling.
                auto adjustedProjection = glm::perspective(glm::radians(_fieldOfView.get()),
-                                                           getActiveDisplayPlugin()->getRecommendedAspectRatio(),
-                                                           DEFAULT_NEAR_CLIP * sensorToWorldScale,
-                                                           DEFAULT_FAR_CLIP);
+                    getActiveDisplayPlugin()->getRecommendedAspectRatio(),
+                    DEFAULT_NEAR_CLIP * sensorToWorldScale,
+                    DEFAULT_FAR_CLIP);
                _viewFrustum.setProjection(adjustedProjection);
                _viewFrustum.calculate();
            }
@ -5764,8 +5901,14 @@ void Application::update(float deltaTime) {
        }
        {
            PROFILE_RANGE(render, "/resizeGL");
-            PerformanceWarning::setSuppressShortTimings(Menu::getInstance()->isOptionChecked(MenuOption::SuppressShortTimings));
-            bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
+            bool showWarnings = false;
+            bool suppressShortTimings = false;
+            auto menu = Menu::getInstance();
+            if (menu) {
+                suppressShortTimings = menu->isOptionChecked(MenuOption::SuppressShortTimings);
+                showWarnings = menu->isOptionChecked(MenuOption::PipelineWarnings);
+            }
+            PerformanceWarning::setSuppressShortTimings(suppressShortTimings);
            PerformanceWarning warn(showWarnings, "Application::paintGL()");
            resizeGL();
        }
@ -5821,12 +5964,6 @@ void Application::update(float deltaTime) {
            }
        }

-        // HACK
-        // load the view frustum
-        // FIXME: This preDisplayRender call is temporary until we create a separate render::scene for the mirror rendering.
-        // Then we can move this logic into the Avatar::simulate call.
-        myAvatar->preDisplaySide(&appRenderArgs._renderArgs);
-
        {
            QMutexLocker viewLocker(&_viewMutex);
            _myCamera.loadViewFrustum(_displayViewFrustum);
@ -5838,21 +5975,6 @@ void Application::update(float deltaTime) {
            appRenderArgs._renderArgs.setViewFrustum(_displayViewFrustum);
        }
    });
-
-    {
-        PerformanceTimer perfTimer("limitless");
-        AnimDebugDraw::getInstance().update();
-    }
-
-    {
-        PerformanceTimer perfTimer("limitless");
-        DependencyManager::get<LimitlessVoiceRecognitionScriptingInterface>()->update();
-    }
-
-    { // Game loop is done, mark the end of the frame for the scene transactions and the render loop to take over
-        PerformanceTimer perfTimer("enqueueFrame");
-        getMain3DScene()->enqueueFrame();
-    }
 }

 void Application::queryAvatars() {
@ -7466,7 +7588,7 @@ void Application::loadAvatarBrowser() const {
 void Application::takeSnapshot(bool notify, bool includeAnimated, float aspectRatio, const QString& filename) {
    postLambdaEvent([notify, includeAnimated, aspectRatio, filename, this] {
        // Get a screenshot and save it
-        QString path = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getScreenshot(aspectRatio), filename);
+        QString path = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getScreenshot(aspectRatio), filename, testSnapshotLocation);
        // If we're not doing an animated snapshot as well...
        if (!includeAnimated) {
            // Tell the dependency manager that the capture of the still snapshot has taken place.
@ -7480,7 +7602,7 @@ void Application::takeSnapshot(bool notify, bool includeAnimated, float aspectRa

 void Application::takeSecondaryCameraSnapshot(const QString& filename) {
    postLambdaEvent([filename, this] {
-        QString snapshotPath = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getSecondaryCameraScreenshot(), filename);
+        QString snapshotPath = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getSecondaryCameraScreenshot(), filename, testSnapshotLocation);
        emit DependencyManager::get<WindowScriptingInterface>()->stillSnapshotTaken(snapshotPath, true);
    });
 }
@ -7493,15 +7615,19 @@ void Application::shareSnapshot(const QString& path, const QUrl& href) {
 }

 float Application::getRenderResolutionScale() const {
-    if (Menu::getInstance()->isOptionChecked(MenuOption::RenderResolutionOne)) {
+    auto menu = Menu::getInstance();
+    if (!menu) {
        return 1.0f;
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::RenderResolutionTwoThird)) {
+    }
+    if (menu->isOptionChecked(MenuOption::RenderResolutionOne)) {
+        return 1.0f;
+    } else if (menu->isOptionChecked(MenuOption::RenderResolutionTwoThird)) {
        return 0.666f;
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::RenderResolutionHalf)) {
+    } else if (menu->isOptionChecked(MenuOption::RenderResolutionHalf)) {
        return 0.5f;
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::RenderResolutionThird)) {
+    } else if (menu->isOptionChecked(MenuOption::RenderResolutionThird)) {
        return 0.333f;
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::RenderResolutionQuarter)) {
+    } else if (menu->isOptionChecked(MenuOption::RenderResolutionQuarter)) {
        return 0.25f;
    } else {
        return 1.0f;
@ -7725,7 +7851,7 @@ DisplayPluginPointer Application::getActiveDisplayPlugin() const {

 static const char* EXCLUSION_GROUP_KEY = "exclusionGroup";

-static void addDisplayPluginToMenu(DisplayPluginPointer displayPlugin, bool active = false) {
+static void addDisplayPluginToMenu(const DisplayPluginPointer& displayPlugin, bool active) {
    auto menu = Menu::getInstance();
    QString name = displayPlugin->getName();
    auto grouping = displayPlugin->getGrouping();
@ -7770,65 +7896,12 @@ void Application::updateDisplayMode() {
        qFatal("Attempted to switch display plugins from a non-main thread");
    }

-    auto displayPlugins = PluginManager::getInstance()->getDisplayPlugins();
-
-    // Once time initialization code 
-    static std::once_flag once;
-    std::call_once(once, [&] {
-        foreach(auto displayPlugin, displayPlugins) {
-            displayPlugin->setContext(_gpuContext);
-            QObject::connect(displayPlugin.get(), &DisplayPlugin::recommendedFramebufferSizeChanged,
-                [this](const QSize& size) { resizeGL(); });
-            QObject::connect(displayPlugin.get(), &DisplayPlugin::resetSensorsRequested, this, &Application::requestReset);
-        }
-    });
-
    // Once time initialization code that depends on the UI being available
-    auto menu = Menu::getInstance();
-    if (menu) {
-        static std::once_flag onceUi;
-        std::call_once(onceUi, [&] {
-            bool first = true;
-
-            // first sort the plugins into groupings: standard, advanced, developer
-            DisplayPluginList standard;
-            DisplayPluginList advanced;
-            DisplayPluginList developer;
-            foreach(auto displayPlugin, displayPlugins) {
-                displayPlugin->setContext(_gpuContext);
-                auto grouping = displayPlugin->getGrouping();
-                switch (grouping) {
-                case Plugin::ADVANCED:
-                    advanced.push_back(displayPlugin);
-                    break;
-                case Plugin::DEVELOPER:
-                    developer.push_back(displayPlugin);
-                    break;
-                default:
-                    standard.push_back(displayPlugin);
-                    break;
-                }
-            }
-
-            // concatenate the groupings into a single list in the order: standard, advanced, developer
-            standard.insert(std::end(standard), std::begin(advanced), std::end(advanced));
-            standard.insert(std::end(standard), std::begin(developer), std::end(developer));
-
-            foreach(auto displayPlugin, standard) {
-                addDisplayPluginToMenu(displayPlugin, first);
-                first = false;
-            }
-
-            // after all plugins have been added to the menu, add a separator to the menu
-            auto parent = menu->getMenu(MenuOption::OutputMenu);
-            parent->addSeparator();
-        });
-
-    }
-
+    auto displayPlugins = getDisplayPlugins();

    // Default to the first item on the list, in case none of the menu items match
    DisplayPluginPointer newDisplayPlugin = displayPlugins.at(0);
+    auto menu = getPrimaryMenu();
    if (menu) {
        foreach(DisplayPluginPointer displayPlugin, PluginManager::getInstance()->getDisplayPlugins()) {
            QString name = displayPlugin->getName();
@ -7852,6 +7925,14 @@ void Application::updateDisplayMode() {
 }

 void Application::setDisplayPlugin(DisplayPluginPointer newDisplayPlugin) {
+    if (newDisplayPlugin == _displayPlugin) {
+        return;
+    }
+
+    // FIXME don't have the application directly set the state of the UI,
+    // instead emit a signal that the display plugin is changing and let 
+    // the desktop lock itself.  Reduces coupling between the UI and display
+    // plugins
    auto offscreenUi = DependencyManager::get<OffscreenUi>();
    auto desktop = offscreenUi->getDesktop();
    auto menu = Menu::getInstance();
@ -7862,8 +7943,8 @@ void Application::setDisplayPlugin(DisplayPluginPointer newDisplayPlugin) {
        bool wasRepositionLocked = false;
        if (desktop) {
            // Tell the desktop to no reposition (which requires plugin info), until we have set the new plugin, below.
-            wasRepositionLocked = offscreenUi->getDesktop()->property("repositionLocked").toBool();
-            offscreenUi->getDesktop()->setProperty("repositionLocked", true);
+            wasRepositionLocked = desktop->property("repositionLocked").toBool();
+            desktop->setProperty("repositionLocked", true);
        }

        if (_displayPlugin) {
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@ -148,6 +148,7 @@ public:
    Q_INVOKABLE QString getUserAgent();

    void initializeGL();
+    void initializeDisplayPlugins();
    void initializeRenderEngine();
    void initializeUi();

@ -671,6 +672,7 @@ private:

    using RenderArgsEditor = std::function <void (AppRenderArgs&)>;
    void editRenderArgs(RenderArgsEditor editor);
+    void updateRenderArgs(float deltaTime);


    Overlays _overlays;
@ -750,5 +752,8 @@ private:

    std::atomic<bool> _pendingIdleEvent { true };
    std::atomic<bool> _pendingRenderEvent { true };
+
+    QString testSnapshotLocation;
+    bool quitWhenFinished { false };
 };
 #endif // hifi_Application_h
--- a/interface/src/Application_render.cpp
+++ b/interface/src/Application_render.cpp
@ -13,8 +13,9 @@

 #include <display-plugins/CompositorHelper.h>
 #include <FramebufferCache.h>
-#include "ui/Stats.h"
+#include <plugins/PluginManager.h>
 #include <SceneScriptingInterface.h>
+#include "ui/Stats.h"
 #include "Util.h"


@ -233,3 +234,4 @@ void Application::runRenderFrame(RenderArgs* renderArgs) {
        _renderEngine->run();
    }
 }
+
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@ -2039,7 +2039,7 @@ void MyAvatar::postUpdate(float deltaTime, const render::ScenePointer& scene) {
    }
 }

-void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
+void MyAvatar::preDisplaySide(const RenderArgs* renderArgs) {

    // toggle using the cauterizedBones depending on where the camera is and the rendering pass type.
    const bool shouldDrawHead = shouldRenderHead(renderArgs);
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@ -272,7 +272,7 @@ public:

    void update(float deltaTime);
    virtual void postUpdate(float deltaTime, const render::ScenePointer& scene) override;
-    void preDisplaySide(RenderArgs* renderArgs);
+    void preDisplaySide(const RenderArgs* renderArgs);

    const glm::mat4& getHMDSensorMatrix() const { return _hmdSensorMatrix; }
    const glm::vec3& getHMDSensorPosition() const { return _hmdSensorPosition; }
--- a/interface/src/ui/Snapshot.cpp
+++ b/interface/src/ui/Snapshot.cpp
@ -74,9 +74,9 @@ SnapshotMetaData* Snapshot::parseSnapshotData(QString snapshotPath) {
    return data;
 }

-QString Snapshot::saveSnapshot(QImage image, const QString& filename) {
+QString Snapshot::saveSnapshot(QImage image, const QString& filename, const QString& pathname) {

-    QFile* snapshotFile = savedFileForSnapshot(image, false, filename);
+    QFile* snapshotFile = savedFileForSnapshot(image, false, filename, pathname);

    // we don't need the snapshot file, so close it, grab its filename and delete it
    snapshotFile->close();
@ -93,7 +93,7 @@ QTemporaryFile* Snapshot::saveTempSnapshot(QImage image) {
    return static_cast<QTemporaryFile*>(savedFileForSnapshot(image, true));
 }

-QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary, const QString& userSelectedFilename) {
+QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary, const QString& userSelectedFilename, const QString& userSelectedPathname) {

    // adding URL to snapshot
    QUrl currentURL = DependencyManager::get<AddressManager>()->currentPublicAddress();
@ -118,7 +118,13 @@ QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary, const QSt
    const int IMAGE_QUALITY = 100;

    if (!isTemporary) {
-        QString snapshotFullPath = snapshotsLocation.get();
+        // If user has requested specific path then use it, else use the application value
+        QString snapshotFullPath;
+        if (!userSelectedPathname.isNull()) {
+            snapshotFullPath = userSelectedPathname;
+        } else {
+            snapshotFullPath = snapshotsLocation.get();
+        }

        if (snapshotFullPath.isEmpty()) {
            snapshotFullPath = OffscreenUi::getExistingDirectory(nullptr, "Choose Snapshots Directory", QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
--- a/interface/src/ui/Snapshot.h
+++ b/interface/src/ui/Snapshot.h
@ -38,7 +38,7 @@ class Snapshot : public QObject, public Dependency {
    Q_OBJECT
    SINGLETON_DEPENDENCY
 public:
-    static QString saveSnapshot(QImage image, const QString& filename);
+    static QString saveSnapshot(QImage image, const QString& filename, const QString& pathname = QString());
    static QTemporaryFile* saveTempSnapshot(QImage image);
    static SnapshotMetaData* parseSnapshotData(QString snapshotPath);

@ -52,7 +52,10 @@ public slots:
    Q_INVOKABLE QString getSnapshotsLocation();
    Q_INVOKABLE void setSnapshotsLocation(const QString& location);
 private:
-    static QFile* savedFileForSnapshot(QImage & image, bool isTemporary, const QString& userSelectedFilename = QString());
+    static QFile* savedFileForSnapshot(QImage& image,
+                                       bool isTemporary,
+                                       const QString& userSelectedFilename = QString(),
+                                       const QString& userSelectedPathname = QString());
 };

 #endif // hifi_Snapshot_h
--- a/libraries/audio/src/AudioLogging.cpp
+++ b/libraries/audio/src/AudioLogging.cpp
@ -12,5 +12,4 @@
 #include "AudioLogging.h"

 Q_LOGGING_CATEGORY(audio, "hifi.audio")
-Q_LOGGING_CATEGORY(audiostream, "hifi.audio-stream", QtWarningMsg)
-
+Q_LOGGING_CATEGORY(audiostream, "hifi.audio-stream")
--- a/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/OpenGLDisplayPlugin.cpp
@ -336,9 +336,8 @@ void OpenGLDisplayPlugin::deactivate() {

    _container->showDisplayPluginsTools(false);
    if (!_container->currentDisplayActions().isEmpty()) {
-        auto menu = _container->getPrimaryMenu();
        foreach(auto itemInfo, _container->currentDisplayActions()) {
-            menu->removeMenuItem(itemInfo.first, itemInfo.second);
+            _container->removeMenuItem(itemInfo.first, itemInfo.second);
        }
        _container->currentDisplayActions().clear();
    }
--- a/libraries/entities/src/EntityEditPacketSender.cpp
+++ b/libraries/entities/src/EntityEditPacketSender.cpp
@ -77,7 +77,6 @@ void EntityEditPacketSender::queueEditAvatarEntityMessage(PacketType type,
    _myAvatar->updateAvatarEntity(entityItemID, binaryProperties);

    entity->setLastBroadcast(usecTimestampNow());
-    return;
 }


@ -85,10 +84,6 @@ void EntityEditPacketSender::queueEditEntityMessage(PacketType type,
                                                    EntityTreePointer entityTree,
                                                    EntityItemID entityItemID,
                                                    const EntityItemProperties& properties) {
-    if (!_shouldSend) {
-        return; // bail early
-    }
-
    if (properties.getClientOnly() && properties.getOwningAvatarID() == _myAvatar->getID()) {
        // this is an avatar-based entity --> update our avatar-data rather than sending to the entity-server
        queueEditAvatarEntityMessage(type, entityTree, entityItemID, properties);
@ -147,9 +142,6 @@ void EntityEditPacketSender::queueEditEntityMessage(PacketType type,
 }

 void EntityEditPacketSender::queueEraseEntityMessage(const EntityItemID& entityItemID) {
-    if (!_shouldSend) {
-        return; // bail early
-    }

    // in case this was a clientOnly entity:
    if(_myAvatar) {
--- a/libraries/entities/src/EntityItem.cpp
+++ b/libraries/entities/src/EntityItem.cpp
@ -1070,7 +1070,7 @@ bool EntityItem::stepKinematicMotion(float timeElapsed) {

    const float MAX_TIME_ELAPSED = 1.0f; // seconds
    if (timeElapsed > MAX_TIME_ELAPSED) {
-        qCWarning(entities) << "kinematic timestep = " << timeElapsed << " truncated to " << MAX_TIME_ELAPSED;
+        qCDebug(entities) << "kinematic timestep = " << timeElapsed << " truncated to " << MAX_TIME_ELAPSED;
    }
    timeElapsed = glm::min(timeElapsed, MAX_TIME_ELAPSED);

--- a/libraries/gl/src/gl/OffscreenGLCanvas.cpp
+++ b/libraries/gl/src/gl/OffscreenGLCanvas.cpp
@ -103,12 +103,15 @@ void OffscreenGLCanvas::onMessageLogged(const QOpenGLDebugMessage& debugMessage)

 bool OffscreenGLCanvas::makeCurrent() {
    bool result = _context->makeCurrent(_offscreenSurface);
-    std::call_once(_reportOnce, []{
-        qCDebug(glLogging) << "GL Version: " << QString((const char*) glGetString(GL_VERSION));
-        qCDebug(glLogging) << "GL Shader Language Version: " << QString((const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
-        qCDebug(glLogging) << "GL Vendor: " << QString((const char*) glGetString(GL_VENDOR));
-        qCDebug(glLogging) << "GL Renderer: " << QString((const char*) glGetString(GL_RENDERER));
-    });
+    if (glGetString) {
+        std::call_once(_reportOnce, [] {
+            qCDebug(glLogging) << "GL Version: " << QString((const char*)glGetString(GL_VERSION));
+            qCDebug(glLogging) << "GL Shader Language Version: "
+                               << QString((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
+            qCDebug(glLogging) << "GL Vendor: " << QString((const char*)glGetString(GL_VENDOR));
+            qCDebug(glLogging) << "GL Renderer: " << QString((const char*)glGetString(GL_RENDERER));
+        });
+    }

    return result;
 }
--- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendShader.cpp
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendShader.cpp
@ -17,7 +17,6 @@ std::string GL41Backend::getBackendShaderHeader() const {
    static const std::string header(
        R"SHADER(#version 410 core
        #define GPU_GL410
-        #define PRECISIONQ
        #define BITFIELD int
        )SHADER");
    return header;
--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendShader.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendShader.cpp
@ -18,7 +18,6 @@ std::string GL45Backend::getBackendShaderHeader() const {
    static const std::string header(
        R"SHADER(#version 450 core
        #define GPU_GL450
-        #define PRECISIONQ
        #define BITFIELD int
        )SHADER"
 #ifdef GPU_SSBO_TRANSFORM_OBJECT
--- a/libraries/gpu-gles/src/gpu/gles/GLESBackendShader.cpp
+++ b/libraries/gpu-gles/src/gpu/gles/GLESBackendShader.cpp
@ -17,10 +17,9 @@ std::string GLESBackend::getBackendShaderHeader() const {
    static const std::string header(
        R"SHADER(#version 310 es
        #extension GL_EXT_texture_buffer : enable
-        precision lowp float; // check precision 2
-        precision lowp samplerBuffer;
-        precision lowp sampler2DShadow;
-        #define PRECISIONQ highp
+        precision highp float;
+        precision highp samplerBuffer;
+        precision highp sampler2DShadow;
        #define BITFIELD highp int
        )SHADER");
    return header;
--- a/libraries/gpu/src/gpu/Format.h
+++ b/libraries/gpu/src/gpu/Format.h
@ -50,47 +50,50 @@ enum Type : uint8_t {
 };
 // Array providing the size in bytes for a given scalar type
 static const int TYPE_SIZE[NUM_TYPES] = {
-    4,
-    4,
-    4,
-    2,
-    2,
-    2,
-    1,
-    1,
+    4, // FLOAT
+    4, // INT32
+    4, // UINT32
+    2, // HALF
+    2, // INT16
+    2, // UINT16
+    1, // INT8
+    1, // UINT8

    // normalized values
-    4,
-    4,
-    2,
-    2,
-    1,
-    1,
-    4,
+    4, // NINT32
+    4, // NUINT32
+    2, // NINT16 
+    2, // NUINT16
+    1, // NINT8
+    1, // NUINT8
+    1, // NUINT2
+    1, // NINT2_10_10_10

-    1
+    1, // COMPRESSED
 };
+
 // Array answering the question Does this type is integer or not 
 static const bool TYPE_IS_INTEGER[NUM_TYPES] = {
-    false,
-    true,
-    true,
-    false,
-    true,
-    true,
-    true,
-    true,
+    false, // FLOAT
+    true, // INT32
+    true, // UINT32
+    false, // HALF
+    true, // INT16
+    true, // UINT16
+    true, // INT8
+    true, // UINT8

    // Normalized values
-    false,
-    false,
-    false,
-    false,
-    false,
-    false,
-    false,
+    false, // NINT32
+    false, // NUINT32
+    false, // NINT16 
+    false, // NUINT16
+    false, // NINT8
+    false, // NUINT8
+    false, // NUINT2
+    false, // NINT2_10_10_10

-    false,
+    false, // COMPRESSED
 };

 // Dimension of an Element
@ -367,9 +370,9 @@ public:
    static const Element PART_DRAWCALL;
    
 protected:
-    uint8 _semantic;
-    uint8 _dimension : 4;
-    uint8 _type : 4;
+    uint16 _semantic : 7;
+    uint16 _dimension : 4;
+    uint16 _type : 5;
 };

  
--- a/libraries/gpu/src/gpu/Texture_ktx.cpp
+++ b/libraries/gpu/src/gpu/Texture_ktx.cpp
@ -46,13 +46,14 @@ struct GPUKTXPayload {

        memcpy(data, &_samplerDesc, sizeof(Sampler::Desc));
        data += sizeof(Sampler::Desc);
-        
+
        // We can't copy the bitset in Texture::Usage in a crossplateform manner
        // So serialize it manually
-        *(uint32*)data = _usage._flags.to_ulong();
+        uint32 usageData = _usage._flags.to_ulong();
+        memcpy(data, &usageData, sizeof(uint32));
        data += sizeof(uint32);

-        *(TextureUsageType*)data = _usageType;
+        memcpy(data, &_usageType, sizeof(TextureUsageType));
        data += sizeof(TextureUsageType);

        return data + PADDING;
@ -77,13 +78,15 @@ struct GPUKTXPayload {

        memcpy(&_samplerDesc, data, sizeof(Sampler::Desc));
        data += sizeof(Sampler::Desc);
-        
+
        // We can't copy the bitset in Texture::Usage in a crossplateform manner
        // So unserialize it manually
-        _usage = Texture::Usage(*(const uint32*)data);
+        uint32 usageData;
+        memcpy(&usageData, data, sizeof(uint32));
+        _usage = Texture::Usage(usageData);
        data += sizeof(uint32);

-        _usageType = *(const TextureUsageType*)data;
+        memcpy(&_usageType, data, sizeof(TextureUsageType));
        return true;
    }

@ -710,4 +713,4 @@ bool Texture::evalTextureFormat(const ktx::Header& header, Element& mipFormat, E
        return false;
    }
    return true;
-}
+}
--- a/libraries/graphics/src/graphics/Light.slh
+++ b/libraries/graphics/src/graphics/Light.slh
@ -34,7 +34,7 @@ vec3 getLightIrradiance(Light l) { return lightIrradiance_getIrradiance(l.irradi
 // Light Ambient

 struct LightAmbient {
-    PRECISIONQ vec4 _ambient;
+    vec4 _ambient;
    SphericalHarmonics _ambientSphere;
    mat4 transform;
 };
--- a/libraries/graphics/src/graphics/LightIrradiance.shared.slh
+++ b/libraries/graphics/src/graphics/LightIrradiance.shared.slh
@ -14,9 +14,9 @@
 #define LightIrradianceConstRef LightIrradiance

 struct LightIrradiance {
-    PRECISIONQ vec4 colorIntensity;
+    vec4 colorIntensity;
    // falloffRadius, cutoffRadius, falloffSpot, spare
-    PRECISIONQ vec4 attenuation;
+    vec4 attenuation;
 };


--- a/libraries/graphics/src/graphics/LightVolume.shared.slh
+++ b/libraries/graphics/src/graphics/LightVolume.shared.slh
@ -16,8 +16,8 @@
 #define LightVolumeConstRef LightVolume

 struct LightVolume {
-    PRECISIONQ vec4 positionRadius;
-    PRECISIONQ vec4 directionSpotCos;
+    vec4 positionRadius;
+    vec4 directionSpotCos;
 };

 bool lightVolume_isPoint(LightVolume lv) { return bool(lv.directionSpotCos.w < 0.f); }
--- a/libraries/graphics/src/graphics/Material.slh
+++ b/libraries/graphics/src/graphics/Material.slh
@ -15,10 +15,10 @@
 // to what is provided by the uniform buffer, or the material key has the wrong bits

 struct Material {
-    PRECISIONQ vec4 _emissiveOpacity;
-    PRECISIONQ vec4 _albedoRoughness;
-    PRECISIONQ vec4 _fresnelMetallic;
-    PRECISIONQ vec4 _scatteringSpare2Key;
+    vec4 _emissiveOpacity;
+    vec4 _albedoRoughness;
+    vec4 _fresnelMetallic;
+    vec4 _scatteringSpare2Key;
 };

 uniform materialBuffer {
@ -64,7 +64,4 @@ const BITFIELD OCCLUSION_MAP_BIT             = 0x00004000;
 const BITFIELD LIGHTMAP_MAP_BIT              = 0x00008000;
 const BITFIELD SCATTERING_MAP_BIT            = 0x00010000;

-#ifdef GL_ES
-precision lowp float;
-#endif
 <@endif@>
--- a/libraries/graphics/src/graphics/SphericalHarmonics.shared.slh
+++ b/libraries/graphics/src/graphics/SphericalHarmonics.shared.slh
@ -16,15 +16,15 @@
 #define SphericalHarmonicsConstRef SphericalHarmonics

 struct SphericalHarmonics {
-    PRECISIONQ vec4 L00;
-    PRECISIONQ vec4 L1m1;
-    PRECISIONQ vec4 L10;
-    PRECISIONQ vec4 L11;
-    PRECISIONQ vec4 L2m2;
-    PRECISIONQ vec4 L2m1;
-    PRECISIONQ vec4 L20;
-    PRECISIONQ vec4 L21;
-    PRECISIONQ vec4 L22;
+    vec4 L00;
+    vec4 L1m1;
+    vec4 L10;
+    vec4 L11;
+    vec4 L2m2;
+    vec4 L2m1;
+    vec4 L20;
+    vec4 L21;
+    vec4 L22;
 };

 vec4 sphericalHarmonics_evalSphericalLight(SphericalHarmonicsConstRef sh, vec3 direction) {
--- a/libraries/networking/src/DomainHandler.h
+++ b/libraries/networking/src/DomainHandler.h
@ -97,7 +97,7 @@ public:

    int getCheckInPacketsSinceLastReply() const { return _checkInPacketsSinceLastReply; }
    void sentCheckInPacket();
-    void domainListReceived() { _checkInPacketsSinceLastReply = 0; }
+    void clearPendingCheckins() { _checkInPacketsSinceLastReply = 0; }

    /**jsdoc
     * <p>The reasons that you may be refused connection to a domain are defined by numeric values:</p>
--- a/libraries/networking/src/HMACAuth.cpp
+++ b/libraries/networking/src/HMACAuth.cpp
@ -0,0 +1,117 @@
+//
+//  HMACAuth.cpp
+//  libraries/networking/src
+//
+//  Created by Simon Walton on 3/19/2018.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "HMACAuth.h"
+
+#include <openssl/opensslv.h>
+#include <openssl/hmac.h>
+
+#include <QUuid>
+#include "NetworkLogging.h"
+#include <cassert>
+
+#if OPENSSL_VERSION_NUMBER >= 0x10100000
+HMACAuth::HMACAuth(AuthMethod authMethod)
+    : _hmacContext(HMAC_CTX_new())
+    , _authMethod(authMethod) { }
+
+HMACAuth::~HMACAuth()
+{
+    HMAC_CTX_free(_hmacContext);
+}
+
+#else
+
+HMACAuth::HMACAuth(AuthMethod authMethod)
+    : _hmacContext(new HMAC_CTX())
+    , _authMethod(authMethod) {
+    HMAC_CTX_init(_hmacContext);
+}
+
+HMACAuth::~HMACAuth() {
+    HMAC_CTX_cleanup(_hmacContext);
+    delete _hmacContext;
+}
+#endif
+
+bool HMACAuth::setKey(const char* keyValue, int keyLen) {
+    const EVP_MD* sslStruct = nullptr;
+
+    switch (_authMethod) {
+    case MD5:
+        sslStruct = EVP_md5();
+        break;
+
+    case SHA1:
+        sslStruct = EVP_sha1();
+        break;
+
+    case SHA224:
+        sslStruct = EVP_sha224();
+        break;
+
+    case SHA256:
+        sslStruct = EVP_sha256();
+        break;
+
+    case RIPEMD160:
+        sslStruct = EVP_ripemd160();
+        break;
+
+    default:
+        return false;
+    }
+
+    QMutexLocker lock(&_lock);
+    return (bool) HMAC_Init_ex(_hmacContext, keyValue, keyLen, sslStruct, nullptr);
+}
+
+bool HMACAuth::setKey(const QUuid& uidKey) {
+    const QByteArray rfcBytes(uidKey.toRfc4122());
+    return setKey(rfcBytes.constData(), rfcBytes.length());
+}
+
+bool HMACAuth::addData(const char* data, int dataLen) {
+    QMutexLocker lock(&_lock);
+    return (bool) HMAC_Update(_hmacContext, reinterpret_cast<const unsigned char*>(data), dataLen);
+}
+
+HMACAuth::HMACHash HMACAuth::result() {
+    HMACHash hashValue(EVP_MAX_MD_SIZE);
+    unsigned int hashLen;
+    QMutexLocker lock(&_lock);
+    
+    auto hmacResult = HMAC_Final(_hmacContext, &hashValue[0], &hashLen);
+    
+    if (hmacResult) {
+        hashValue.resize((size_t)hashLen);
+    } else {
+        // the HMAC_FINAL call failed - should not be possible to get into this state
+        qCWarning(networking) << "Error occured calling HMAC_Final";
+        assert(hmacResult);
+    }
+
+    // Clear state for possible reuse.
+    HMAC_Init_ex(_hmacContext, nullptr, 0, nullptr, nullptr);
+    return hashValue;
+}
+
+bool HMACAuth::calculateHash(HMACHash& hashResult, const char* data, int dataLen) {
+    QMutexLocker lock(&_lock);
+    if (!addData(data, dataLen)) {
+        qCWarning(networking) << "Error occured calling HMACAuth::addData()";
+        assert(false);
+        return false;
+    }
+
+    hashResult = result();
+    return true;
+}
--- a/libraries/networking/src/HMACAuth.h
+++ b/libraries/networking/src/HMACAuth.h
@ -0,0 +1,47 @@
+//
+//  HMACAuth.h
+//  libraries/networking/src
+//
+//  Created by Simon Walton on 3/19/2018.
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_HMACAuth_h
+#define hifi_HMACAuth_h
+
+#include <vector>
+#include <memory>
+#include <QtCore/QMutex>
+
+class QUuid;
+
+class HMACAuth {
+public:
+    enum AuthMethod { MD5, SHA1, SHA224, SHA256, RIPEMD160 };
+    using HMACHash = std::vector<unsigned char>;
+    
+    explicit HMACAuth(AuthMethod authMethod = MD5);
+    ~HMACAuth();
+
+    bool setKey(const char* keyValue, int keyLen);
+    bool setKey(const QUuid& uidKey);
+    // Calculate complete hash in one.
+    bool calculateHash(HMACHash& hashResult, const char* data, int dataLen);
+
+    // Append to data to be hashed.
+    bool addData(const char* data, int dataLen);
+    // Get the resulting hash from calls to addData().
+    // Note that only one hash may be calculated at a time for each
+    // HMACAuth instance if this interface is used.
+    HMACHash result();
+
+private:
+    QMutex _lock { QMutex::Recursive };
+    struct hmac_ctx_st* _hmacContext;
+    AuthMethod _authMethod;
+};
+
+#endif  // hifi_HMACAuth_h
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@ -36,6 +36,7 @@
 #include "HifiSockAddr.h"
 #include "NetworkLogging.h"
 #include "udt/Packet.h"
+#include "HMACAuth.h"

 static Setting::Handle<quint16> LIMITED_NODELIST_LOCAL_PORT("LimitedNodeList.LocalPort", 0);

@ -332,15 +333,20 @@ bool LimitedNodeList::packetSourceAndHashMatchAndTrackBandwidth(const udt::Packe
            if (verifiedPacket && !ignoreVerification) {

                QByteArray packetHeaderHash = NLPacket::verificationHashInHeader(packet);
-                QByteArray expectedHash = NLPacket::hashForPacketAndSecret(packet, sourceNode->getConnectionSecret());
+                QByteArray expectedHash;
+                auto sourceNodeHMACAuth = sourceNode->getAuthenticateHash();
+                if (sourceNode->getAuthenticateHash()) {
+                    expectedHash = NLPacket::hashForPacketAndHMAC(packet, *sourceNodeHMACAuth);
+                }

-                // check if the md5 hash in the header matches the hash we would expect
-                if (packetHeaderHash != expectedHash) {
+                // check if the HMAC-md5 hash in the header matches the hash we would expect
+                if (!sourceNodeHMACAuth || packetHeaderHash != expectedHash) {
                    static QMultiMap<QUuid, PacketType> hashDebugSuppressMap;

                    if (!hashDebugSuppressMap.contains(sourceID, headerType)) {
-                        qCDebug(networking) << packetHeaderHash << expectedHash;
                        qCDebug(networking) << "Packet hash mismatch on" << headerType << "- Sender" << sourceID;
+                        qCDebug(networking) << "Packet len:" << packet.getDataSize() << "Expected hash:" <<
+                            expectedHash.toHex() << "Actual:" << packetHeaderHash.toHex();

                        hashDebugSuppressMap.insert(sourceID, headerType);
                    }
@ -372,15 +378,15 @@ void LimitedNodeList::collectPacketStats(const NLPacket& packet) {
    _numCollectedBytes += packet.getDataSize();
 }

-void LimitedNodeList::fillPacketHeader(const NLPacket& packet, const QUuid& connectionSecret) {
+void LimitedNodeList::fillPacketHeader(const NLPacket& packet, HMACAuth* hmacAuth) {
    if (!PacketTypeEnum::getNonSourcedPackets().contains(packet.getType())) {
        packet.writeSourceID(getSessionLocalID());
    }

-    if (!connectionSecret.isNull()
+    if (hmacAuth
        && !PacketTypeEnum::getNonSourcedPackets().contains(packet.getType())
        && !PacketTypeEnum::getNonVerifiedPackets().contains(packet.getType())) {
-        packet.writeVerificationHashGivenSecret(connectionSecret);
+        packet.writeVerificationHash(*hmacAuth);
    }
 }

@ -396,17 +402,17 @@ qint64 LimitedNodeList::sendUnreliablePacket(const NLPacket& packet, const Node&
    emit dataSent(destinationNode.getType(), packet.getDataSize());
    destinationNode.recordBytesSent(packet.getDataSize());

-    return sendUnreliablePacket(packet, *destinationNode.getActiveSocket(), destinationNode.getConnectionSecret());
+    return sendUnreliablePacket(packet, *destinationNode.getActiveSocket(), destinationNode.getAuthenticateHash());
 }

 qint64 LimitedNodeList::sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr,
-                                             const QUuid& connectionSecret) {
+        HMACAuth* hmacAuth) {
    Q_ASSERT(!packet.isPartOfMessage());
    Q_ASSERT_X(!packet.isReliable(), "LimitedNodeList::sendUnreliablePacket",
               "Trying to send a reliable packet unreliably.");

    collectPacketStats(packet);
-    fillPacketHeader(packet, connectionSecret);
+    fillPacketHeader(packet, hmacAuth);

    return _nodeSocket.writePacket(packet, sockAddr);
 }
@ -419,7 +425,7 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
        emit dataSent(destinationNode.getType(), packet->getDataSize());
        destinationNode.recordBytesSent(packet->getDataSize());

-        return sendPacket(std::move(packet), *activeSocket, destinationNode.getConnectionSecret());
+        return sendPacket(std::move(packet), *activeSocket, destinationNode.getAuthenticateHash());
    } else {
        qCDebug(networking) << "LimitedNodeList::sendPacket called without active socket for node" << destinationNode << "- not sending";
        return ERROR_SENDING_PACKET_BYTES;
@ -427,18 +433,18 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
 }

 qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr,
-                                   const QUuid& connectionSecret) {
+                                   HMACAuth* hmacAuth) {
    Q_ASSERT(!packet->isPartOfMessage());
    if (packet->isReliable()) {
        collectPacketStats(*packet);
-        fillPacketHeader(*packet, connectionSecret);
+        fillPacketHeader(*packet, hmacAuth);

        auto size = packet->getDataSize();
        _nodeSocket.writePacket(std::move(packet), sockAddr);

        return size;
    } else {
-        return sendUnreliablePacket(*packet, sockAddr, connectionSecret);
+        return sendUnreliablePacket(*packet, sockAddr, hmacAuth);
    }
 }

@ -447,13 +453,14 @@ qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetLi

    if (activeSocket) {
        qint64 bytesSent = 0;
-        auto connectionSecret = destinationNode.getConnectionSecret();
+        auto connectionHash = destinationNode.getAuthenticateHash();

        // close the last packet in the list
        packetList.closeCurrentPacket();

        while (!packetList._packets.empty()) {
-            bytesSent += sendPacket(packetList.takeFront<NLPacket>(), *activeSocket, connectionSecret);
+            bytesSent += sendPacket(packetList.takeFront<NLPacket>(), *activeSocket,
+                connectionHash);
        }

        emit dataSent(destinationNode.getType(), bytesSent);
@ -466,14 +473,14 @@ qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetLi
 }

 qint64 LimitedNodeList::sendUnreliableUnorderedPacketList(NLPacketList& packetList, const HifiSockAddr& sockAddr,
-                                                          const QUuid& connectionSecret) {
+                                                          HMACAuth* hmacAuth) {
    qint64 bytesSent = 0;

    // close the last packet in the list
    packetList.closeCurrentPacket();

    while (!packetList._packets.empty()) {
-        bytesSent += sendPacket(packetList.takeFront<NLPacket>(), sockAddr, connectionSecret);
+        bytesSent += sendPacket(packetList.takeFront<NLPacket>(), sockAddr, hmacAuth);
    }

    return bytesSent;
@ -501,7 +508,7 @@ qint64 LimitedNodeList::sendPacketList(std::unique_ptr<NLPacketList> packetList,
        for (std::unique_ptr<udt::Packet>& packet : packetList->_packets) {
            NLPacket* nlPacket = static_cast<NLPacket*>(packet.get());
            collectPacketStats(*nlPacket);
-            fillPacketHeader(*nlPacket, destinationNode.getConnectionSecret());
+            fillPacketHeader(*nlPacket, destinationNode.getAuthenticateHash());
        }

        return _nodeSocket.writePacketList(std::move(packetList), *activeSocket);
@ -524,7 +531,7 @@ qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node&
    auto& destinationSockAddr = (overridenSockAddr.isNull()) ? *destinationNode.getActiveSocket()
                                                             : overridenSockAddr;

-    return sendPacket(std::move(packet), destinationSockAddr, destinationNode.getConnectionSecret());
+    return sendPacket(std::move(packet), destinationSockAddr, destinationNode.getAuthenticateHash());
 }

 int LimitedNodeList::updateNodeWithDataFromPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
--- a/libraries/networking/src/LimitedNodeList.h
+++ b/libraries/networking/src/LimitedNodeList.h
@ -138,19 +138,17 @@ public:
    // use sendUnreliablePacket to send an unreliable packet (that you do not need to move)
    // either to a node (via its active socket) or to a manual sockaddr
    qint64 sendUnreliablePacket(const NLPacket& packet, const Node& destinationNode);
-    qint64 sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr,
-                                const QUuid& connectionSecret = QUuid());
+    qint64 sendUnreliablePacket(const NLPacket& packet, const HifiSockAddr& sockAddr, HMACAuth* hmacAuth = nullptr);

    // use sendPacket to send a moved unreliable or reliable NL packet to a node's active socket or manual sockaddr
    qint64 sendPacket(std::unique_ptr<NLPacket> packet, const Node& destinationNode);
-    qint64 sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr,
-                      const QUuid& connectionSecret = QUuid());
+    qint64 sendPacket(std::unique_ptr<NLPacket> packet, const HifiSockAddr& sockAddr, HMACAuth* hmacAuth = nullptr);

    // use sendUnreliableUnorderedPacketList to unreliably send separate packets from the packet list
    // either to a node's active socket or to a manual sockaddr
    qint64 sendUnreliableUnorderedPacketList(NLPacketList& packetList, const Node& destinationNode);
    qint64 sendUnreliableUnorderedPacketList(NLPacketList& packetList, const HifiSockAddr& sockAddr,
-                          const QUuid& connectionSecret = QUuid());
+        HMACAuth* hmacAuth = nullptr);

    // use sendPacketList to send reliable packet lists (ordered or unordered) to a node's active socket
    // or to a manual sock addr
@ -372,7 +370,7 @@ protected:
    qint64 writePacket(const NLPacket& packet, const HifiSockAddr& destinationSockAddr,
                       const QUuid& connectionSecret = QUuid());
    void collectPacketStats(const NLPacket& packet);
-    void fillPacketHeader(const NLPacket& packet, const QUuid& connectionSecret = QUuid());
+    void fillPacketHeader(const NLPacket& packet, HMACAuth* hmacAuth = nullptr);

    void setLocalSocket(const HifiSockAddr& sockAddr);

--- a/libraries/networking/src/NLPacket.cpp
+++ b/libraries/networking/src/NLPacket.cpp
@ -11,6 +11,8 @@

 #include "NLPacket.h"

+#include "HMACAuth.h"
+
 int NLPacket::localHeaderSize(PacketType type) {
    bool nonSourced = PacketTypeEnum::getNonSourcedPackets().contains(type);
    bool nonVerified = PacketTypeEnum::getNonVerifiedPackets().contains(type);
@ -150,18 +152,16 @@ QByteArray NLPacket::verificationHashInHeader(const udt::Packet& packet) {
    return QByteArray(packet.getData() + offset, NUM_BYTES_MD5_HASH);
 }

-QByteArray NLPacket::hashForPacketAndSecret(const udt::Packet& packet, const QUuid& connectionSecret) {
-    QCryptographicHash hash(QCryptographicHash::Md5);
-    
+QByteArray NLPacket::hashForPacketAndHMAC(const udt::Packet& packet, HMACAuth& hash) {
    int offset = Packet::totalHeaderSize(packet.isPartOfMessage()) + sizeof(PacketType) + sizeof(PacketVersion)
        + NUM_BYTES_LOCALID + NUM_BYTES_MD5_HASH;
    
    // add the packet payload and the connection UUID
-    hash.addData(packet.getData() + offset, packet.getDataSize() - offset);
-    hash.addData(connectionSecret.toRfc4122());
-    
-    // return the hash
-    return hash.result();
+    HMACAuth::HMACHash hashResult;
+    if (!hash.calculateHash(hashResult, packet.getData() + offset, packet.getDataSize() - offset)) {
+        return QByteArray();
+    }
+    return QByteArray((const char*) hashResult.data(), (int) hashResult.size());
 }

 void NLPacket::writeTypeAndVersion() {
@ -214,14 +214,14 @@ void NLPacket::writeSourceID(LocalID sourceID) const {
    _sourceID = sourceID;
 }

-void NLPacket::writeVerificationHashGivenSecret(const QUuid& connectionSecret) const {
+void NLPacket::writeVerificationHash(HMACAuth& hmacAuth) const {
    Q_ASSERT(!PacketTypeEnum::getNonSourcedPackets().contains(_type) &&
             !PacketTypeEnum::getNonVerifiedPackets().contains(_type));
    
    auto offset = Packet::totalHeaderSize(isPartOfMessage()) + sizeof(PacketType) + sizeof(PacketVersion)
                + NUM_BYTES_LOCALID;

-    QByteArray verificationHash = hashForPacketAndSecret(*this, connectionSecret);
+    QByteArray verificationHash = hashForPacketAndHMAC(*this, hmacAuth);
    
    memcpy(_packet.get() + offset, verificationHash.data(), verificationHash.size());
 }
--- a/libraries/networking/src/NLPacket.h
+++ b/libraries/networking/src/NLPacket.h
@ -18,6 +18,8 @@

 #include "udt/Packet.h"

+class HMACAuth;
+
 class NLPacket : public udt::Packet {
    Q_OBJECT
 public:
@ -69,7 +71,7 @@ public:
    
    static LocalID sourceIDInHeader(const udt::Packet& packet);
    static QByteArray verificationHashInHeader(const udt::Packet& packet);
-    static QByteArray hashForPacketAndSecret(const udt::Packet& packet, const QUuid& connectionSecret);
+    static QByteArray hashForPacketAndHMAC(const udt::Packet& packet, HMACAuth& hash);
    
    PacketType getType() const { return _type; }
    void setType(PacketType type);
@ -78,9 +80,9 @@ public:
    void setVersion(PacketVersion version);

    LocalID getSourceID() const { return _sourceID; }
-
+    
    void writeSourceID(LocalID sourceID) const;
-    void writeVerificationHashGivenSecret(const QUuid& connectionSecret) const;
+    void writeVerificationHash(HMACAuth& hmacAuth) const;

 protected:
    
--- a/libraries/networking/src/Node.cpp
+++ b/libraries/networking/src/Node.cpp
@ -86,7 +86,7 @@ NodeType_t NodeType::fromString(QString type) {


 Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
-           const HifiSockAddr& localSocket, QObject* parent) :
+    const HifiSockAddr& localSocket, QObject* parent) :
    NetworkPeer(uuid, publicSocket, localSocket, parent),
    _type(type),
    _pingMs(-1),  // "Uninitialized"
@ -108,6 +108,7 @@ void Node::setType(char type) {
    _symmetricSocket.setObjectName(typeString);
 }

+
 void Node::updateClockSkewUsec(qint64 clockSkewSample) {
    _clockSkewMovingPercentile.updatePercentile(clockSkewSample);
    _clockSkewUsec = (quint64)_clockSkewMovingPercentile.getValueAtPercentile();
@ -194,3 +195,16 @@ QDebug operator<<(QDebug debug, const Node& node) {
    debug.nospace() << node.getPublicSocket() << "/" << node.getLocalSocket();
    return debug.nospace();
 }
+
+void Node::setConnectionSecret(const QUuid& connectionSecret) {
+    if (_connectionSecret == connectionSecret) {
+        return;
+    }
+
+    if (!_authenticateHash) {
+        _authenticateHash.reset(new HMACAuth());
+    }
+
+    _connectionSecret = connectionSecret;
+    _authenticateHash->setKey(_connectionSecret);
+}
--- a/libraries/networking/src/Node.h
+++ b/libraries/networking/src/Node.h
@ -33,6 +33,7 @@
 #include "SimpleMovingAverage.h"
 #include "MovingPercentile.h"
 #include "NodePermissions.h"
+#include "HMACAuth.h"

 class Node : public NetworkPeer {
    Q_OBJECT
@ -55,7 +56,8 @@ public:
    void setIsUpstream(bool isUpstream) { _isUpstream = isUpstream; }

    const QUuid& getConnectionSecret() const { return _connectionSecret; }
-    void setConnectionSecret(const QUuid& connectionSecret) { _connectionSecret = connectionSecret; }
+    void setConnectionSecret(const QUuid& connectionSecret);
+    HMACAuth* getAuthenticateHash() const { return _authenticateHash.get(); }

    NodeData* getLinkedData() const { return _linkedData.get(); }
    void setLinkedData(std::unique_ptr<NodeData> linkedData) { _linkedData = std::move(linkedData); }
@ -97,6 +99,7 @@ private:
    NodeType_t _type;

    QUuid _connectionSecret;
+    std::unique_ptr<HMACAuth> _authenticateHash { nullptr };
    std::unique_ptr<NodeData> _linkedData;
    bool _isReplicated { false };
    int _pingMs;
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@ -594,6 +594,8 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedM
    }
    // read in the connection token from the packet, then send domain-server checkin
    _domainHandler.setConnectionToken(QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID)));
+
+    _domainHandler.clearPendingCheckins();
    sendDomainServerCheckIn();
 }

@ -605,7 +607,7 @@ void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message)
    }

    // this is a packet from the domain server, reset the count of un-replied check-ins
-    _domainHandler.domainListReceived();
+    _domainHandler.clearPendingCheckins();

    // emit our signal so listeners know we just heard from the DS
    emit receivedDomainServerList();
--- a/libraries/networking/src/udt/PacketHeaders.cpp
+++ b/libraries/networking/src/udt/PacketHeaders.cpp
@ -92,7 +92,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
        case PacketType::AvatarQuery:
            return static_cast<PacketVersion>(AvatarQueryVersion::ConicalFrustums);
        default:
-            return 20;
+            return 21;
    }
 }

--- a/libraries/octree/src/OctreeEditPacketSender.cpp
+++ b/libraries/octree/src/OctreeEditPacketSender.cpp
@ -23,7 +23,6 @@ const int OctreeEditPacketSender::DEFAULT_MAX_PENDING_MESSAGES = PacketSender::D


 OctreeEditPacketSender::OctreeEditPacketSender() :
-    _shouldSend(true),
    _maxPendingMessages(DEFAULT_MAX_PENDING_MESSAGES),
    _releaseQueuedMessagesPending(false)
 {
@ -146,10 +145,6 @@ void OctreeEditPacketSender::queuePendingPacketToNodes(std::unique_ptr<NLPacket>
 }

 void OctreeEditPacketSender::queuePacketToNodes(std::unique_ptr<NLPacket> packet) {
-    if (!_shouldSend) {
-        return; // bail early
-    }
-
    assert(serversExist()); // we must have servers to be here!!

    auto node = DependencyManager::get<NodeList>()->soloNodeOfType(getMyNodeType());
@ -162,10 +157,6 @@ void OctreeEditPacketSender::queuePacketToNodes(std::unique_ptr<NLPacket> packet
 // NOTE: editMessage - is JUST the octcode/color and does not contain the packet header
 void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, QByteArray& editMessage) {

-    if (!_shouldSend) {
-        return; // bail early
-    }
-
    // If we don't have servers, then we will simply queue up all of these packets and wait till we have
    // servers for processing
    if (!serversExist()) {
--- a/libraries/octree/src/OctreeEditPacketSender.h
+++ b/libraries/octree/src/OctreeEditPacketSender.h
@ -41,12 +41,10 @@ public:

    /// are we in sending mode. If we're not in sending mode then all packets and messages will be ignored and
    /// not queued and not sent
-    bool getShouldSend() const { return _shouldSend; }

    /// set sending mode. By default we are set to shouldSend=TRUE and packets will be sent. If shouldSend=FALSE, then we'll
    /// switch to not sending mode, and all packets and messages will be ignored, not queued, and not sent. This might be used
    /// in an application like interface when all octree features are disabled.
-    void setShouldSend(bool shouldSend) { _shouldSend = shouldSend; }

    /// if you're running in non-threaded mode, you must call this method regularly
    virtual bool process() override;
@ -76,7 +74,6 @@ public slots:
 protected:
    using EditMessagePair = std::pair<PacketType, QByteArray>;

-    bool _shouldSend;
    void queuePacketToNode(const QUuid& nodeID, std::unique_ptr<NLPacket> packet);
    void queuePacketListToNode(const QUuid& nodeUUID, std::unique_ptr<NLPacketList> packetList);

--- a/libraries/physics/src/EntityMotionState.cpp
+++ b/libraries/physics/src/EntityMotionState.cpp
@ -349,7 +349,7 @@ bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) {

    if (_numInactiveUpdates > 0) {
        const uint8_t MAX_NUM_INACTIVE_UPDATES = 20;
-        if (_numInactiveUpdates > MAX_NUM_INACTIVE_UPDATES) {
+        if (_numInactiveUpdates > MAX_NUM_INACTIVE_UPDATES || isServerlessMode()) {
            // clear local ownership (stop sending updates) and let the server clear itself
            _entity->clearSimulationOwnership();
            return false;
@ -833,3 +833,9 @@ void EntityMotionState::clearObjectVelocities() const {
    }
    _entity->setAcceleration(glm::vec3(0.0f));
 }
+
+bool EntityMotionState::isServerlessMode() {
+    EntityTreeElementPointer element = _entity->getElement();
+    EntityTreePointer tree = element ? element->getTree() : nullptr;
+    return tree ? tree->isServerlessMode() : false;
+}
--- a/libraries/physics/src/EntityMotionState.h
+++ b/libraries/physics/src/EntityMotionState.h
@ -156,6 +156,8 @@ protected:
    uint8_t _numInactiveUpdates { 1 };
    uint8_t _bidPriority { 0 };
    bool _serverVariablesSet { false };
+
+    bool isServerlessMode();
 };

 #endif // hifi_EntityMotionState_h
--- a/libraries/physics/src/PhysicalEntitySimulation.cpp
+++ b/libraries/physics/src/PhysicalEntitySimulation.cpp
@ -328,10 +328,18 @@ void PhysicalEntitySimulation::handleChangedMotionStates(const VectorOfMotionSta
 }

 void PhysicalEntitySimulation::addOwnershipBid(EntityMotionState* motionState) {
-    motionState->initForBid();
-    motionState->sendBid(_entityPacketSender, _physicsEngine->getNumSubsteps());
-    _bids.push_back(motionState);
-    _nextBidExpiry = glm::min(_nextBidExpiry, motionState->getNextBidExpiry());
+    if (getEntityTree()->isServerlessMode()) {
+        EntityItemPointer entity = motionState->getEntity();
+        auto nodeList = DependencyManager::get<NodeList>();
+        auto sessionID = nodeList->getSessionUUID();
+        entity->setSimulationOwner(SimulationOwner(sessionID, SCRIPT_GRAB_SIMULATION_PRIORITY));
+        _owned.push_back(motionState);
+    } else {
+        motionState->initForBid();
+        motionState->sendBid(_entityPacketSender, _physicsEngine->getNumSubsteps());
+        _bids.push_back(motionState);
+        _nextBidExpiry = glm::min(_nextBidExpiry, motionState->getNextBidExpiry());
+    }
 }

 void PhysicalEntitySimulation::addOwnership(EntityMotionState* motionState) {
--- a/libraries/procedural/src/procedural/Procedural.cpp
+++ b/libraries/procedural/src/procedural/Procedural.cpp
@ -19,7 +19,7 @@
 #include <SharedUtil.h>
 #include <NumericalConstants.h>
 #include <GLMHelpers.h>
-
+#include <NetworkingConstants.h>
 #include "ProceduralCommon_frag.h"

 #include "Logging.h"
@ -178,6 +178,8 @@ void Procedural::setProceduralData(const ProceduralData& proceduralData) {
                return;
            }
            _shaderPath = shaderUrl.toLocalFile();
+        } else if (shaderUrl.scheme() == URL_SCHEME_QRC) {
+            _shaderPath = ":" + shaderUrl.path();
        } else {
            _networkShader = ShaderCache::instance().getShader(shaderUrl);
        }
--- a/libraries/qml/src/qml/Logging.h
+++ b/libraries/qml/src/qml/Logging.h
@ -6,8 +6,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#ifndef hifi_Controllers_Logging_h
-#define hifi_Controllers_Logging_h
+#ifndef hifi_QML_Logging_h
+#define hifi_QML_Logging_h

 #include <QLoggingCategory>

--- a/libraries/render-utils/src/LightingModel.slh
+++ b/libraries/render-utils/src/LightingModel.slh
@ -14,10 +14,10 @@
 <@func declareLightingModel()@>

 struct LightingModel {
-    PRECISIONQ vec4 _UnlitEmissiveLightmapBackground;
-    PRECISIONQ vec4 _ScatteringDiffuseSpecularAlbedo;
-    PRECISIONQ vec4 _AmbientDirectionalPointSpot;
-    PRECISIONQ vec4 _ShowContourObscuranceWireframe;
+    vec4 _UnlitEmissiveLightmapBackground;
+    vec4 _ScatteringDiffuseSpecularAlbedo;
+    vec4 _AmbientDirectionalPointSpot;
+    vec4 _ShowContourObscuranceWireframe;
 };

 uniform lightingModelBuffer{
--- a/libraries/script-engine/src/ScriptEngine.cpp
+++ b/libraries/script-engine/src/ScriptEngine.cpp
@ -101,8 +101,6 @@ int functionSignatureMetaID = qRegisterMetaType<QScriptEngine::FunctionSignature

 int scriptEnginePointerMetaID = qRegisterMetaType<ScriptEnginePointer>();

-Q_LOGGING_CATEGORY(scriptengineScript, "hifi.scriptengine.script")
-
 static QScriptValue debugPrint(QScriptContext* context, QScriptEngine* engine) {
    QString message = "";
    for (int i = 0; i < context->argumentCount(); i++) {
@ -115,9 +113,9 @@ static QScriptValue debugPrint(QScriptContext* context, QScriptEngine* engine) {
    if (ScriptEngine *scriptEngine = qobject_cast<ScriptEngine*>(engine)) {
        scriptEngine->print(message);
        // prefix the script engine name to help disambiguate messages in the main debug log
-        qCDebug(scriptengineScript, "[%s] %s", qUtf8Printable(scriptEngine->getFilename()), qUtf8Printable(message));
+        qCDebug(scriptengine_script, "[%s] %s", qUtf8Printable(scriptEngine->getFilename()), qUtf8Printable(message));
    } else {
-        qCDebug(scriptengineScript, "%s", qUtf8Printable(message));
+        qCDebug(scriptengine_script, "%s", qUtf8Printable(message));
    }

    return QScriptValue();
--- a/libraries/script-engine/src/ScriptEngine.h
+++ b/libraries/script-engine/src/ScriptEngine.h
@ -526,6 +526,9 @@ public:
    void setUserLoaded(bool isUserLoaded) { _isUserLoaded = isUserLoaded; }
    bool isUserLoaded() const { return _isUserLoaded; }

+    void setQuitWhenFinished(const bool quitWhenFinished) { _quitWhenFinished = quitWhenFinished; }
+    bool isQuitWhenFinished() const { return _quitWhenFinished; }
+
    // NOTE - this is used by the TypedArray implementation. we need to review this for thread safety
    ArrayBufferClass* getArrayBufferClass() { return _arrayBufferClass; }

@ -768,6 +771,8 @@ protected:
    std::atomic<bool> _isUserLoaded { false };
    bool _isReloading { false };

+    std::atomic<bool> _quitWhenFinished;
+
    ArrayBufferClass* _arrayBufferClass;

    AssetScriptingInterface* _assetScriptingInterface;
--- a/libraries/script-engine/src/ScriptEngineLogging.cpp
+++ b/libraries/script-engine/src/ScriptEngineLogging.cpp
@ -13,3 +13,4 @@

 Q_LOGGING_CATEGORY(scriptengine, "hifi.scriptengine")
 Q_LOGGING_CATEGORY(scriptengine_module, "hifi.scriptengine.module")
+Q_LOGGING_CATEGORY(scriptengine_script, "hifi.scriptengine.script")
--- a/libraries/script-engine/src/ScriptEngineLogging.h
+++ b/libraries/script-engine/src/ScriptEngineLogging.h
@ -16,6 +16,7 @@

 Q_DECLARE_LOGGING_CATEGORY(scriptengine)
 Q_DECLARE_LOGGING_CATEGORY(scriptengine_module)
+Q_DECLARE_LOGGING_CATEGORY(scriptengine_script)

 #endif // hifi_ScriptEngineLogging_h

--- a/libraries/script-engine/src/ScriptEngines.cpp
+++ b/libraries/script-engine/src/ScriptEngines.cpp
@ -347,7 +347,8 @@ void ScriptEngines::saveScripts() {
    {
        QReadLocker lock(&_scriptEnginesHashLock);
        for (auto it = _scriptEnginesHash.begin(); it != _scriptEnginesHash.end(); ++it) {
-            if (it.value() && it.value()->isUserLoaded()) {
+            // Save user-loaded scripts, only if they are set to quit when finished
+            if (it.value() && it.value()->isUserLoaded()  && !it.value()->isQuitWhenFinished()) {
                auto normalizedUrl = normalizeScriptURL(it.key());
                list.append(normalizedUrl.toString());
            }
@ -456,7 +457,7 @@ void ScriptEngines::reloadAllScripts() {
 }

 ScriptEnginePointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool isUserLoaded, bool loadScriptFromEditor,
-                                        bool activateMainWindow, bool reload) {
+                                              bool activateMainWindow, bool reload, bool quitWhenFinished) {
    if (thread() != QThread::currentThread()) {
        ScriptEnginePointer result { nullptr };
        BLOCKING_INVOKE_METHOD(this, "loadScript", Q_RETURN_ARG(ScriptEnginePointer, result),
@ -488,6 +489,7 @@ ScriptEnginePointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool i
    scriptEngine = ScriptEnginePointer(new ScriptEngine(_context, NO_SCRIPT, "about:" + scriptFilename.fileName()));
    addScriptEngine(scriptEngine);
    scriptEngine->setUserLoaded(isUserLoaded);
+    scriptEngine->setQuitWhenFinished(quitWhenFinished);

    if (scriptFilename.isEmpty() || !scriptUrl.isValid()) {
        launchScriptEngine(scriptEngine);
@ -496,6 +498,11 @@ ScriptEnginePointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool i
        connect(scriptEngine.data(), &ScriptEngine::scriptLoaded, this, &ScriptEngines::onScriptEngineLoaded);
        connect(scriptEngine.data(), &ScriptEngine::errorLoadingScript, this, &ScriptEngines::onScriptEngineError);

+        // Shutdown Interface when script finishes, if requested
+        if (quitWhenFinished) {
+            connect(scriptEngine.data(), &ScriptEngine::finished, this, &ScriptEngines::quitWhenFinished);
+        }
+
        // get the script engine object to load the script at the designated script URL
        scriptEngine->loadURL(scriptUrl, reload);
    }
@ -536,6 +543,10 @@ void ScriptEngines::onScriptEngineLoaded(const QString& rawScriptURL) {
    emit scriptCountChanged();
 }

+void ScriptEngines::quitWhenFinished() {
+    qApp->quit();
+}
+
 int ScriptEngines::runScriptInitializers(ScriptEnginePointer scriptEngine) {
    int ii=0;
    for (auto initializer : _scriptInitializers) {
--- a/libraries/script-engine/src/ScriptEngines.h
+++ b/libraries/script-engine/src/ScriptEngines.h
@ -88,10 +88,11 @@ public:
     * @param {boolean} [loadScriptFromEditor=false]
     * @param {boolean} [activateMainWindow=false]
     * @param {boolean} [reload=false]
+     * @param {boolean} [quitWhenFinished=false]
     * @returns {boolean}
     */
    Q_INVOKABLE ScriptEnginePointer loadScript(const QUrl& scriptFilename = QString(),
-        bool isUserLoaded = true, bool loadScriptFromEditor = false, bool activateMainWindow = false, bool reload = false);
+        bool isUserLoaded = true, bool loadScriptFromEditor = false, bool activateMainWindow = false, bool reload = false, bool quitWhenFinished = false);

    /**jsdoc
     * @function ScriptDiscoveryService.stopScript
@ -266,6 +267,7 @@ protected:
    ScriptEnginePointer reloadScript(const QString& scriptName, bool isUserLoaded = true) { return loadScript(scriptName, isUserLoaded, false, false, true); }
    void removeScriptEngine(ScriptEnginePointer);
    void onScriptEngineLoaded(const QString& scriptFilename);
+    void quitWhenFinished();
    void onScriptEngineError(const QString& scriptFilename);
    void launchScriptEngine(ScriptEnginePointer);

--- a/libraries/script-engine/src/UsersScriptingInterface.h
+++ b/libraries/script-engine/src/UsersScriptingInterface.h
@ -106,10 +106,11 @@ public slots:
    void mute(const QUuid& nodeID);

    /**jsdoc
-    * Get the user name and machine fingerprint associated with the given UUID. This will only do anything if you're an admin 
-    * of the domain you're in.
-    * @function Users.getUsernameFromID
-    * @param {Uuid} nodeID The node or session ID of the user whose username you want.
+    * Request the user name and machine fingerprint associated with the given UUID. The user name will be returned in a 
+    * {@link Users.usernameFromIDReply|usernameFromIDReply} signal. This will only do anything if you're an admin of the domain 
+    * you're in.
+    * @function Users.requestUsernameFromID
+    * @param {Uuid} nodeID The node or session ID of the user whose user name you want.
    */
    void requestUsernameFromID(const QUuid& nodeID);

@ -170,7 +171,8 @@ signals:
    void enteredIgnoreRadius();

    /**jsdoc
-     * Notifies scripts of the user name and machine fingerprint associated with a UUID.
+     * Triggered in response to a {@link Users.requestUsernameFromID|requestUsernameFromID} call. Provides the user name and 
+     * machine fingerprint associated with a UUID.
     * Username and machineFingerprint will be their default constructor output if the requesting user isn't an admin.
     * @function Users.usernameFromIDReply
     * @param {Uuid} nodeID
--- a/libraries/test-utils/CMakeLists.txt
+++ b/libraries/test-utils/CMakeLists.txt
@ -0,0 +1,3 @@
+set(TARGET_NAME test-utils)
+setup_hifi_library(Network Gui)
+
--- a/libraries/test-utils/src/test-utils/FileDownloader.cpp
+++ b/libraries/test-utils/src/test-utils/FileDownloader.cpp
@ -0,0 +1,21 @@
+#include "FileDownloader.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtNetwork/QNetworkReply>
+
+FileDownloader::FileDownloader(QUrl url, const Handler& handler, QObject* parent) : QObject(parent), _handler(handler) {
+    connect(&_accessManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(fileDownloaded(QNetworkReply*)));
+    _accessManager.get(QNetworkRequest(url));
+}
+
+void FileDownloader::waitForDownload() {
+    while (!_complete) {
+        QCoreApplication::processEvents();
+    }
+}
+
+void FileDownloader::fileDownloaded(QNetworkReply* pReply) {
+    _handler(pReply->readAll());
+    pReply->deleteLater();
+    _complete = true;
+}
--- a/libraries/test-utils/src/test-utils/FileDownloader.h
+++ b/libraries/test-utils/src/test-utils/FileDownloader.h
@ -0,0 +1,23 @@
+#pragma once
+
+#include <QtCore/QObject>
+#include <QtNetwork/QNetworkAccessManager>
+
+class FileDownloader : public QObject {
+    Q_OBJECT
+
+public:
+    using Handler = std::function<void(const QByteArray& data)>;
+
+    FileDownloader(QUrl url, const Handler& handler, QObject* parent = 0);
+
+    void waitForDownload();
+
+private slots:
+    void fileDownloaded(QNetworkReply* pReply);
+
+private:
+    QNetworkAccessManager _accessManager;
+    Handler _handler;
+    bool _complete { false };
+};
--- a/libraries/ui-plugins/src/ui-plugins/PluginContainer.h
+++ b/libraries/ui-plugins/src/ui-plugins/PluginContainer.h
@ -54,6 +54,12 @@ public:
    void setFullscreen(const QScreen* targetScreen, bool hideMenu = false);
    void unsetFullscreen(const QScreen* avoidScreen = nullptr);

+    // FIXME remove access tot he menu from the plugin container
+    // Instead let display plugins expose a structure about the kinds
+    // of actions and menu items they want to have appear when they are
+    // active and allow the application to act on that when the display
+    // plugin becomes active (or when the UI is initialized, and a 
+    // display plugin is already active)
    virtual ui::Menu* getPrimaryMenu() = 0;
    virtual void showDisplayPluginsTools(bool show = true) = 0;
    virtual void requestReset() = 0;
--- a/plugins/oculus/src/OculusBaseDisplayPlugin.cpp
+++ b/plugins/oculus/src/OculusBaseDisplayPlugin.cpp
@ -166,12 +166,11 @@ void OculusBaseDisplayPlugin::deactivateSession() {
    //_session = nullptr;
 }
 void OculusBaseDisplayPlugin::updatePresentPose() {
-    //mat4 sensorResetMat;
-    //_currentPresentFrameInfo.sensorSampleTime = ovr_GetTimeInSeconds();
-    //_currentPresentFrameInfo.predictedDisplayTime = ovr_GetPredictedDisplayTime(_session, _currentFrame->frameIndex);
-    //auto trackingState = ovr_GetTrackingState(_session, _currentRenderFrameInfo.predictedDisplayTime, ovrFalse);
-    //_currentPresentFrameInfo.presentPose = toGlm(trackingState.HeadPose.ThePose);
-    _currentPresentFrameInfo.presentPose = _currentPresentFrameInfo.renderPose;
+    _currentPresentFrameInfo.sensorSampleTime = ovr_GetTimeInSeconds();
+    _currentPresentFrameInfo.predictedDisplayTime = ovr_GetPredictedDisplayTime(_session, 0);
+    auto trackingState = ovr_GetTrackingState(_session, _currentRenderFrameInfo.predictedDisplayTime, ovrFalse);
+    _currentPresentFrameInfo.presentPose = toGlm(trackingState.HeadPose.ThePose);
+    _currentPresentFrameInfo.renderPose = _currentPresentFrameInfo.presentPose;
 }

 OculusBaseDisplayPlugin::~OculusBaseDisplayPlugin() {
--- a/scripts/system/+android/radar.js
+++ b/scripts/system/+android/radar.js
@ -346,9 +346,9 @@ function pinchUpdate(event) {
    }

    Camera.position = { 
-        x: Camera.position.x, 
-        y:radarHeight, 
-        z:Camera.position.z 
+        x : Camera.position.x, 
+        y : radarHeight, 
+        z : Camera.position.z 
    };

    if (!draggingCamera) {
@ -360,7 +360,7 @@ function pinchUpdate(event) {
 }

 function isInsideSquare(coords0, coords1, halfside) {
-    return coords0 != undefined && coords1!= undefined &&
+    return coords0 != undefined && coords1 != undefined &&
            Math.abs(coords0.x - coords1.x) <= halfside
            && Math.abs(coords0.y - coords1.y) <= halfside;
 }
@ -372,7 +372,7 @@ function dragScrollUpdate(event) {
    // drag management
    var pickRay = Camera.computePickRay(event.x, event.y);
    var dragAt = Vec3.sum(pickRay.origin, Vec3.multiply(pickRay.direction,
-            radarHeight-MyAvatar.position.y));
+            radarHeight - MyAvatar.position.y));

    if (lastDragAt === undefined || lastDragAt === null) {
        lastDragAt = dragAt;
@ -1082,29 +1082,20 @@ function renderAllOthersAvatarIcons() {
    }
 }

-/*******************************************************************************
- * Entities (to remark) cache structure for showing entities markers
- ******************************************************************************/
-
 var ICON_ENTITY_DEFAULT_DIMENSIONS = {
    x : 0.10,
    y : 0.00001,
    z : 0.10
 };

-var entityIconModelDimensionsVal = {
-    x : 0,
-    y : 0.00001,
-    z : 0
-};
+
 function teleportIconModelDimensions(y) {
-    // given the current height, give a size
-    // TODO: receive entity.position.y and substract to radarHeight
+    var teleportModelDimensions = ICON_ENTITY_DEFAULT_DIMENSIONS;
    var xz = -0.002831 * (radarHeight - y) + 0.1;
-    entityIconModelDimensionsVal.x = xz;
-    entityIconModelDimensionsVal.z = xz;
+    teleportModelDimensions.x = xz;
+    teleportModelDimensions.z = xz;
    // reuse object
-    return entityIconModelDimensionsVal;
+    return teleportModelDimensions;
 }

 /*******************************************************************************
--- a/scripts/system/controllers/controllerModules/farActionGrabEntity.js
+++ b/scripts/system/controllers/controllerModules/farActionGrabEntity.js
@ -564,6 +564,9 @@ Script.include("/~/system/libraries/Xform.js");
                    }
                } else if (this.distanceRotating) {
                    this.distanceRotate(otherFarGrabModule);
+                } else if (this.highlightedEntity) {
+                    Selection.removeFromSelectedItemsList(DISPATCHER_HOVERING_LIST, "entity", this.highlightedEntity);
+                    this.highlightedEntity = null;
                }
            }
            return this.exitIfDisabled(controllerData);
--- a/scripts/system/controllers/controllerModules/mouseHighlightEntities.js
+++ b/scripts/system/controllers/controllerModules/mouseHighlightEntities.js
@ -63,6 +63,9 @@
                            this.highlightedEntity = targetEntityID;
                        }
                    }
+                } else if (this.highlightedEntity) {
+                    dispatcherUtils.unhighlightTargetEntity(this.highlightedEntity);
+                    this.highlightedEntity = null;
                }
            }

--- a/scripts/system/edit.js
+++ b/scripts/system/edit.js
@ -1165,17 +1165,11 @@ function setupModelMenus() {
        });
        modelMenuAddedDelete = true;
    }
-    Menu.addMenuItem({
-        menuName: "Edit",
-        menuItemName: "Entity List...",
-        afterItem: "Entities",
-        grouping: "Advanced"
-    });

    Menu.addMenuItem({
        menuName: "Edit",
        menuItemName: "Parent Entity to Last",
-        afterItem: "Entity List...",
+        afterItem: "Entities",
        grouping: "Advanced"
    });

@ -1297,7 +1291,6 @@ function cleanupModelMenus() {

    Menu.removeMenuItem("Edit", "Parent Entity to Last");
    Menu.removeMenuItem("Edit", "Unparent Entity");
-    Menu.removeMenuItem("Edit", "Entity List...");
    Menu.removeMenuItem("Edit", "Allow Selecting of Large Models");
    Menu.removeMenuItem("Edit", "Allow Selecting of Small Models");
    Menu.removeMenuItem("Edit", "Allow Selecting of Lights");
@ -1659,8 +1652,6 @@ function handeMenuEvent(menuItem) {
            Window.promptTextChanged.connect(onPromptTextChanged);
            Window.promptAsync("URL of SVO to import", "");
        }
-    } else if (menuItem === "Entity List...") {
-        entityListTool.toggleVisible();
    } else if (menuItem === "Select All Entities In Box") {
        selectAllEtitiesInCurrentSelectionBox(false);
    } else if (menuItem === "Select All Entities Touching Box") {
--- a/scripts/system/hmd.js
+++ b/scripts/system/hmd.js
@ -18,7 +18,7 @@
 var headset; // The preferred headset. Default to the first one found in the following list.
 var displayMenuName = "Display";
 var desktopMenuItemName = "Desktop";
-['OpenVR (Vive)', 'Oculus Rift'].forEach(function (name) {
+['HTC Vive', 'Oculus Rift', 'WindowMS'].forEach(function (name) {
    if (!headset && Menu.menuItemExists(displayMenuName, name)) {
        headset = name;
    }
--- a/scripts/system/marketplaces/marketplaces.js
+++ b/scripts/system/marketplaces/marketplaces.js
@ -789,10 +789,14 @@ var selectionDisplay = null; // for gridTool.js to ignore
    var savedDisablePreviewOptionLocked = false;
    var savedDisablePreviewOption = Menu.isOptionChecked("Disable Preview");;
    function maybeEnableHMDPreview() {
-        setTabletVisibleInSecondaryCamera(true);
-        DesktopPreviewProvider.setPreviewDisabledReason("USER");
-        Menu.setIsOptionChecked("Disable Preview", savedDisablePreviewOption);
-        savedDisablePreviewOptionLocked = false;
+        // Set a small timeout to prevent sensitive data from being shown during
+        // UI fade
+        Script.setTimeout(function () {
+            setTabletVisibleInSecondaryCamera(true);
+            DesktopPreviewProvider.setPreviewDisabledReason("USER");
+            Menu.setIsOptionChecked("Disable Preview", savedDisablePreviewOption);
+            savedDisablePreviewOptionLocked = false;
+        }, 150);
    }

    // Function Name: fromQml()
--- a/tests-manual/CMakeLists.txt
+++ b/tests-manual/CMakeLists.txt
@ -0,0 +1,8 @@
+# add the manual test directories
+file(GLOB TEST_SUBDIRS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/*")
+foreach(DIR ${TEST_SUBDIRS})
+  if((IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${DIR}") AND (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${DIR}/CMakeLists.txt"))
+    set(TEST_PROJ_NAME ${DIR})
+    add_subdirectory(${DIR})
+  endif()
+endforeach()
--- a/tests-manual/controllers/CMakeLists.txt
+++ b/tests-manual/controllers/CMakeLists.txt
--- a/tests-manual/controllers/qml/main.qml
+++ b/tests-manual/controllers/qml/main.qml
--- a/tests-manual/controllers/src/main.cpp
+++ b/tests-manual/controllers/src/main.cpp
--- a/tests-manual/entities/CMakeLists.txt
+++ b/tests-manual/entities/CMakeLists.txt
--- a/tests-manual/entities/packet.bin
+++ b/tests-manual/entities/packet.bin
--- a/tests-manual/entities/src/main.cpp
+++ b/tests-manual/entities/src/main.cpp
--- a/tests-manual/gl/CMakeLists.txt
+++ b/tests-manual/gl/CMakeLists.txt
--- a/tests-manual/gl/src/main.cpp
+++ b/tests-manual/gl/src/main.cpp
--- a/tests-manual/gpu-textures/CMakeLists.txt
+++ b/tests-manual/gpu-textures/CMakeLists.txt
@ -0,0 +1,16 @@
+set(TARGET_NAME gpu-textures-tests)
+AUTOSCRIBE_SHADER_LIB(gpu graphics render-utils)
+# This is not a testcase -- just set it up as a regular hifi project
+setup_hifi_project(Quick Gui Script)
+setup_memory_debugger()
+set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
+link_hifi_libraries(
+    shared task networking gl 
+    ktx gpu octree  
+    ${PLATFORM_GL_BACKEND}
+)
+
+set(EXTRA_DEPLOY_OPTIONS "--qmldir  \"${PROJECT_SOURCE_DIR}/qml\"")
+package_libraries_for_deployment()
+
+target_nsight()
--- a/tests-manual/gpu-textures/qml/textureStats.qml
+++ b/tests-manual/gpu-textures/qml/textureStats.qml
@ -0,0 +1,52 @@
+import QtQuick 2.5
+import QtQuick.Controls 2.3
+
+Item {
+    width: 400
+    height: 600
+
+    Column {
+        spacing: 10
+        anchors.top: parent.top
+        anchors.left: parent.left
+        anchors.margins: 10
+
+        Text { text: qsTr("Total") }
+        Text { text: Stats.total + " MB" }
+        Text { text: qsTr("Allocated") }
+        Text { text: Stats.allocated }
+        Text { text: qsTr("Populated") }
+        Text { text: Stats.populated }
+        Text { text: qsTr("Pending") }
+        Text { text: Stats.pending }
+        Text { text: qsTr("Current Index") }
+        Text { text: Stats.index }
+        Text { text: qsTr("Current Source") }
+        Text { text: Stats.source }
+        Text { text: qsTr("Current Rez") }
+        Text { text: Stats.rez.width + " x " + Stats.rez.height }
+    }
+
+    Row {
+        id: row1
+        spacing: 10
+        anchors.bottom: row2.top
+        anchors.left: parent.left
+        anchors.margins: 10
+        Button { text: "1024"; onClicked: Stats.maxTextureMemory(1024); }
+        Button { text: "256"; onClicked: Stats.maxTextureMemory(256); }
+    }
+
+    Row {
+        id: row2
+        spacing: 10
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.margins: 10
+        Button { text: "Change Textures"; onClicked: Stats.changeTextures(); }
+        Button { text: "Next"; onClicked: Stats.nextTexture(); }
+        Button { text: "Previous"; onClicked: Stats.prevTexture(); }
+    }
+
+}
+
--- a/tests-manual/gpu-textures/src/TestHelpers.cpp
+++ b/tests-manual/gpu-textures/src/TestHelpers.cpp
@ -0,0 +1,26 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "TestHelpers.h"
+#include <QtCore/QFileInfo>
+
+gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings) {
+    auto vs = gpu::Shader::createVertex(vertexShaderSrc);
+    auto fs = gpu::Shader::createPixel(fragmentShaderSrc);
+    auto shader = gpu::Shader::createProgram(vs, fs);
+    if (!gpu::Shader::makeProgram(*shader, bindings)) {
+        printf("Could not compile shader\n");
+        exit(-1);
+    }
+    return shader;
+}
+
+QString projectRootDir() {
+    static QString projectRootPath = QFileInfo(QFileInfo(__FILE__).absolutePath() + "/..").absoluteFilePath();
+    return projectRootPath;
+}
--- a/tests-manual/gpu-textures/src/TestHelpers.h
+++ b/tests-manual/gpu-textures/src/TestHelpers.h
@ -0,0 +1,40 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include <vector>
+
+#include <GLMHelpers.h>
+#include <Transform.h>
+#include <NumericalConstants.h>
+
+#include <gpu/Resource.h>
+#include <gpu/Forward.h>
+#include <gpu/Shader.h>
+#include <gpu/Stream.h>
+
+struct RenderArgs {
+    gpu::ContextPointer _context;
+    ivec4 _viewport;
+    gpu::Batch* _batch;
+};
+
+class GpuTestBase : public QObject {
+public:
+    virtual ~GpuTestBase() {}
+    virtual bool isReady() const { return true; }
+    virtual size_t getTestCount() const { return 1; }
+    virtual void renderTest(size_t test, const RenderArgs& args) = 0;
+    virtual QObject * statsObject() { return nullptr; }
+    virtual QUrl statUrl() { return QUrl(); }
+};
+
+uint32_t toCompactColor(const glm::vec4& color);
+gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings);
+QString projectRootDir();
--- a/tests-manual/gpu-textures/src/TestTextures.cpp
+++ b/tests-manual/gpu-textures/src/TestTextures.cpp
@ -0,0 +1,166 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "TestTextures.h"
+
+#include <random>
+#include <algorithm>
+
+#include <QtCore/QDir>
+#include <QtQuick/QQuickView>
+#include <QtQml/QQmlContext>
+#include <gpu/Batch.h>
+#include <gpu/Context.h>
+
+#include "TestHelpers.h"
+
+std::string vertexShaderSource = R"SHADER(
+#line 14
+layout(location = 0) out vec2 outTexCoord0;
+
+const vec4 VERTICES[] = vec4[](
+    vec4(-1.0, -1.0, 0.0, 1.0), 
+    vec4( 1.0, -1.0, 0.0, 1.0),    
+    vec4(-1.0,  1.0, 0.0, 1.0),
+    vec4( 1.0,  1.0, 0.0, 1.0)
+);   
+
+void main() {
+    outTexCoord0 = VERTICES[gl_VertexID].xy;
+    outTexCoord0 += 1.0;
+    outTexCoord0 /= 2.0;
+    gl_Position = VERTICES[gl_VertexID];
+}
+)SHADER";
+
+std::string fragmentShaderSource = R"SHADER(
+#line 28
+
+uniform sampler2D tex;
+
+layout(location = 0) in vec2 inTexCoord0;
+layout(location = 0) out vec4 outFragColor;
+
+void main() {
+    outFragColor = texture(tex, inTexCoord0);
+    outFragColor.a = 1.0;
+    //outFragColor.rb = inTexCoord0;
+}
+
+)SHADER";
+
+#define STAT_UPDATE(name, src) \
+    { \
+        auto val = src; \
+        if (_##name != val) { \
+            _##name = val; \
+            emit name##Changed(); \
+        } \
+    }
+
+
+void TextureTestStats::update(int curIndex, const gpu::TexturePointer& texture) {
+    STAT_UPDATE(total, (int)BYTES_TO_MB(gpu::Context::getTextureGPUMemSize()));
+    STAT_UPDATE(allocated, (int)gpu::Context::getTextureResourceGPUMemSize());
+    STAT_UPDATE(pending, (int)gpu::Context::getTexturePendingGPUTransferMemSize());
+    STAT_UPDATE(populated, (int)gpu::Context::getTextureResourcePopulatedGPUMemSize());
+    STAT_UPDATE(source, texture->source().c_str());
+    STAT_UPDATE(index, curIndex);
+    auto dims = texture->getDimensions();
+    STAT_UPDATE(rez, QSize(dims.x, dims.y));
+}
+
+TexturesTest::TexturesTest() {
+    connect(&stats, &TextureTestStats::changeTextures, this, &TexturesTest::onChangeTextures);
+    connect(&stats, &TextureTestStats::nextTexture, this, &TexturesTest::onNextTexture);
+    connect(&stats, &TextureTestStats::prevTexture, this, &TexturesTest::onPrevTexture);
+    connect(&stats, &TextureTestStats::maxTextureMemory, this, &TexturesTest::onMaxTextureMemory);
+    {
+        auto VS = gpu::Shader::createVertex(vertexShaderSource);
+        auto PS = gpu::Shader::createPixel(fragmentShaderSource);
+        auto program = gpu::Shader::createProgram(VS, PS);
+        gpu::Shader::BindingSet slotBindings;
+        gpu::Shader::makeProgram(*program, slotBindings);
+        // If the pipeline did not exist, make it
+        auto state = std::make_shared<gpu::State>();
+        state->setCullMode(gpu::State::CULL_NONE);
+        state->setDepthTest({});
+        state->setBlendFunction({ false });
+        pipeline = gpu::Pipeline::create(program, state);
+    }
+
+    onChangeTextures();
+}
+
+
+void TexturesTest::renderTest(size_t testId, const RenderArgs& args) {
+    stats.update((int)index, textures[index]);
+    gpu::Batch& batch = *(args._batch);
+    batch.setPipeline(pipeline);
+    batch.setInputFormat(vertexFormat);
+    for (const auto& texture : textures) {
+        batch.setResourceTexture(0, texture);
+        batch.draw(gpu::TRIANGLE_STRIP, 4, 0);
+    }
+    batch.setResourceTexture(0, textures[index]);
+    batch.draw(gpu::TRIANGLE_STRIP, 4, 0);
+}
+
+#define LOAD_TEXTURE_COUNT 64
+
+void TexturesTest::onChangeTextures() {
+    static const QDir TEST_DIR("D:/ktx_texture_test");
+    static std::vector<std::string> ALL_TEXTURE_FILES;
+    if (ALL_TEXTURE_FILES.empty()) {
+        auto entryList = TEST_DIR.entryList({ "*.ktx" }, QDir::Filter::Files);
+        ALL_TEXTURE_FILES.reserve(entryList.size());
+        for (auto entry : entryList) {
+            auto textureFile = TEST_DIR.absoluteFilePath(entry).toStdString();
+            ALL_TEXTURE_FILES.push_back(textureFile);
+        }
+    }
+
+    oldTextures.clear();
+    oldTextures.swap(textures);
+
+#if 0
+    static const std::string bad = "D:/ktx_texture_test/b4beed38675dbc7a827ecd576399c1f4.ktx";
+    auto texture = gpu::Texture::unserialize(bad);
+    auto texelFormat = texture->getTexelFormat();
+    qDebug() << texture->getTexelFormat().getSemantic();
+    qDebug() << texture->getTexelFormat().getScalarCount();
+    textures.push_back(texture);
+#else
+    std::shuffle(ALL_TEXTURE_FILES.begin(), ALL_TEXTURE_FILES.end(), std::default_random_engine());
+    size_t newTextureCount = std::min<size_t>(ALL_TEXTURE_FILES.size(), LOAD_TEXTURE_COUNT);
+    for (size_t i = 0; i < newTextureCount; ++i) {
+        const auto& textureFile = ALL_TEXTURE_FILES[i];
+        auto texture = gpu::Texture::unserialize(textureFile);
+        qDebug() << textureFile.c_str();
+        qDebug() << texture->getTexelFormat().getSemantic();
+        qDebug() << texture->getTexelFormat().getScalarCount();
+        textures.push_back(texture);
+    }
+#endif
+    index = 0;
+    qDebug() << "Done";
+}
+
+void TexturesTest::onNextTexture() {
+    index += textures.size() + 1;
+    index %= textures.size();
+}
+
+void TexturesTest::onPrevTexture() {
+    index += textures.size() - 1;
+    index %= textures.size();
+}
+
+void TexturesTest::onMaxTextureMemory(int maxTextureMemory) {
+    gpu::Texture::setAllowedGPUMemoryUsage(MB_TO_BYTES(maxTextureMemory));
+}
--- a/tests-manual/gpu-textures/src/TestTextures.h
+++ b/tests-manual/gpu-textures/src/TestTextures.h
@ -0,0 +1,74 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+#pragma once
+
+#include "TestHelpers.h"
+
+#define STATS_PROPERTY(type, name, initialValue) \
+    Q_PROPERTY(type name READ name NOTIFY name##Changed) \
+public: \
+    type name() { return _##name; }; \
+private: \
+    type _##name{ initialValue };
+
+
+class TextureTestStats : public QObject {
+    Q_OBJECT;
+    STATS_PROPERTY(int, pending, 0)
+    STATS_PROPERTY(int, total, 0)
+    STATS_PROPERTY(int, populated, 0)
+    STATS_PROPERTY(int, allocated, 0)
+    STATS_PROPERTY(int, index, 0)
+
+    STATS_PROPERTY(QString, source, QString())
+    STATS_PROPERTY(QSize, rez, QSize(0, 0))
+
+public:
+    void update(int index, const gpu::TexturePointer& texture);
+
+signals:
+    void pendingChanged();
+    void totalChanged();
+    void populatedChanged();
+    void allocatedChanged();
+    void changeTextures();
+    void rezChanged();
+    void indexChanged();
+    void sourceChanged();
+    void maxTextureMemory(int);
+
+    void nextTexture();
+    void prevTexture();
+};
+
+
+class TexturesTest : public GpuTestBase {
+    Q_OBJECT
+
+    gpu::Stream::FormatPointer vertexFormat { std::make_shared<gpu::Stream::Format>() };
+    std::vector<gpu::TexturePointer> textures;
+    std::vector<gpu::TexturePointer> oldTextures;
+    gpu::PipelinePointer pipeline;
+    TextureTestStats stats;
+    size_t index{ 0 };
+
+public:
+    TexturesTest();
+    QObject* statsObject() override { return &stats; }
+    QUrl statUrl() override { return QUrl::fromLocalFile(projectRootDir() + "/qml/textureStats.qml"); }
+    void renderTest(size_t testId, const RenderArgs& args) override;
+
+protected slots:
+    void onChangeTextures();
+    void onMaxTextureMemory(int newValue);
+    void onNextTexture();
+    void onPrevTexture();
+
+};
+
+
--- a/tests-manual/gpu-textures/src/TestWindow.cpp
+++ b/tests-manual/gpu-textures/src/TestWindow.cpp
@ -0,0 +1,117 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "TestWindow.h"
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <QtCore/QTimer>
+#include <QtGui/QResizeEvent>
+
+#include <gl/GLHelpers.h>
+
+#include <gpu/gl/GLBackend.h>
+
+TestWindow::TestWindow() {
+
+    auto timer = new QTimer(this);
+    timer->setTimerType(Qt::PreciseTimer);
+    timer->setInterval(5);
+    connect(timer, &QTimer::timeout, [&] { draw(); });
+    timer->start();
+
+    connect(qApp, &QCoreApplication::aboutToQuit, [this, timer] {
+        timer->stop();
+        _aboutToQuit = true;
+    });
+
+    setSurfaceType(QSurface::OpenGLSurface);
+
+    QSurfaceFormat format = getDefaultOpenGLSurfaceFormat();
+    format.setOption(QSurfaceFormat::DebugContext);
+    setFormat(format);
+    _glContext.setFormat(format);
+    _glContext.create();
+    _glContext.makeCurrent(this);
+
+    show();
+}
+
+void TestWindow::initGl() {
+    _glContext.makeCurrent(this);
+    gl::initModuleGl();
+    gpu::Context::init<gpu::gl::GLBackend>();
+    _renderArgs->_context = std::make_shared<gpu::Context>();
+    _glContext.makeCurrent(this);
+    resize(QSize(800, 600));
+}
+
+void TestWindow::resizeWindow(const QSize& size) {
+    _size = size;
+    _renderArgs->_viewport = ivec4(0, 0, _size.width(), _size.height());
+}
+
+void TestWindow::beginFrame() {
+    _renderArgs->_context->recycle();
+    _renderArgs->_context->beginFrame();
+    gpu::doInBatch("TestWindow::beginFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
+        batch.clearDepthFramebuffer(1e4);
+        batch.setViewportTransform({ 0, 0, _size.width() * devicePixelRatio(), _size.height() * devicePixelRatio() });
+    });
+
+    gpu::doInBatch("TestWindow::beginFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.setViewportTransform(_renderArgs->_viewport);
+        batch.setStateScissorRect(_renderArgs->_viewport);
+        batch.setProjectionTransform(_projectionMatrix);
+    });
+}
+
+void TestWindow::endFrame() {
+    gpu::doInBatch("TestWindow::endFrame::finish", _renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.resetStages();
+    });
+    auto framePointer = _renderArgs->_context->endFrame();
+    _renderArgs->_context->consumeFrameUpdates(framePointer);
+    _renderArgs->_context->executeFrame(framePointer);
+    _glContext.swapBuffers(this);
+}
+
+void TestWindow::draw() {
+    if (_aboutToQuit) {
+        return;
+    }
+
+    // Attempting to draw before we're visible and have a valid size will
+    // produce GL errors.
+    if (!isVisible() || _size.width() <= 0 || _size.height() <= 0) {
+        return;
+    }
+
+    if (!_glContext.makeCurrent(this)) {
+        return;
+    }
+
+    static std::once_flag once;
+    std::call_once(once, [&] { initGl(); });
+    beginFrame();
+
+    renderFrame();
+
+    endFrame();
+}
+
+void TestWindow::resizeEvent(QResizeEvent* ev) {
+    resizeWindow(ev->size());
+    float fov_degrees = 60.0f;
+    float aspect_ratio = (float)_size.width() / _size.height();
+    float near_clip = 0.1f;
+    float far_clip = 1000.0f;
+    _projectionMatrix = glm::perspective(glm::radians(fov_degrees), aspect_ratio, near_clip, far_clip);
+}
--- a/tests-manual/gpu-textures/src/TestWindow.h
+++ b/tests-manual/gpu-textures/src/TestWindow.h
@ -0,0 +1,41 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include <QtGui/QWindow>
+#include <QtCore/QTime>
+
+#include <GLMHelpers.h>
+#include <gl/QOpenGLContextWrapper.h>
+#include <gpu/Forward.h>
+#include "TestHelpers.h"
+
+#define DEFERRED_LIGHTING
+
+class TestWindow : public QWindow {
+protected:
+    QOpenGLContextWrapper _glContext;
+    QSize _size;
+    glm::mat4 _projectionMatrix;
+    bool _aboutToQuit { false };
+    std::shared_ptr<RenderArgs> _renderArgs{ std::make_shared<RenderArgs>() };
+
+    TestWindow();
+    virtual void initGl();
+    virtual void renderFrame() = 0;
+
+private:
+    void resizeWindow(const QSize& size);
+
+    void beginFrame();
+    void endFrame();
+    void draw();
+    void resizeEvent(QResizeEvent* ev) override;
+};
+
--- a/tests-manual/gpu-textures/src/main.cpp
+++ b/tests-manual/gpu-textures/src/main.cpp
@ -0,0 +1,170 @@
+//
+//  main.cpp
+//  tests/gpu-test/src
+//
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include <unordered_map>
+#include <memory>
+#include <cstdio>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <QtCore/QTime>
+#include <QtCore/QTimer>
+#include <QtCore/QDir>
+#include <QtCore/QElapsedTimer>
+#include <QtCore/QFile>
+#include <QtCore/QLoggingCategory>
+
+#include <QtGui/QDesktopServices>
+#include <QtGui/QResizeEvent>
+#include <QtGui/QWindow>
+#include <QtGui/QGuiApplication>
+#include <QtGui/QImage>
+#include <QtGui/QScreen>
+
+#include <QtWidgets/QApplication>
+
+#include <gl/Config.h>
+
+#include <QtQuick/QQuickWindow>
+#include <QtQuick/QQuickView>
+#include <QtQml/QQmlContext>
+
+#include <gpu/Context.h>
+#include <gpu/Batch.h>
+#include <gpu/Stream.h>
+#include <gpu/gl/GLBackend.h>
+
+#include <gl/QOpenGLContextWrapper.h>
+#include <gl/GLHelpers.h>
+
+#include <GLMHelpers.h>
+#include <PathUtils.h>
+#include <NumericalConstants.h>
+
+#include <PerfStat.h>
+#include <PathUtils.h>
+#include <SharedUtil.h>
+#include <ViewFrustum.h>
+
+#include <gpu/Pipeline.h>
+#include <gpu/Context.h>
+
+#include "TestWindow.h"
+#include "TestTextures.h"
+
+using TestBuilder = std::function<GpuTestBase*()>;
+using TestBuilders = std::list<TestBuilder>;
+
+#define INTERACTIVE
+
+class MyTestWindow : public TestWindow {
+    using Parent = TestWindow;
+    TestBuilders _testBuilders;
+    GpuTestBase* _currentTest{ nullptr };
+    size_t _currentTestId{ 0 };
+    size_t _currentMaxTests{ 0 };
+    glm::mat4 _camera;
+    QTime _time;
+
+    void initGl() override {
+        Parent::initGl();
+        _time.start();
+        updateCamera();
+        _testBuilders = TestBuilders({
+            [] { return new TexturesTest(); },
+        });
+    }
+
+    void updateCamera() {
+        float t = _time.elapsed() * 1e-3f;
+        glm::vec3 unitscale{ 1.0f };
+        glm::vec3 up{ 0.0f, 1.0f, 0.0f };
+
+        float distance = 3.0f;
+        glm::vec3 camera_position{ distance * sinf(t), 0.5f, distance * cosf(t) };
+
+        static const vec3 camera_focus(0);
+        static const vec3 camera_up(0, 1, 0);
+        _camera = glm::inverse(glm::lookAt(camera_position, camera_focus, up));
+
+        ViewFrustum frustum;
+        frustum.setPosition(camera_position);
+        frustum.setOrientation(glm::quat_cast(_camera));
+        frustum.setProjection(_projectionMatrix);
+    }
+
+    void renderFrame() override {
+        updateCamera();
+
+        while ((!_currentTest || (_currentTestId >= _currentMaxTests)) && !_testBuilders.empty()) {
+            if (_currentTest) {
+                delete _currentTest;
+                _currentTest = nullptr;
+            }
+
+            _currentTest = _testBuilders.front()();
+            _testBuilders.pop_front();
+
+            if (_currentTest) {
+                auto statsObject = _currentTest->statsObject();
+                QUrl url = _currentTest->statUrl();
+                if (statsObject) {
+                    auto screens = qApp->screens();
+                    auto primaryScreen = qApp->primaryScreen();
+                    auto targetScreen = primaryScreen;
+                    for (const auto& screen : screens) {
+                        if (screen == primaryScreen) {
+                            continue;
+                        }
+                        targetScreen = screen;
+                        break;
+                    }
+
+                    auto destPoint = targetScreen->availableGeometry().topLeft();
+                    QQuickView* view = new QQuickView();
+                    view->rootContext()->setContextProperty("Stats", statsObject);
+                    view->setSource(url);
+                    view->show();
+                    view->setPosition({ destPoint.x() + 100, destPoint.y() + 100 });
+                }
+                _currentMaxTests = _currentTest->getTestCount();
+                _currentTestId = 0;
+            }
+        }
+
+        if (!_currentTest && _testBuilders.empty()) {
+            qApp->quit();
+            return;
+        }
+
+        // Tests might need to wait for resources to download
+        if (!_currentTest->isReady()) {
+            return;
+        }
+
+        gpu::doInBatch("main::renderFrame", _renderArgs->_context, [&](gpu::Batch& batch) {
+            batch.setViewTransform(_camera);
+            _renderArgs->_batch = &batch;
+            _currentTest->renderTest(_currentTestId, *_renderArgs);
+            _renderArgs->_batch = nullptr;
+        });
+    }
+};
+
+int main(int argc, char** argv) {
+    setupHifiApplication("GPU Test");
+    qputenv("HIFI_DEBUG_OPENGL", QByteArray("1"));
+    QApplication app(argc, argv);
+    MyTestWindow window;
+    app.exec();
+
+    return 0;
+}
--- a/tests-manual/gpu/CMakeLists.txt
+++ b/tests-manual/gpu/CMakeLists.txt
--- a/tests-manual/gpu/src/TestFbx.cpp
+++ b/tests-manual/gpu/src/TestFbx.cpp
--- a/tests-manual/gpu/src/TestFbx.h
+++ b/tests-manual/gpu/src/TestFbx.h
--- a/tests-manual/gpu/src/TestFloorGrid.cpp
+++ b/tests-manual/gpu/src/TestFloorGrid.cpp
--- a/tests-manual/gpu/src/TestFloorGrid.h
+++ b/tests-manual/gpu/src/TestFloorGrid.h
--- a/tests-manual/gpu/src/TestFloorTexture.cpp
+++ b/tests-manual/gpu/src/TestFloorTexture.cpp
--- a/tests-manual/gpu/src/TestFloorTexture.h
+++ b/tests-manual/gpu/src/TestFloorTexture.h
--- a/tests-manual/gpu/src/TestHelpers.cpp
+++ b/tests-manual/gpu/src/TestHelpers.cpp
--- a/tests-manual/gpu/src/TestHelpers.h
+++ b/tests-manual/gpu/src/TestHelpers.h
--- a/tests-manual/gpu/src/TestInstancedShapes.cpp
+++ b/tests-manual/gpu/src/TestInstancedShapes.cpp
--- a/tests-manual/gpu/src/TestInstancedShapes.h
+++ b/tests-manual/gpu/src/TestInstancedShapes.h
--- a/tests-manual/gpu/src/TestShapes.cpp
+++ b/tests-manual/gpu/src/TestShapes.cpp
--- a/tests-manual/gpu/src/TestShapes.h
+++ b/tests-manual/gpu/src/TestShapes.h
--- a/tests-manual/gpu/src/TestWindow.cpp
+++ b/tests-manual/gpu/src/TestWindow.cpp
--- a/tests-manual/gpu/src/TestWindow.h
+++ b/tests-manual/gpu/src/TestWindow.h
--- a/tests-manual/gpu/src/main.cpp
+++ b/tests-manual/gpu/src/main.cpp
--- a/tests-manual/qml/CMakeLists.txt
+++ b/tests-manual/qml/CMakeLists.txt
--- a/Show more
+++ b/Show more