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

2025-03-27 23:52:03 +01:00 · 2017-06-19 13:53:29 -07:00 · 2017-06-19 13:53:29 -07:00 · cbdffce88e
commit cbdffce88e
parent 5245237bb2 ed6620fc51
125 changed files with 683 additions and 663 deletions
--- a/assignment-client/src/Agent.h
+++ b/assignment-client/src/Agent.h
@ -23,7 +23,6 @@

 #include <EntityEditPacketSender.h>
 #include <EntityTree.h>
-#include <EntityTreeHeadlessViewer.h>
 #include <ScriptEngine.h>
 #include <ThreadedAssignment.h>

@ -31,6 +30,7 @@

 #include "AudioGate.h"
 #include "MixedAudioStream.h"
+#include "entities/EntityTreeHeadlessViewer.h"
 #include "avatars/ScriptableAvatar.h"

 class Agent : public ThreadedAssignment {
--- a/assignment-client/src/entities/EntityTreeHeadlessViewer.cpp
+++ b/assignment-client/src/entities/EntityTreeHeadlessViewer.cpp
--- a/assignment-client/src/entities/EntityTreeHeadlessViewer.h
+++ b/assignment-client/src/entities/EntityTreeHeadlessViewer.h
@ -16,9 +16,9 @@
 #include <SharedUtil.h>
 #include <Octree.h>
 #include <OctreePacketData.h>
-#include <OctreeHeadlessViewer.h>
 #include <ViewFrustum.h>

+#include "../octree/OctreeHeadlessViewer.h"
 #include "EntityTree.h"

 class EntitySimulation;
--- a/assignment-client/src/octree/OctreeHeadlessViewer.cpp
+++ b/assignment-client/src/octree/OctreeHeadlessViewer.cpp
@ -9,17 +9,14 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#include <NodeList.h>
-
-#include "OctreeLogging.h"
 #include "OctreeHeadlessViewer.h"

-OctreeHeadlessViewer::OctreeHeadlessViewer() : OctreeRenderer() {
-    _viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
-}
+#include <NodeList.h>
+#include <OctreeLogging.h>

-void OctreeHeadlessViewer::init() {
-    OctreeRenderer::init();
+
+OctreeHeadlessViewer::OctreeHeadlessViewer() {
+    _viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
 }

 void OctreeHeadlessViewer::queryOctree() {
--- a/assignment-client/src/octree/OctreeHeadlessViewer.h
+++ b/assignment-client/src/octree/OctreeHeadlessViewer.h
@ -12,28 +12,17 @@
 #ifndef hifi_OctreeHeadlessViewer_h
 #define hifi_OctreeHeadlessViewer_h

-#include <udt/PacketHeaders.h>
-#include <SharedUtil.h>
-#include <ViewFrustum.h>
+#include <OctreeProcessor.h>
+#include <JurisdictionListener.h>
+#include <OctreeQuery.h>

-#include "JurisdictionListener.h"
-#include "Octree.h"
-#include "OctreeConstants.h"
-#include "OctreeQuery.h"
-#include "OctreeRenderer.h"
-#include "OctreeSceneStats.h"
-#include "Octree.h"

 // Generic client side Octree renderer class.
-class OctreeHeadlessViewer : public OctreeRenderer {
+class OctreeHeadlessViewer : public OctreeProcessor {
    Q_OBJECT
 public:
    OctreeHeadlessViewer();
    virtual ~OctreeHeadlessViewer() {};
-    virtual void renderElement(OctreeElementPointer element, RenderArgs* args) override { /* swallow these */ }
-
-    virtual void init() override ;
-    virtual void render(RenderArgs* renderArgs) override { /* swallow these */ }

    void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }
    
@ -71,6 +60,7 @@ private:
    JurisdictionListener* _jurisdictionListener = nullptr;
    OctreeQuery _octreeQuery;

+    ViewFrustum _viewFrustum;
    float _voxelSizeScale { DEFAULT_OCTREE_SIZE_SCALE };
    int _boundaryLevelAdjust { 0 };
    int _maxPacketsPerSecond { DEFAULT_MAX_OCTREE_PPS };
--- a/assignment-client/src/scripts/EntityScriptServer.h
+++ b/assignment-client/src/scripts/EntityScriptServer.h
@ -19,10 +19,10 @@
 #include <QtCore/QUuid>

 #include <EntityEditPacketSender.h>
-#include <EntityTreeHeadlessViewer.h>
 #include <plugins/CodecPlugin.h>
 #include <ScriptEngine.h>
 #include <ThreadedAssignment.h>
+#include "../entities/EntityTreeHeadlessViewer.h"

 class EntityScriptServer : public ThreadedAssignment {
    Q_OBJECT
--- a/cmake/macros/LinkHifiLibraries.cmake
+++ b/cmake/macros/LinkHifiLibraries.cmake
@ -7,16 +7,18 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 

-macro(LINK_HIFI_LIBRARIES)
+function(LINK_HIFI_LIBRARIES)
  
  file(RELATIVE_PATH RELATIVE_LIBRARY_DIR_PATH ${CMAKE_CURRENT_SOURCE_DIR} "${HIFI_LIBRARY_DIR}")
  
  set(LIBRARIES_TO_LINK ${ARGN})
-  
-  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})    
+  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})
    if (NOT TARGET ${HIFI_LIBRARY})
      add_subdirectory("${RELATIVE_LIBRARY_DIR_PATH}/${HIFI_LIBRARY}" "${RELATIVE_LIBRARY_DIR_PATH}/${HIFI_LIBRARY}")
    endif ()
+  endforeach()
+
+  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})
  
    include_directories("${HIFI_LIBRARY_DIR}/${HIFI_LIBRARY}/src")
    include_directories("${CMAKE_BINARY_DIR}/libraries/${HIFI_LIBRARY}/shaders")
@ -29,4 +31,4 @@ macro(LINK_HIFI_LIBRARIES)

  setup_memory_debugger()

-endmacro(LINK_HIFI_LIBRARIES)
+endfunction()
--- a/domain-server/resources/describe-settings.json
+++ b/domain-server/resources/describe-settings.json
@ -147,6 +147,7 @@
    {
      "name": "security",
      "label": "Security",
+      "restart": false,
      "settings": [
        {
          "name": "http_username",
--- a/domain-server/resources/web/settings/index.shtml
+++ b/domain-server/resources/web/settings/index.shtml
@ -26,7 +26,7 @@
        </ul>

        <button id="advanced-toggle-button" class="btn btn-info advanced-toggle">Show advanced</button>
-        <button class="btn btn-success save-button">Save and restart</button>
+        <button class="btn btn-success save-button">Save</button>
      </div>
    </div>

@ -77,7 +77,7 @@
  </div>

  <div class="col-xs-12 hidden-sm hidden-md hidden-lg">
-    <button class="btn btn-success save-button" id="small-save-button">Save and restart</button>
+    <button class="btn btn-success save-button" id="small-save-button">Save</button>
  </div>
 </div>

--- a/domain-server/resources/web/settings/js/settings.js
+++ b/domain-server/resources/web/settings/js/settings.js
@ -1328,6 +1328,18 @@ function makeTableCategoryInput(setting, numVisibleColumns) {
  return html;
 }

+function getDescriptionForKey(key) {
+  for (var i in Settings.data.descriptions) {
+    if (Settings.data.descriptions[i].name === key) {
+      return Settings.data.descriptions[i];
+    }
+  }
+}
+
+var SAVE_BUTTON_LABEL_SAVE = "Save";
+var SAVE_BUTTON_LABEL_RESTART = "Save and restart";
+var reasonsForRestart = [];
+
 function badgeSidebarForDifferences(changedElement) {
  // figure out which group this input is in
  var panelParentID = changedElement.closest('.panel').attr('id');
@ -1350,13 +1362,24 @@ function badgeSidebarForDifferences(changedElement) {
  }

  var badgeValue = 0
+  var description = getDescriptionForKey(panelParentID);

  // badge for any settings we have that are not the same or are not present in initialValues
  for (var setting in panelJSON) {
    if ((!_.has(initialPanelJSON, setting) && panelJSON[setting] !== "") ||
      (!_.isEqual(panelJSON[setting], initialPanelJSON[setting])
      && (panelJSON[setting] !== "" || _.has(initialPanelJSON, setting)))) {
-      badgeValue += 1
+      badgeValue += 1;
+
+      // add a reason to restart
+      if (description && description.restart != false) {
+        reasonsForRestart.push(setting);
+      }
+    } else {
+        // remove a reason to restart
+        if (description && description.restart != false) {
+          reasonsForRestart = $.grep(reasonsForRestart, function(v) { return v != setting; });
+      }
    }
  }

@ -1365,6 +1388,7 @@ function badgeSidebarForDifferences(changedElement) {
    badgeValue = ""
  }

+  $(".save-button").html(reasonsForRestart.length > 0 ? SAVE_BUTTON_LABEL_RESTART : SAVE_BUTTON_LABEL_SAVE);
  $("a[href='#" + panelParentID + "'] .badge").html(badgeValue);
 }

--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -581,7 +581,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
    _undoStackScriptingInterface(&_undoStack),
    _entitySimulation(new PhysicalEntitySimulation()),
    _physicsEngine(new PhysicsEngine(Vectors::ZERO)),
-    _entityClipboardRenderer(false, this, this),
    _entityClipboard(new EntityTree()),
    _lastQueriedTime(usecTimestampNow()),
    _previousScriptLocation("LastScriptLocation", DESKTOP_LOCATION),
@ -3989,11 +3988,6 @@ void Application::init() {
    DependencyManager::get<NodeList>()->sendDomainServerCheckIn();

    getEntities()->init();
-    {
-        QMutexLocker viewLocker(&_viewMutex);
-        getEntities()->setViewFrustum(_viewFrustum);
-    }
-
    getEntities()->setEntityLoadingPriorityFunction([this](const EntityItem& item) {
        auto dims = item.getDimensions();
        auto maxSize = glm::compMax(dims);
@ -4023,13 +4017,6 @@ void Application::init() {
    // of events related clicking, hovering over, and entering entities
    getEntities()->connectSignalsToSlots(entityScriptingInterface.data());

-    _entityClipboardRenderer.init();
-    {
-        QMutexLocker viewLocker(&_viewMutex);
-        _entityClipboardRenderer.setViewFrustum(_viewFrustum);
-    }
-    _entityClipboardRenderer.setTree(_entityClipboard);
-
    // Make sure any new sounds are loaded as soon as know about them.
    connect(tree.get(), &EntityTree::newCollisionSoundURL, this, [this](QUrl newURL, EntityItemID id) {
        EntityTreePointer tree = getEntities()->getTree();
@ -5022,9 +5009,6 @@ QRect Application::getDesirableApplicationGeometry() const {
    return applicationGeometry;
 }

-// FIXME, preprocessor guard this check to occur only in DEBUG builds
-static QThread * activeRenderingThread = nullptr;
-
 PickRay Application::computePickRay(float x, float y) const {
    vec2 pickPoint { x, y };
    PickRay result;
@ -5095,7 +5079,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
    auto myAvatar = getMyAvatar();
    myAvatar->preDisplaySide(renderArgs);

-    activeRenderingThread = QThread::currentThread();
    PROFILE_RANGE(render, __FUNCTION__);
    PerformanceTimer perfTimer("display");
    PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "Application::displaySide()");
@ -5168,8 +5151,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
        // Before the deferred pass, let's try to use the render engine
        _renderEngine->run();
    }
-
-    activeRenderingThread = nullptr;
 }

 void Application::resetSensors(bool andReload) {
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@ -181,7 +181,6 @@ public:
    QUndoStack* getUndoStack() { return &_undoStack; }
    MainWindow* getWindow() const { return _window; }
    EntityTreePointer getEntityClipboard() const { return _entityClipboard; }
-    EntityTreeRenderer* getEntityClipboardRenderer() { return &_entityClipboardRenderer; }
    EntityEditPacketSender* getEntityEditPacketSender() { return &_entityEditSender; }

    ivec2 getMouse() const;
@ -532,7 +531,6 @@ private:
    PhysicalEntitySimulationPointer _entitySimulation;
    PhysicsEnginePointer _physicsEngine;

-    EntityTreeRenderer _entityClipboardRenderer;
    EntityTreePointer _entityClipboard;

    mutable QMutex _viewMutex { QMutex::Recursive };
--- a/interface/src/LODManager.h
+++ b/interface/src/LODManager.h
@ -17,6 +17,7 @@
 #include <OctreeConstants.h>
 #include <PIDController.h>
 #include <SimpleMovingAverage.h>
+#include <render/Args.h>

 const float DEFAULT_DESKTOP_LOD_DOWN_FPS = 20.0;
 const float DEFAULT_HMD_LOD_DOWN_FPS = 20.0;
@ -45,7 +46,6 @@ const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
 // This controls how low the auto-adjust LOD will go. We want a minimum vision of ~20:500 or 0.04 of default
 const float ADJUST_LOD_MIN_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE * 0.04f;

-class RenderArgs;
 class AABox;

 class LODManager : public QObject, public Dependency {
--- a/interface/src/audio/AudioScope.h
+++ b/interface/src/audio/AudioScope.h
@ -19,7 +19,6 @@

 #include <DependencyManager.h>
 #include <gpu/Batch.h>
-#include <RenderArgs.h>


 class AudioScope : public QObject, public Dependency {
--- a/interface/src/scripting/MenuScriptingInterface.cpp
+++ b/interface/src/scripting/MenuScriptingInterface.cpp
@ -152,9 +152,13 @@ void MenuScriptingInterface::closeInfoView(const QString& path) {
 }

 bool MenuScriptingInterface::isInfoViewVisible(const QString& path) {
+    if (QThread::currentThread() == qApp->thread()) {
+        return Menu::getInstance()->isInfoViewVisible(path);
+    }
+        
    bool result;
    QMetaObject::invokeMethod(Menu::getInstance(), "isInfoViewVisible", Qt::BlockingQueuedConnection,
-                              Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
+        Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
    return result;
 }

--- a/interface/src/ui/Stats.cpp
+++ b/interface/src/ui/Stats.cpp
@ -16,6 +16,7 @@
 #include <glm/gtx/quaternion.hpp>
 #include <glm/gtx/vector_angle.hpp>

+#include <render/Args.h>
 #include <avatar/AvatarManager.h>
 #include <Application.h>
 #include <AudioClient.h>
@ -33,6 +34,7 @@
 #include "SequenceNumberStats.h"
 #include "StatTracker.h"

+
 HIFI_QML_DEF(Stats)

 using namespace std;
@ -454,7 +456,7 @@ void Stats::updateStats(bool force) {
    }
 }

-void Stats::setRenderDetails(const RenderDetails& details) {
+void Stats::setRenderDetails(const render::RenderDetails& details) {
    STAT_UPDATE(triangles, details._trianglesRendered);
    STAT_UPDATE(materialSwitches, details._materialSwitches);
    if (_expanded) {
--- a/interface/src/ui/Stats.h
+++ b/interface/src/ui/Stats.h
@ -9,10 +9,11 @@
 #ifndef hifi_Stats_h
 #define hifi_Stats_h

+#include <QtGui/QVector3D>
+
 #include <OffscreenQmlElement.h>
-#include <RenderArgs.h>
-#include <QVector3D>
 #include <AudioIOStats.h>
+#include <render/Args.h>

 #define STATS_PROPERTY(type, name, initialValue) \
    Q_PROPERTY(type name READ name NOTIFY name##Changed) \
@ -138,7 +139,7 @@ public:

    Stats(QQuickItem* parent = nullptr);
    bool includeTimingRecord(const QString& name);
-    void setRenderDetails(const RenderDetails& details);
+    void setRenderDetails(const render::RenderDetails& details);
    const QString& monospaceFont() {
        return _monospaceFont;
    }
--- a/interface/src/ui/overlays/Image3DOverlay.cpp
+++ b/interface/src/ui/overlays/Image3DOverlay.cpp
@ -112,7 +112,7 @@ void Image3DOverlay::render(RenderArgs* args) {
        _geometryId
    );

-    batch->setResourceTexture(0, args->_whiteTexture); // restore default white color after me
+    batch->setResourceTexture(0, nullptr); // restore default white color after me
 }

 const render::ShapeKey Image3DOverlay::getShapeKey() {
--- a/interface/src/ui/overlays/LocalModelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalModelsOverlay.cpp
@ -1,50 +0,0 @@
-//
-//  LocalModelsOverlay.cpp
-//  interface/src/ui/overlays
-//
-//  Created by Ryan Huffman on 07/08/14.
-//  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 "LocalModelsOverlay.h"
-
-#include <EntityTreeRenderer.h>
-#include <gpu/Batch.h>
-
-
-QString const LocalModelsOverlay::TYPE = "localmodels";
-
-LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
-    Volume3DOverlay(),
-    _entityTreeRenderer(entityTreeRenderer) {
-}
-
-LocalModelsOverlay::LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay) :
-    Volume3DOverlay(localModelsOverlay),
-    _entityTreeRenderer(localModelsOverlay->_entityTreeRenderer)
-{
-}
-
-void LocalModelsOverlay::update(float deltatime) {
-    _entityTreeRenderer->update();
-}
-
-void LocalModelsOverlay::render(RenderArgs* args) {
-    if (_visible) {
-        auto batch = args ->_batch;
-
-        Transform transform = Transform();
-        transform.setTranslation(args->getViewFrustum().getPosition() + getPosition());
-        batch->setViewTransform(transform);
-        _entityTreeRenderer->render(args);
-        transform.setTranslation(args->getViewFrustum().getPosition());
-        batch->setViewTransform(transform);
-    }
-}
-
-LocalModelsOverlay* LocalModelsOverlay::createClone() const {
-    return new LocalModelsOverlay(this);
-}
--- a/interface/src/ui/overlays/LocalModelsOverlay.h
+++ b/interface/src/ui/overlays/LocalModelsOverlay.h
@ -1,37 +0,0 @@
-//
-//  LocalModelsOverlay.h
-//  interface/src/ui/overlays
-//
-//  Created by Ryan Huffman on 07/08/14.
-//  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
-//
-
-#ifndef hifi_LocalModelsOverlay_h
-#define hifi_LocalModelsOverlay_h
-
-#include "Volume3DOverlay.h"
-
-class EntityTreeRenderer;
-
-class LocalModelsOverlay : public Volume3DOverlay {
-    Q_OBJECT
-public:
-    static QString const TYPE;
-    virtual QString getType() const override { return TYPE; }
-
-    LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
-    LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay);
-
-    virtual void update(float deltatime) override;
-    virtual void render(RenderArgs* args) override;
-
-    virtual LocalModelsOverlay* createClone() const override;
-
-private:
-    EntityTreeRenderer* _entityTreeRenderer;
-};
-
-#endif // hifi_LocalModelsOverlay_h
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@ -26,7 +26,6 @@
 #include "Shape3DOverlay.h"
 #include "ImageOverlay.h"
 #include "Line3DOverlay.h"
-#include "LocalModelsOverlay.h"
 #include "ModelOverlay.h"
 #include "Rectangle3DOverlay.h"
 #include "Sphere3DOverlay.h"
@ -171,8 +170,6 @@ OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties)
        thisOverlay = std::make_shared<Line3DOverlay>();
    } else if (type == Grid3DOverlay::TYPE) {
        thisOverlay = std::make_shared<Grid3DOverlay>();
-    } else if (type == LocalModelsOverlay::TYPE) {
-        thisOverlay = std::make_shared<LocalModelsOverlay>(qApp->getEntityClipboardRenderer());
    } else if (type == ModelOverlay::TYPE) {
        thisOverlay = std::make_shared<ModelOverlay>();
    } else if (type == Web3DOverlay::TYPE) {
--- a/interface/src/ui/overlays/OverlaysPayload.cpp
+++ b/interface/src/ui/overlays/OverlaysPayload.cpp
@ -21,7 +21,6 @@
 #include "Cube3DOverlay.h"
 #include "ImageOverlay.h"
 #include "Line3DOverlay.h"
-#include "LocalModelsOverlay.h"
 #include "ModelOverlay.h"
 #include "Overlays.h"
 #include "Rectangle3DOverlay.h"
--- a/interface/src/ui/overlays/Web3DOverlay.cpp
+++ b/interface/src/ui/overlays/Web3DOverlay.cpp
@ -318,7 +318,7 @@ void Web3DOverlay::render(RenderArgs* args) {
        geometryCache->bindOpaqueWebBrowserProgram(batch, _isAA);
    }
    geometryCache->renderQuad(batch, halfSize * -1.0f, halfSize, vec2(0), vec2(1), color, _geometryId);
-    batch.setResourceTexture(0, args->_whiteTexture); // restore default white color after me
+    batch.setResourceTexture(0, nullptr); // restore default white color after me
 }

 const render::ShapeKey Web3DOverlay::getShapeKey() {
--- a/libraries/animation/CMakeLists.txt
+++ b/libraries/animation/CMakeLists.txt
@ -1,5 +1,7 @@
 set(TARGET_NAME animation)
 setup_hifi_library(Network Script)
 link_hifi_libraries(shared model fbx)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(gpu)

 target_nsight()
--- a/libraries/audio-client/CMakeLists.txt
+++ b/libraries/audio-client/CMakeLists.txt
@ -1,6 +1,8 @@
 set(TARGET_NAME audio-client)
 setup_hifi_library(Network Multimedia)
 link_hifi_libraries(audio plugins)
+include_hifi_library_headers(shared)
+include_hifi_library_headers(networking)

 # append audio includes to our list of includes to bubble
 target_include_directories(${TARGET_NAME} PUBLIC "${HIFI_LIBRARY_DIR}/audio/src")
--- a/libraries/avatars-renderer/CMakeLists.txt
+++ b/libraries/avatars-renderer/CMakeLists.txt
@ -2,5 +2,17 @@ set(TARGET_NAME avatars-renderer)
 AUTOSCRIBE_SHADER_LIB(gpu model render render-utils)
 setup_hifi_library(Widgets Network Script)
 link_hifi_libraries(shared gpu model animation model-networking script-engine render image render-utils)
+include_hifi_library_headers(avatars)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(fbx)
+include_hifi_library_headers(recording)
+include_hifi_library_headers(trackers)
+include_hifi_library_headers(ktx)
+include_hifi_library_headers(procedural)
+include_hifi_library_headers(physics)
+include_hifi_library_headers(entities-renderer)
+include_hifi_library_headers(audio)
+include_hifi_library_headers(entities)
+include_hifi_library_headers(octree)

 target_bullet()
--- a/libraries/controllers/CMakeLists.txt
+++ b/libraries/controllers/CMakeLists.txt
@ -5,6 +5,7 @@ setup_hifi_library(Script Qml)

 # use setup_hifi_library macro to setup our project and link appropriate Qt modules
 link_hifi_libraries(shared)
+include_hifi_library_headers(networking)

 GroupSources("src/controllers")

--- a/libraries/display-plugins/CMakeLists.txt
+++ b/libraries/display-plugins/CMakeLists.txt
@ -2,6 +2,14 @@ set(TARGET_NAME display-plugins)
 AUTOSCRIBE_SHADER_LIB(gpu display-plugins)
 setup_hifi_library(OpenGL)
 link_hifi_libraries(shared plugins ui-plugins gl gpu-gl ui render-utils)
+include_hifi_library_headers(gpu)
+include_hifi_library_headers(model-networking)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(model)
+include_hifi_library_headers(fbx)
+include_hifi_library_headers(image)
+include_hifi_library_headers(ktx)
+include_hifi_library_headers(render)

 target_opengl()

--- a/libraries/display-plugins/src/display-plugins/hmd/DebugHmdDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/hmd/DebugHmdDisplayPlugin.cpp
@ -10,7 +10,6 @@
 #include <QtCore/QProcessEnvironment>

 #include <ViewFrustum.h>
-#include <controllers/Pose.h>
 #include <gpu/Frame.h>

 const QString DebugHmdDisplayPlugin::NAME("HMD Simulator");
--- a/libraries/entities-renderer/CMakeLists.txt
+++ b/libraries/entities-renderer/CMakeLists.txt
@ -2,6 +2,16 @@ set(TARGET_NAME entities-renderer)
 AUTOSCRIBE_SHADER_LIB(gpu model procedural render render-utils)
 setup_hifi_library(Widgets Network Script)
 link_hifi_libraries(shared gpu procedural model model-networking script-engine render render-utils image)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(gl)
+include_hifi_library_headers(ktx)
+include_hifi_library_headers(octree)
+include_hifi_library_headers(audio)
+include_hifi_library_headers(physics)
+include_hifi_library_headers(animation)
+include_hifi_library_headers(fbx)
+include_hifi_library_headers(entities)
+include_hifi_library_headers(avatars)

 target_bullet()

--- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp
+++ b/libraries/entities-renderer/src/EntityTreeRenderer.cpp
@ -9,6 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

+#include "EntityTreeRenderer.h"
+
 #include <glm/gtx/quaternion.hpp>

 #include <QEventLoop>
@ -24,7 +26,6 @@
 #include <SceneScriptingInterface.h>
 #include <ScriptEngine.h>

-#include "EntityTreeRenderer.h"

 #include "RenderableEntityItem.h"

@ -130,7 +131,12 @@ void EntityTreeRenderer::clear() {
    if (scene) {
        render::Transaction transaction;
        foreach(auto entity, _entitiesInScene) {
-            entity->removeFromScene(entity, scene, transaction);
+            auto renderable = entity->getRenderableInterface();
+            if (!renderable) {
+                qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), trying to remove non-renderable entity";
+                continue;
+            }
+            renderable->removeFromScene(entity, scene, transaction);
        }
        scene->enqueueTransaction(transaction);
    } else {
@ -141,7 +147,7 @@ void EntityTreeRenderer::clear() {
    // reset the zone to the default (while we load the next scene)
    _layeredZones.clear();

-    OctreeRenderer::clear();
+    OctreeProcessor::clear();
 }

 void EntityTreeRenderer::reloadEntityScripts() {
@ -155,7 +161,7 @@ void EntityTreeRenderer::reloadEntityScripts() {
 }

 void EntityTreeRenderer::init() {
-    OctreeRenderer::init();
+    OctreeProcessor::init();
    EntityTreePointer entityTree = std::static_pointer_cast<EntityTree>(_tree);
    entityTree->setFBXService(this);

@ -181,7 +187,7 @@ void EntityTreeRenderer::shutdown() {
 }

 void EntityTreeRenderer::setTree(OctreePointer newTree) {
-    OctreeRenderer::setTree(newTree);
+    OctreeProcessor::setTree(newTree);
    std::static_pointer_cast<EntityTree>(_tree)->setFBXService(this);
 }

@ -791,24 +797,33 @@ void EntityTreeRenderer::mouseMoveEvent(QMouseEvent* event) {
 }

 void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) {
+    if (!_entitiesInScene.contains(entityID)) {
+        return;
+    }
+        
    if (_tree && !_shuttingDown && _entitiesScriptEngine) {
        _entitiesScriptEngine->unloadEntityScript(entityID, true);
    }

+    auto scene = _viewState->getMain3DScene();
+    if (!scene) {
+        qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), Unexpected null scene, possibly during application shutdown";
+        return;
+    }
+
+    auto entity = _entitiesInScene.take(entityID);
+    auto renderable = entity->getRenderableInterface();
+    if (!renderable) {
+        qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), trying to remove non-renderable entity";
+        return;
+    }
+
    forceRecheckEntities(); // reset our state to force checking our inside/outsideness of entities

    // here's where we remove the entity payload from the scene
-    if (_entitiesInScene.contains(entityID)) {
-        auto entity = _entitiesInScene.take(entityID);
-        render::Transaction transaction;
-        auto scene = _viewState->getMain3DScene();
-        if (scene) {
-            entity->removeFromScene(entity, scene, transaction);
-            scene->enqueueTransaction(transaction);
-        } else {
-            qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), Unexpected null scene, possibly during application shutdown";
-        }
-    }
+    render::Transaction transaction;
+    renderable->removeFromScene(entity, scene, transaction);
+    scene->enqueueTransaction(transaction);
 }

 void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
@ -820,18 +835,25 @@ void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
    }
 }

-void EntityTreeRenderer::addEntityToScene(EntityItemPointer entity) {
+void EntityTreeRenderer::addEntityToScene(const EntityItemPointer& entity) {
    // here's where we add the entity payload to the scene
-    render::Transaction transaction;
    auto scene = _viewState->getMain3DScene();
-    if (scene) {
-        if (entity->addToScene(entity, scene, transaction)) {
-            _entitiesInScene.insert(entity->getEntityItemID(), entity);
-        }
-        scene->enqueueTransaction(transaction);
-    } else {
+    if (!scene) {
        qCWarning(entitiesrenderer) << "EntityTreeRenderer::addEntityToScene(), Unexpected null scene, possibly during application shutdown";
+        return;
    }
+
+    auto renderable = entity->getRenderableInterface();
+    if (!renderable) {
+        qCWarning(entitiesrenderer) << "EntityTreeRenderer::addEntityToScene(), Unexpected non-renderable entity";
+        return;
+    }
+
+    render::Transaction transaction;
+    if (renderable->addToScene(entity, scene, transaction)) {
+        _entitiesInScene.insert(entity->getEntityItemID(), entity);
+    }
+    scene->enqueueTransaction(transaction);
 }


@ -1050,3 +1072,4 @@ bool EntityTreeRenderer::LayeredZones::contains(const LayeredZones& other) {
    }
    return result;
 }
+
--- a/libraries/entities-renderer/src/EntityTreeRenderer.h
+++ b/libraries/entities-renderer/src/EntityTreeRenderer.h
@ -20,9 +20,10 @@
 #include <EntityTree.h>
 #include <QMouseEvent>
 #include <PointerEvent.h>
-#include <OctreeRenderer.h>
 #include <ScriptCache.h>
 #include <TextureCache.h>
+#include <OctreeProcessor.h>
+#include <render/Forward.h>

 class AbstractScriptingServicesInterface;
 class AbstractViewStateInterface;
@ -38,7 +39,7 @@ using ModelWeakPointer = std::weak_ptr<Model>;
 using CalculateEntityLoadingPriority = std::function<float(const EntityItem& item)>;

 // Generic client side Octree renderer class.
-class EntityTreeRenderer : public OctreeRenderer, public EntityItemFBXService, public Dependency {
+class EntityTreeRenderer : public OctreeProcessor, public EntityItemFBXService, public Dependency {
    Q_OBJECT
 public:
    EntityTreeRenderer(bool wantScripts, AbstractViewStateInterface* viewState,
@ -144,7 +145,7 @@ protected:
 private:
    void resetEntitiesScriptEngine();

-    void addEntityToScene(EntityItemPointer entity);
+    void addEntityToScene(const EntityItemPointer& entity);
    bool findBestZoneAndMaybeContainingEntities(QVector<EntityItemID>* entitiesContainingAvatar = nullptr);

    bool applyLayeredZones();
--- a/libraries/entities-renderer/src/RenderableEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableEntityItem.cpp
@ -40,7 +40,7 @@ namespace render {
    template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args) {
        if (args) {
            if (payload && payload->_entity && payload->_entity->getVisible()) {
-                payload->_entity->render(args);
+                payload->_entity->getRenderableInterface()->render(args);
            }
        }
    }
--- a/libraries/entities-renderer/src/RenderableEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableEntityItem.h
@ -34,13 +34,23 @@ enum class RenderItemStatusIcon {
 void makeEntityItemStatusGetters(EntityItemPointer entity, render::Item::Status::Getters& statusGetters);


+// Renderable entity item interface
+class RenderableEntityInterface {
+public:
+    virtual void render(RenderArgs* args) {};
+    virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) = 0;
+    virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) = 0;
+    virtual RenderableEntityInterface* getRenderableInterface() { return nullptr; }
+};
+
 class RenderableEntityItemProxy {
 public:
-    RenderableEntityItemProxy(EntityItemPointer entity, render::ItemID metaID) : _entity(entity), _metaID(metaID) { }
+    RenderableEntityItemProxy(const EntityItemPointer& entity, render::ItemID metaID)
+        : _entity(entity), _metaID(metaID) {}
    typedef render::Payload<RenderableEntityItemProxy> Payload;
    typedef Payload::DataPointer Pointer;

-    EntityItemPointer _entity;
+    const EntityItemPointer _entity;
    render::ItemID _metaID;
 };

@ -51,10 +61,11 @@ namespace render {
   template <> uint32_t metaFetchMetaSubItems(const RenderableEntityItemProxy::Pointer& payload, ItemIDs& subItems);
 }

+
 // Mixin class for implementing basic single item rendering
-class SimpleRenderableEntityItem {
+class SimplerRenderableEntitySupport : public RenderableEntityInterface {
 public:
-    bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
+    bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override {
        _myItem = scene->allocateID();

        auto renderData = std::make_shared<RenderableEntityItemProxy>(self, _myItem);
@ -69,7 +80,7 @@ public:
        return true;
    }

-    void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
+    void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override {
        transaction.removeItem(_myItem);
        render::Item::clearID(_myItem);
    }
@ -91,7 +102,6 @@ public:
            qCWarning(entitiesrenderer) << "SimpleRenderableEntityItem::notifyChanged(), Unexpected null scene, possibly during application shutdown";
        }
    }
-
 private:
    render::ItemID _myItem { render::Item::INVALID_ITEM_ID };
 };
@ -99,20 +109,18 @@ private:

 #define SIMPLE_RENDERABLE() \
 public: \
-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override { return _renderHelper.addToScene(self, scene, transaction); } \
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override { _renderHelper.removeFromScene(self, scene, transaction); } \
-    virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); _renderHelper.notifyChanged(); } \
-    virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); _renderHelper.notifyChanged(); } \
+    virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyChanged(); } \
+    virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); notifyChanged(); } \
+    virtual RenderableEntityInterface* getRenderableInterface() override { return this; } \
    void checkFading() { \
        bool transparent = isTransparent(); \
        if (transparent != _prevIsTransparent) { \
-            _renderHelper.notifyChanged(); \
+            notifyChanged(); \
            _isFading = false; \
            _prevIsTransparent = transparent; \
        } \
    } \
 private: \
-    SimpleRenderableEntityItem _renderHelper; \
    bool _prevIsTransparent { isTransparent() };


--- a/libraries/entities-renderer/src/RenderableLightEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableLightEntityItem.cpp
@ -27,7 +27,7 @@ RenderableLightEntityItem::RenderableLightEntityItem(const EntityItemID& entityI
 {
 }

-bool RenderableLightEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
+bool RenderableLightEntityItem::addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) {
    _myItem = scene->allocateID();

    auto renderItem = std::make_shared<LightPayload>();
@ -51,7 +51,7 @@ void RenderableLightEntityItem::somethingChangedNotification() {
    LightEntityItem::somethingChangedNotification();
 }

-void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
+void RenderableLightEntityItem::removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) {
    transaction.removeItem(_myItem);
    render::Item::clearID(_myItem);
 }
--- a/libraries/entities-renderer/src/RenderableLightEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableLightEntityItem.h
@ -17,11 +17,13 @@
 #include "RenderableEntityItem.h"


-class RenderableLightEntityItem : public LightEntityItem  {
+class RenderableLightEntityItem : public LightEntityItem, public RenderableEntityInterface {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderableLightEntityItem(const EntityItemID& entityItemID);

+    RenderableEntityInterface* getRenderableInterface() override { return this; }
+
    virtual bool supportsDetailedRayIntersection() const override { return true; }
    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                         bool& keepSearching, OctreeElementPointer& element, float& distance, 
@ -30,10 +32,10 @@ public:

    void updateLightFromEntity(render::Transaction& transaction);

-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;

    virtual void somethingChangedNotification() override;
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;

    virtual void locationChanged(bool tellPhysics = true) override;

--- a/libraries/entities-renderer/src/RenderableLineEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableLineEntityItem.h
@ -16,7 +16,7 @@
 #include "RenderableEntityItem.h"
 #include <GeometryCache.h>

-class RenderableLineEntityItem : public LineEntityItem {
+class RenderableLineEntityItem : public LineEntityItem, public SimplerRenderableEntitySupport {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderableLineEntityItem(const EntityItemID& entityItemID) :
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@ -213,7 +213,7 @@ namespace render {
        if (args) {
            if (payload && payload->entity) {
                PROFILE_RANGE(render_detail, "MetaModelRender");
-                payload->entity->render(args);
+                payload->entity->getRenderableInterface()->render(args);
            }
        }
    }
@ -228,7 +228,7 @@ namespace render {
    }
 }

-bool RenderableModelEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
+bool RenderableModelEntityItem::addToScene(const EntityItemPointer& self, const render::ScenePointer& scene,
                                            render::Transaction& transaction) {
    _myMetaItem = scene->allocateID();

@ -249,7 +249,7 @@ bool RenderableModelEntityItem::addToScene(EntityItemPointer self, const render:
    return true;
 }

-void RenderableModelEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
+void RenderableModelEntityItem::removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene,
                                                render::Transaction& transaction) {
    transaction.removeItem(_myMetaItem);
    render::Item::clearID(_myMetaItem);
@ -390,7 +390,7 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
        if (!_model || _needsModelReload) {
            // TODO: this getModel() appears to be about 3% of model render time. We should optimize
            PerformanceTimer perfTimer("getModel");
-            auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderer);
+            auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderData);
            getModel(renderer);

            // Remap textures immediately after loading to avoid flicker
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.h
@ -20,7 +20,7 @@
 class Model;
 class EntityTreeRenderer;

-class RenderableModelEntityItem : public ModelEntityItem {
+class RenderableModelEntityItem : public ModelEntityItem, RenderableEntityInterface {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);

@ -28,6 +28,8 @@ public:

    virtual ~RenderableModelEntityItem();

+    RenderableEntityInterface* getRenderableInterface() override { return this; }
+
    virtual void setDimensions(const glm::vec3& value) override;
    virtual void setModelURL(const QString& url) override;

@ -40,8 +42,8 @@ public:

    void doInitialModelSimulation();

-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;


    void updateModelBounds();
--- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
@ -161,7 +161,7 @@ RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const Ent
    }
 }

-bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
+bool RenderableParticleEffectEntityItem::addToScene(const EntityItemPointer& self,
                                                    const render::ScenePointer& scene,
                                                    render::Transaction& transaction) {
    _scene = scene;
@ -176,7 +176,7 @@ bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
    return true;
 }

-void RenderableParticleEffectEntityItem::removeFromScene(EntityItemPointer self,
+void RenderableParticleEffectEntityItem::removeFromScene(const EntityItemPointer& self,
                                                         const render::ScenePointer& scene,
                                                         render::Transaction& transaction) {
    transaction.removeItem(_renderItemId);
--- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h
@ -15,18 +15,20 @@
 #include <TextureCache.h>
 #include "RenderableEntityItem.h"

-class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem  {
+class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem, public RenderableEntityInterface {
    friend class ParticlePayloadData;
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderableParticleEffectEntityItem(const EntityItemID& entityItemID);

+    RenderableEntityInterface* getRenderableInterface() override { return this; }
+
    virtual void update(const quint64& now) override;

    void updateRenderItem();

-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;

 protected:
    virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); }
--- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
@ -206,7 +206,7 @@ void RenderablePolyLineEntityItem::render(RenderArgs* args) {
    if (_texture->isLoaded()) {
        batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, _texture->getGPUTexture());
    } else {
-        batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, args->_whiteTexture);
+        batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, nullptr);
    }
   
    batch.setInputFormat(_format);
--- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h
+++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h
@ -22,7 +22,7 @@
 #include <QReadWriteLock>


-class RenderablePolyLineEntityItem : public PolyLineEntityItem {
+class RenderablePolyLineEntityItem : public PolyLineEntityItem, public SimplerRenderableEntitySupport {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    static void createPipeline();
--- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
@ -820,7 +820,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) {
    batch.drawIndexed(gpu::TRIANGLES, (gpu::uint32)mesh->getNumIndices(), 0);
 }

-bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
+bool RenderablePolyVoxEntityItem::addToScene(const EntityItemPointer& self,
                                             const render::ScenePointer& scene,
                                             render::Transaction& transaction) {
    _myItem = scene->allocateID();
@ -838,7 +838,7 @@ bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
    return true;
 }

-void RenderablePolyVoxEntityItem::removeFromScene(EntityItemPointer self,
+void RenderablePolyVoxEntityItem::removeFromScene(const EntityItemPointer& self,
                                                  const render::ScenePointer& scene,
                                                  render::Transaction& transaction) {
    transaction.removeItem(_myItem);
@ -865,7 +865,7 @@ namespace render {

    template <> void payloadRender(const PolyVoxPayload::Pointer& payload, RenderArgs* args) {
        if (args && payload && payload->_owner) {
-            payload->_owner->render(args);
+            payload->_owner->getRenderableInterface()->render(args);
        }
    }
 }
--- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h
+++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h
@ -41,13 +41,15 @@ namespace render {
 }


-class RenderablePolyVoxEntityItem : public PolyVoxEntityItem {
+class RenderablePolyVoxEntityItem : public PolyVoxEntityItem, public RenderableEntityInterface {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderablePolyVoxEntityItem(const EntityItemID& entityItemID);

    virtual ~RenderablePolyVoxEntityItem();

+    RenderableEntityInterface* getRenderableInterface() override { return this; }
+
    void initializePolyVox();

    virtual void somethingChangedNotification() override {
@ -105,10 +107,10 @@ public:
    virtual void setYTextureURL(const QString& yTextureURL) override;
    virtual void setZTextureURL(const QString& zTextureURL) override;

-    virtual bool addToScene(EntityItemPointer self,
+    virtual bool addToScene(const EntityItemPointer& self,
                            const render::ScenePointer& scene,
                            render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self,
+    virtual void removeFromScene(const EntityItemPointer& self,
                                 const render::ScenePointer& scene,
                                 render::Transaction& transaction) override;

--- a/libraries/entities-renderer/src/RenderableShapeEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.h
@ -14,7 +14,7 @@

 #include "RenderableEntityItem.h"

-class RenderableShapeEntityItem : public ShapeEntityItem {
+class RenderableShapeEntityItem : public ShapeEntityItem, private SimplerRenderableEntitySupport {
    using Pointer = std::shared_ptr<RenderableShapeEntityItem>;
    static Pointer baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
 public:
--- a/libraries/entities-renderer/src/RenderableTextEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableTextEntityItem.h
@ -19,7 +19,7 @@

 const int FIXED_FONT_POINT_SIZE = 40;

-class RenderableTextEntityItem : public TextEntityItem  {
+class RenderableTextEntityItem : public TextEntityItem, public SimplerRenderableEntitySupport {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderableTextEntityItem(const EntityItemID& entityItemID) : TextEntityItem(entityItemID) { }
--- a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp
@ -198,7 +198,7 @@ void RenderableWebEntityItem::render(RenderArgs* args) {
    #endif

    if (!_webSurface) {
-        auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderer);
+        auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderData);
        if (!buildWebSurface(renderer)) {
            return;
        }
--- a/libraries/entities-renderer/src/RenderableWebEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableWebEntityItem.h
@ -27,7 +27,7 @@ class EntityTreeRenderer;
 class RenderableWebEntityItem;


-class RenderableWebEntityItem : public WebEntityItem  {
+class RenderableWebEntityItem : public WebEntityItem, SimplerRenderableEntitySupport {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    RenderableWebEntityItem(const EntityItemID& entityItemID);
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
@ -257,7 +257,7 @@ bool RenderableZoneEntityItem::contains(const glm::vec3& point) const {
    return false;
 }

-bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
+bool RenderableZoneEntityItem::addToScene(const EntityItemPointer& self, const render::ScenePointer& scene,
    render::Transaction& transaction) {
    _myMetaItem = scene->allocateID();

@ -277,7 +277,7 @@ bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::
    return true;
 }

-void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
+void RenderableZoneEntityItem::removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene,
    render::Transaction& transaction) {
    transaction.removeItem(_myMetaItem);
    render::Item::clearID(_myMetaItem);
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.h
@ -14,13 +14,14 @@

 #include <Model.h>
 #include <ZoneEntityItem.h>
+#include "RenderableEntityItem.h"

 class NetworkGeometry;
 class KeyLightPayload;

 class RenderableZoneEntityItemMeta;

-class RenderableZoneEntityItem : public ZoneEntityItem  {
+class RenderableZoneEntityItem : public ZoneEntityItem, public RenderableEntityInterface  {
 public:
    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
    
@ -30,6 +31,8 @@ public:
        _needsInitialSimulation(true)
    { }
    
+    RenderableEntityInterface* getRenderableInterface() override { return this; }
+
    virtual bool setProperties(const EntityItemProperties& properties) override;
    virtual void somethingChangedNotification() override;

@ -41,8 +44,8 @@ public:
    virtual void render(RenderArgs* args) override;
    virtual bool contains(const glm::vec3& point) const override;
    
-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
+    virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
    
    render::ItemID getRenderItemID() const { return _myMetaItem; }
    
--- a/libraries/entities/CMakeLists.txt
+++ b/libraries/entities/CMakeLists.txt
@ -1,6 +1,8 @@
 set(TARGET_NAME entities)
 setup_hifi_library(Network Script)
 link_hifi_libraries(avatars shared audio octree model model-networking fbx networking animation)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(gpu)

 target_bullet()

--- a/libraries/entities/src/AddEntityOperator.cpp
+++ b/libraries/entities/src/AddEntityOperator.cpp
@ -30,7 +30,7 @@ AddEntityOperator::AddEntityOperator(EntityTreePointer tree, EntityItemPointer n
    _newEntityBox = queryCube.clamp((float)(-HALF_TREE_SCALE), (float)HALF_TREE_SCALE);
 }

-bool AddEntityOperator::preRecursion(OctreeElementPointer element) {
+bool AddEntityOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

    // In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -60,7 +60,7 @@ bool AddEntityOperator::preRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-bool AddEntityOperator::postRecursion(OctreeElementPointer element) {
+bool AddEntityOperator::postRecursion(const OctreeElementPointer& element) {
    // Post-recursion is the unwinding process. For this operation, while we
    // unwind we want to mark the path as being dirty if we changed it below.
    // We might have two paths, one for the old entity and one for the new entity.
@ -74,7 +74,7 @@ bool AddEntityOperator::postRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-OctreeElementPointer AddEntityOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
+OctreeElementPointer AddEntityOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
    // If we're getting called, it's because there was no child element at this index while recursing.
    // We only care if this happens while still searching for the new entity location.
    // Check to see if 
--- a/libraries/entities/src/AddEntityOperator.h
+++ b/libraries/entities/src/AddEntityOperator.h
@ -16,9 +16,9 @@ class AddEntityOperator : public RecurseOctreeOperator {
 public:
    AddEntityOperator(EntityTreePointer tree, EntityItemPointer newEntity);
                            
-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override;
-    virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override;
+    virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
 private:
    EntityTreePointer _tree;
    EntityItemPointer _newEntity;
--- a/libraries/entities/src/DeleteEntityOperator.cpp
+++ b/libraries/entities/src/DeleteEntityOperator.cpp
@ -55,7 +55,7 @@ void DeleteEntityOperator::addEntityIDToDeleteList(const EntityItemID& searchEnt


 // does this entity tree element contain the old entity
-bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(OctreeElementPointer element) {
+bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(const OctreeElementPointer& element) {
    bool containsEntity = false;

    // If we don't have an old entity, then we don't contain the entity, otherwise
@ -72,7 +72,7 @@ bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(OctreeElementPoin
    return containsEntity;
 }

-bool DeleteEntityOperator::preRecursion(OctreeElementPointer element) {
+bool DeleteEntityOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

    // In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -108,7 +108,7 @@ bool DeleteEntityOperator::preRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-bool DeleteEntityOperator::postRecursion(OctreeElementPointer element) {
+bool DeleteEntityOperator::postRecursion(const OctreeElementPointer& element) {
    // Post-recursion is the unwinding process. For this operation, while we
    // unwind we want to mark the path as being dirty if we changed it below.
    // We might have two paths, one for the old entity and one for the new entity.
--- a/libraries/entities/src/DeleteEntityOperator.h
+++ b/libraries/entities/src/DeleteEntityOperator.h
@ -36,8 +36,8 @@ public:
    ~DeleteEntityOperator();

    void addEntityIDToDeleteList(const EntityItemID& searchEntityID);
-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override;

    const RemovedEntities& getEntities() const { return _entitiesToDelete; }
 private:
@ -46,7 +46,7 @@ private:
    quint64 _changeTime;
    int _foundCount;
    int _lookingCount;
-    bool subTreeContainsSomeEntitiesToDelete(OctreeElementPointer element);
+    bool subTreeContainsSomeEntitiesToDelete(const OctreeElementPointer& element);
 };

 #endif // hifi_DeleteEntityOperator_h
--- a/libraries/entities/src/EntityItem.h
+++ b/libraries/entities/src/EntityItem.h
@ -51,10 +51,6 @@ typedef std::shared_ptr<EntityTreeElement> EntityTreeElementPointer;
 using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr<EntityTreeElementExtraEncodeData>;


-namespace render {
-    class Scene;
-    class Transaction;
-}

 #define DONT_ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() = 0;
 #define ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() override { };
@ -65,6 +61,8 @@ namespace render {

 class MeshProxyList;

+class RenderableEntityInterface;
+

 /// EntityItem class this is the base class for all entity types. It handles the basic properties and functionality available
 /// to all other entity types. In particular: postion, size, rotation, age, lifetime, velocity, gravity. You can not instantiate
@ -83,6 +81,8 @@ public:
    EntityItem(const EntityItemID& entityItemID);
    virtual ~EntityItem();

+    virtual RenderableEntityInterface* getRenderableInterface() { return nullptr; }
+
    inline EntityItemPointer getThisPointer() const {
        return std::static_pointer_cast<EntityItem>(std::const_pointer_cast<SpatiallyNestable>(shared_from_this()));
    }
@ -150,13 +150,6 @@ public:
                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                bool& somethingChanged)
                                                { somethingChanged = false; return 0; }
-
-    virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene,
-                            render::Transaction& transaction) { return false; } // by default entity items don't add to scene
-    virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
-                                render::Transaction& transaction) { } // by default entity items don't add to scene
-    virtual void render(RenderArgs* args) { } // by default entity items don't know how to render
-
    static int expectedBytes();

    static void adjustEditPacketForClockSkew(QByteArray& buffer, qint64 clockSkew);
--- a/libraries/entities/src/EntityTree.cpp
+++ b/libraries/entities/src/EntityTree.cpp
@ -554,7 +554,7 @@ public:
 };


-bool EntityTree::findNearPointOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::findNearPointOperation(const OctreeElementPointer& element, void* extraData) {
    FindNearPointArgs* args = static_cast<FindNearPointArgs*>(extraData);
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

@ -589,7 +589,7 @@ bool EntityTree::findNearPointOperation(OctreeElementPointer element, void* extr
    return false;
 }

-bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
+bool findRayIntersectionOp(const OctreeElementPointer& element, void* extraData) {
    RayArgs* args = static_cast<RayArgs*>(extraData);
    bool keepSearching = true;
    EntityTreeElementPointer entityTreeElementPointer = std::dynamic_pointer_cast<EntityTreeElement>(element);
@ -625,7 +625,7 @@ bool EntityTree::findRayIntersection(const glm::vec3& origin, const glm::vec3& d
 }


-EntityItemPointer EntityTree::findClosestEntity(glm::vec3 position, float targetRadius) {
+EntityItemPointer EntityTree::findClosestEntity(const glm::vec3& position, float targetRadius) {
    FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX };
    withReadLock([&] {
        // NOTE: This should use recursion, since this is a spatial operation
@ -642,7 +642,7 @@ public:
 };


-bool EntityTree::findInSphereOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::findInSphereOperation(const OctreeElementPointer& element, void* extraData) {
    FindAllNearPointArgs* args = static_cast<FindAllNearPointArgs*>(extraData);
    glm::vec3 penetration;
    bool sphereIntersection = element->getAACube().findSpherePenetration(args->position, args->targetRadius, penetration);
@ -678,7 +678,7 @@ public:
    QVector<EntityItemPointer> _foundEntities;
 };

-bool EntityTree::findInCubeOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::findInCubeOperation(const OctreeElementPointer& element, void* extraData) {
    FindEntitiesInCubeArgs* args = static_cast<FindEntitiesInCubeArgs*>(extraData);
    if (element->getAACube().touches(args->_cube)) {
        EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -707,7 +707,7 @@ public:
    QVector<EntityItemPointer> _foundEntities;
 };

-bool EntityTree::findInBoxOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::findInBoxOperation(const OctreeElementPointer& element, void* extraData) {
    FindEntitiesInBoxArgs* args = static_cast<FindEntitiesInBoxArgs*>(extraData);
    if (element->getAACube().touches(args->_box)) {
        EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -732,7 +732,7 @@ public:
    QVector<EntityItemPointer> entities;
 };

-bool EntityTree::findInFrustumOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::findInFrustumOperation(const OctreeElementPointer& element, void* extraData) {
    FindInFrustumArgs* args = static_cast<FindInFrustumArgs*>(extraData);
    if (element->isInView(args->frustum)) {
        EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -1527,15 +1527,15 @@ void EntityTree::debugDumpMap() {

 class ContentsDimensionOperator : public RecurseOctreeOperator {
 public:
-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override { return true; }
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override { return true; }
    glm::vec3 getDimensions() const { return _contentExtents.size(); }
    float getLargestDimension() const { return _contentExtents.largestDimension(); }
 private:
    Extents _contentExtents;
 };

-bool ContentsDimensionOperator::preRecursion(OctreeElementPointer element) {
+bool ContentsDimensionOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
    entityTreeElement->expandExtentsToContents(_contentExtents);
    return true;
@ -1555,11 +1555,11 @@ float EntityTree::getContentsLargestDimension() {

 class DebugOperator : public RecurseOctreeOperator {
 public:
-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override { return true; }
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override { return true; }
 };

-bool DebugOperator::preRecursion(OctreeElementPointer element) {
+bool DebugOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
    qCDebug(entities) << "EntityTreeElement [" << entityTreeElement.get() << "]";
    entityTreeElement->debugDump();
@ -1573,11 +1573,11 @@ void EntityTree::dumpTree() {

 class PruneOperator : public RecurseOctreeOperator {
 public:
-    virtual bool preRecursion(OctreeElementPointer element) override { return true; }
-    virtual bool postRecursion(OctreeElementPointer element) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override { return true; }
+    virtual bool postRecursion(const OctreeElementPointer& element) override;
 };

-bool PruneOperator::postRecursion(OctreeElementPointer element) {
+bool PruneOperator::postRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
    entityTreeElement->pruneChildren();
    return true;
@ -1639,6 +1639,7 @@ QVector<EntityItemID> EntityTree::sendEntities(EntityEditPacketSender* packetSen
    // If this is called repeatedly (e.g., multiple pastes with the same data), the new elements will clash unless we
    // use new identifiers.  We need to keep a map so that we can map parent identifiers correctly.
    QHash<EntityItemID, EntityItemID> map;
+
    args.map = &map;
    withReadLock([&] {
        recurseTreeWithOperation(sendEntitiesOperation, &args);
@ -1692,7 +1693,7 @@ QVector<EntityItemID> EntityTree::sendEntities(EntityEditPacketSender* packetSen
    return map.values().toVector();
 }

-bool EntityTree::sendEntitiesOperation(OctreeElementPointer element, void* extraData) {
+bool EntityTree::sendEntitiesOperation(const OctreeElementPointer& element, void* extraData) {
    SendEntitiesOperationArgs* args = static_cast<SendEntitiesOperationArgs*>(extraData);
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

--- a/libraries/entities/src/EntityTree.h
+++ b/libraries/entities/src/EntityTree.h
@ -136,7 +136,7 @@ public:

    /// \param position point of query in world-frame (meters)
    /// \param targetRadius radius of query (meters)
-    EntityItemPointer findClosestEntity(glm::vec3 position, float targetRadius);
+    EntityItemPointer findClosestEntity(const glm::vec3& position, float targetRadius);
    EntityItemPointer findEntityByID(const QUuid& id);
    EntityItemPointer findEntityByEntityItemID(const EntityItemID& entityID);
    virtual SpatiallyNestablePointer findByID(const QUuid& id) override { return findEntityByID(id); }
@ -294,12 +294,12 @@ protected:
    bool updateEntityWithElement(EntityItemPointer entity, const EntityItemProperties& properties,
                                 EntityTreeElementPointer containingElement,
                                 const SharedNodePointer& senderNode = SharedNodePointer(nullptr));
-    static bool findNearPointOperation(OctreeElementPointer element, void* extraData);
-    static bool findInSphereOperation(OctreeElementPointer element, void* extraData);
-    static bool findInCubeOperation(OctreeElementPointer element, void* extraData);
-    static bool findInBoxOperation(OctreeElementPointer element, void* extraData);
-    static bool findInFrustumOperation(OctreeElementPointer element, void* extraData);
-    static bool sendEntitiesOperation(OctreeElementPointer element, void* extraData);
+    static bool findNearPointOperation(const OctreeElementPointer& element, void* extraData);
+    static bool findInSphereOperation(const OctreeElementPointer& element, void* extraData);
+    static bool findInCubeOperation(const OctreeElementPointer& element, void* extraData);
+    static bool findInBoxOperation(const OctreeElementPointer& element, void* extraData);
+    static bool findInFrustumOperation(const OctreeElementPointer& element, void* extraData);
+    static bool sendEntitiesOperation(const OctreeElementPointer& element, void* extraData);
    static void bumpTimestamp(EntityItemProperties& properties);

    void notifyNewlyCreatedEntity(const EntityItem& newEntity, const SharedNodePointer& senderNode);
--- a/libraries/entities/src/EntityTypes.h
+++ b/libraries/entities/src/EntityTypes.h
@ -17,8 +17,6 @@
 #include <QHash>
 #include <QString>

-#include <OctreeRenderer.h> // for RenderArgs
-
 #include "EntitiesLogging.h"

 class EntityItem;
--- a/libraries/entities/src/MovingEntitiesOperator.cpp
+++ b/libraries/entities/src/MovingEntitiesOperator.cpp
@ -109,7 +109,7 @@ void MovingEntitiesOperator::addEntityToMoveList(EntityItemPointer entity, const
 }

 // does this entity tree element contain the old entity
-bool MovingEntitiesOperator::shouldRecurseSubTree(OctreeElementPointer element) {
+bool MovingEntitiesOperator::shouldRecurseSubTree(const OctreeElementPointer& element) {
    bool containsEntity = false;

    // If we don't have an old entity, then we don't contain the entity, otherwise
@ -141,7 +141,7 @@ bool MovingEntitiesOperator::shouldRecurseSubTree(OctreeElementPointer element)
    return containsEntity;
 }

-bool MovingEntitiesOperator::preRecursion(OctreeElementPointer element) {
+bool MovingEntitiesOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
    
    // In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -221,7 +221,7 @@ bool MovingEntitiesOperator::preRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-bool MovingEntitiesOperator::postRecursion(OctreeElementPointer element) {
+bool MovingEntitiesOperator::postRecursion(const OctreeElementPointer& element) {
    // Post-recursion is the unwinding process. For this operation, while we
    // unwind we want to mark the path as being dirty if we changed it below.
    // We might have two paths, one for the old entity and one for the new entity.
@ -261,7 +261,7 @@ bool MovingEntitiesOperator::postRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-OctreeElementPointer MovingEntitiesOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
+OctreeElementPointer MovingEntitiesOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
    // If we're getting called, it's because there was no child element at this index while recursing.
    // We only care if this happens while still searching for the new entity locations.
    if (_foundNewCount < _lookingCount) {
--- a/libraries/entities/src/MovingEntitiesOperator.h
+++ b/libraries/entities/src/MovingEntitiesOperator.h
@ -38,9 +38,9 @@ public:
    ~MovingEntitiesOperator();

    void addEntityToMoveList(EntityItemPointer entity, const AACube& newCube);
-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override;
-    virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override;
+    virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
    bool hasMovingEntities() const { return _entitiesToMove.size() > 0; }
 private:
    EntityTreePointer _tree;
@ -49,7 +49,7 @@ private:
    int _foundOldCount;
    int _foundNewCount;
    int _lookingCount;
-    bool shouldRecurseSubTree(OctreeElementPointer element);
+    bool shouldRecurseSubTree(const OctreeElementPointer& element);
    
    bool _wantDebug;
 };
--- a/libraries/entities/src/RecurseOctreeToMapOperator.cpp
+++ b/libraries/entities/src/RecurseOctreeToMapOperator.cpp
@ -14,7 +14,7 @@
 #include "EntityItemProperties.h"

 RecurseOctreeToMapOperator::RecurseOctreeToMapOperator(QVariantMap& map,
-                                                       OctreeElementPointer top,
+                                                       const OctreeElementPointer& top,
                                                       QScriptEngine* engine,
                                                       bool skipDefaultValues,
                                                       bool skipThoseWithBadParents) :
@ -34,14 +34,14 @@ RecurseOctreeToMapOperator::RecurseOctreeToMapOperator(QVariantMap& map,
    }
 };

-bool RecurseOctreeToMapOperator::preRecursion(OctreeElementPointer element) {
+bool RecurseOctreeToMapOperator::preRecursion(const OctreeElementPointer& element) {
    if (element == _top) {
        _withinTop = true;
    }
    return true;
 }

-bool RecurseOctreeToMapOperator::postRecursion(OctreeElementPointer element) {
+bool RecurseOctreeToMapOperator::postRecursion(const OctreeElementPointer& element) {

    EntityItemProperties defaultProperties;

--- a/libraries/entities/src/RecurseOctreeToMapOperator.h
+++ b/libraries/entities/src/RecurseOctreeToMapOperator.h
@ -13,10 +13,10 @@

 class RecurseOctreeToMapOperator : public RecurseOctreeOperator {
 public:
-    RecurseOctreeToMapOperator(QVariantMap& map, OctreeElementPointer top, QScriptEngine* engine, bool skipDefaultValues,
+    RecurseOctreeToMapOperator(QVariantMap& map, const OctreeElementPointer& top, QScriptEngine* engine, bool skipDefaultValues,
                               bool skipThoseWithBadParents);
-    bool preRecursion(OctreeElementPointer element) override;
-    bool postRecursion(OctreeElementPointer element) override;
+    bool preRecursion(const OctreeElementPointer& element) override;
+    bool postRecursion(const OctreeElementPointer& element) override;
 private:
    QVariantMap& _map;
    OctreeElementPointer _top;
--- a/libraries/entities/src/UpdateEntityOperator.cpp
+++ b/libraries/entities/src/UpdateEntityOperator.cpp
@ -77,7 +77,7 @@ UpdateEntityOperator::~UpdateEntityOperator() {


 // does this entity tree element contain the old entity
-bool UpdateEntityOperator::subTreeContainsOldEntity(OctreeElementPointer element) {
+bool UpdateEntityOperator::subTreeContainsOldEntity(const OctreeElementPointer& element) {

    // We've found cases where the old entity might be placed in an element that is not actually the best fit
    // so when we're searching the tree for the old element, we use the known cube for the known containing element
@ -95,7 +95,7 @@ bool UpdateEntityOperator::subTreeContainsOldEntity(OctreeElementPointer element
    return elementContainsOldBox;
 }

-bool UpdateEntityOperator::subTreeContainsNewEntity(OctreeElementPointer element) {
+bool UpdateEntityOperator::subTreeContainsNewEntity(const OctreeElementPointer& element) {
    bool elementContainsNewBox = element->getAACube().contains(_newEntityBox);

    if (_wantDebug) {
@ -112,7 +112,7 @@ bool UpdateEntityOperator::subTreeContainsNewEntity(OctreeElementPointer element
 }


-bool UpdateEntityOperator::preRecursion(OctreeElementPointer element) {
+bool UpdateEntityOperator::preRecursion(const OctreeElementPointer& element) {
    EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

    // In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -238,7 +238,7 @@ bool UpdateEntityOperator::preRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-bool UpdateEntityOperator::postRecursion(OctreeElementPointer element) {
+bool UpdateEntityOperator::postRecursion(const OctreeElementPointer& element) {
    // Post-recursion is the unwinding process. For this operation, while we
    // unwind we want to mark the path as being dirty if we changed it below.
    // We might have two paths, one for the old entity and one for the new entity.
@ -270,7 +270,7 @@ bool UpdateEntityOperator::postRecursion(OctreeElementPointer element) {
    return keepSearching; // if we haven't yet found it, keep looking
 }

-OctreeElementPointer UpdateEntityOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
+OctreeElementPointer UpdateEntityOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
    // If we're getting called, it's because there was no child element at this index while recursing.
    // We only care if this happens while still searching for the new entity location.
    // Check to see if
--- a/libraries/entities/src/UpdateEntityOperator.h
+++ b/libraries/entities/src/UpdateEntityOperator.h
@ -25,9 +25,9 @@ public:

    ~UpdateEntityOperator();

-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override;
-    virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override;
+    virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
 private:
    EntityTreePointer _tree;
    EntityItemPointer _existingEntity;
@ -45,8 +45,8 @@ private:
    AABox _oldEntityBox; // clamped to domain
    AABox _newEntityBox; // clamped to domain

-    bool subTreeContainsOldEntity(OctreeElementPointer element);
-    bool subTreeContainsNewEntity(OctreeElementPointer element);
+    bool subTreeContainsOldEntity(const OctreeElementPointer& element);
+    bool subTreeContainsNewEntity(const OctreeElementPointer& element);

    bool _wantDebug;
 };
--- a/libraries/fbx/CMakeLists.txt
+++ b/libraries/fbx/CMakeLists.txt
@ -1,3 +1,4 @@
 set(TARGET_NAME fbx)
 setup_hifi_library()
 link_hifi_libraries(shared model networking)
+include_hifi_library_headers(gpu)
--- a/libraries/gpu-gl/src/gpu/gl/GLTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLTexture.cpp
@ -223,12 +223,21 @@ TransferJob::TransferJob(const GLTexture& parent, uint16_t sourceMip, uint16_t t

    // Buffering can invoke disk IO, so it should be off of the main and render threads
    _bufferingLambda = [=] {
-        _mipData = _parent._gpuObject.accessStoredMipFace(sourceMip, face)->createView(_transferSize, _transferOffset);
+        auto mipStorage = _parent._gpuObject.accessStoredMipFace(sourceMip, face);
+        if (mipStorage) {
+            _mipData = mipStorage->createView(_transferSize, _transferOffset);
+        } else {
+            qCWarning(gpugllogging) << "Buffering failed because mip could not be retrieved from texture " << _parent._source.c_str() ;
+        }
    };

    _transferLambda = [=] {
-        _parent.copyMipFaceLinesFromTexture(targetMip, face, transferDimensions, lineOffset, internalFormat, format, type, _mipData->size(), _mipData->readData());
-        _mipData.reset();
+        if (_mipData) {
+            _parent.copyMipFaceLinesFromTexture(targetMip, face, transferDimensions, lineOffset, internalFormat, format, type, _mipData->size(), _mipData->readData());
+            _mipData.reset();
+        } else {
+            qCWarning(gpugllogging) << "Transfer failed because mip could not be retrieved from texture " << _parent._source.c_str();
+        }
    };
 }

--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
@ -123,7 +123,7 @@ GLuint GL45Texture::allocate(const Texture& texture) {
    glCreateTextures(getGLTextureType(texture), 1, &result);
 #ifdef DEBUG
    auto source = texture.source();
-    glObjectLabel(GL_TEXTURE, result, source.length(), source.data());
+    glObjectLabel(GL_TEXTURE, result, (GLsizei)source.length(), source.data());
 #endif
    return result;
 }
--- a/libraries/gpu/src/gpu/Texture.h
+++ b/libraries/gpu/src/gpu/Texture.h
@ -18,7 +18,7 @@
 #include <QUrl>

 #include <shared/Storage.h>
-
+#include <shared/FileCache.h>
 #include "Forward.h"
 #include "Resource.h"
 #include "Metric.h"
@ -311,6 +311,7 @@ public:
    class KtxStorage : public Storage {
    public:
        KtxStorage(const std::string& filename);
+        KtxStorage(const cache::FilePointer& file);
        PixelsPointer getMipFace(uint16 level, uint8 face = 0) const override;
        Size getMipFaceSize(uint16 level, uint8 face = 0) const override;
        bool isMipAvailable(uint16 level, uint8 face = 0) const override;
@ -328,6 +329,7 @@ public:
        mutable std::weak_ptr<storage::FileStorage> _cacheFile;

        std::string _filename;
+        cache::FilePointer _cacheEntry;
        std::atomic<uint8_t> _minMipLevelAvailable;
        size_t _offsetToMinMipKV;

@ -499,6 +501,7 @@ public:

    void setStorage(std::unique_ptr<Storage>& newStorage);
    void setKtxBacking(const std::string& filename);
+    void setKtxBacking(const cache::FilePointer& cacheEntry);

    // Usage is a a set of flags providing Semantic about the usage of the Texture.
    void setUsage(const Usage& usage) { _usage = usage; }
@ -529,8 +532,9 @@ public:
    // Serialize a texture into a KTX file
    static ktx::KTXUniquePointer serialize(const Texture& texture);

+    static TexturePointer build(const ktx::KTXDescriptor& descriptor);
    static TexturePointer unserialize(const std::string& ktxFile);
-    static TexturePointer unserialize(const std::string& ktxFile, const ktx::KTXDescriptor& descriptor);
+    static TexturePointer unserialize(const cache::FilePointer& cacheEntry);

    static bool evalKTXFormat(const Element& mipFormat, const Element& texelFormat, ktx::Header& header);
    static bool evalTextureFormat(const ktx::Header& header, Element& mipFormat, Element& texelFormat);
--- a/libraries/gpu/src/gpu/Texture_ktx.cpp
+++ b/libraries/gpu/src/gpu/Texture_ktx.cpp
@ -154,6 +154,10 @@ struct IrradianceKTXPayload {
 };
 const std::string IrradianceKTXPayload::KEY{ "hifi.irradianceSH" };

+KtxStorage::KtxStorage(const cache::FilePointer& cacheEntry) : KtxStorage(cacheEntry->getFilepath())  {
+    _cacheEntry = cacheEntry;
+}
+
 KtxStorage::KtxStorage(const std::string& filename) : _filename(filename) {
    {
        // We are doing a lot of work here just to get descriptor data
@ -295,20 +299,35 @@ void KtxStorage::assignMipFaceData(uint16 level, uint8 face, const storage::Stor
    throw std::runtime_error("Invalid call");
 }

+bool validKtx(const std::string& filename) {
+    ktx::StoragePointer storage { new storage::FileStorage(filename.c_str()) };
+    auto ktxPointer = ktx::KTX::create(storage);
+    if (!ktxPointer) {
+        return false;
+    }
+    return true;
+}
+
 void Texture::setKtxBacking(const std::string& filename) {
    // Check the KTX file for validity before using it as backing storage
-    {
-        ktx::StoragePointer storage { new storage::FileStorage(filename.c_str()) };
-        auto ktxPointer = ktx::KTX::create(storage);
-        if (!ktxPointer) {
-            return;
-        }
+    if (!validKtx(filename)) {
+        return;
    }

    auto newBacking = std::unique_ptr<Storage>(new KtxStorage(filename));
    setStorage(newBacking);
 }

+void Texture::setKtxBacking(const cache::FilePointer& cacheEntry) {
+    // Check the KTX file for validity before using it as backing storage
+    if (!validKtx(cacheEntry->getFilepath())) {
+        return;
+    }
+
+    auto newBacking = std::unique_ptr<Storage>(new KtxStorage(cacheEntry));
+    setStorage(newBacking);
+}
+

 ktx::KTXUniquePointer Texture::serialize(const Texture& texture) {
    ktx::Header header;
@ -442,21 +461,10 @@ ktx::KTXUniquePointer Texture::serialize(const Texture& texture) {
    return ktxBuffer;
 }

-TexturePointer Texture::unserialize(const std::string& ktxfile) {
-    std::unique_ptr<ktx::KTX> ktxPointer = ktx::KTX::create(std::make_shared<storage::FileStorage>(ktxfile.c_str()));
-    if (!ktxPointer) {
-        return nullptr;
-    }
-
-    ktx::KTXDescriptor descriptor { ktxPointer->toDescriptor() };
-    return unserialize(ktxfile, ktxPointer->toDescriptor());
-}
-
-TexturePointer Texture::unserialize(const std::string& ktxfile, const ktx::KTXDescriptor& descriptor) {
-    const auto& header = descriptor.header;
-
+TexturePointer Texture::build(const ktx::KTXDescriptor& descriptor) {
    Format mipFormat = Format::COLOR_BGRA_32;
    Format texelFormat = Format::COLOR_SRGBA_32;
+    const auto& header = descriptor.header;

    if (!Texture::evalTextureFormat(header, mipFormat, texelFormat)) {
        return nullptr;
@ -485,20 +493,19 @@ TexturePointer Texture::unserialize(const std::string& ktxfile, const ktx::KTXDe
    }

    auto texture = create(gpuktxKeyValue._usageType,
-                          type,
-                          texelFormat,
-                          header.getPixelWidth(),
-                          header.getPixelHeight(),
-                          header.getPixelDepth(),
-                          1, // num Samples
-                          header.getNumberOfSlices(),
-                          header.getNumberOfLevels(),
-                          gpuktxKeyValue._samplerDesc);
+        type,
+        texelFormat,
+        header.getPixelWidth(),
+        header.getPixelHeight(),
+        header.getPixelDepth(),
+        1, // num Samples
+        header.getNumberOfSlices(),
+        header.getNumberOfLevels(),
+        gpuktxKeyValue._samplerDesc);
    texture->setUsage(gpuktxKeyValue._usage);

    // Assing the mips availables
    texture->setStoredMipFormat(mipFormat);
-    texture->setKtxBacking(ktxfile);

    IrradianceKTXPayload irradianceKtxKeyValue;
    if (IrradianceKTXPayload::findInKeyValues(descriptor.keyValues, irradianceKtxKeyValue)) {
@ -508,6 +515,36 @@ TexturePointer Texture::unserialize(const std::string& ktxfile, const ktx::KTXDe
    return texture;
 }

+
+
+TexturePointer Texture::unserialize(const cache::FilePointer& cacheEntry) {
+    std::unique_ptr<ktx::KTX> ktxPointer = ktx::KTX::create(std::make_shared<storage::FileStorage>(cacheEntry->getFilepath().c_str()));
+    if (!ktxPointer) {
+        return nullptr;
+    }
+
+    auto texture = build(ktxPointer->toDescriptor());
+    if (texture) {
+        texture->setKtxBacking(cacheEntry);
+    }
+
+    return texture;
+}
+
+TexturePointer Texture::unserialize(const std::string& ktxfile) {
+    std::unique_ptr<ktx::KTX> ktxPointer = ktx::KTX::create(std::make_shared<storage::FileStorage>(ktxfile.c_str()));
+    if (!ktxPointer) {
+        return nullptr;
+    }
+    
+    auto texture = build(ktxPointer->toDescriptor());
+    if (texture) {
+        texture->setKtxBacking(ktxfile);
+    }
+
+    return texture;
+}
+
 bool Texture::evalKTXFormat(const Element& mipFormat, const Element& texelFormat, ktx::Header& header) {
    if (texelFormat == Format::COLOR_RGBA_32 && mipFormat == Format::COLOR_BGRA_32) {
        header.setUncompressed(ktx::GLType::UNSIGNED_BYTE, 1, ktx::GLFormat::BGRA, ktx::GLInternalFormat::RGBA8, ktx::GLBaseInternalFormat::RGBA);
--- a/libraries/ktx/CMakeLists.txt
+++ b/libraries/ktx/CMakeLists.txt
@ -1,3 +1,3 @@
 set(TARGET_NAME ktx)
 setup_hifi_library()
-link_hifi_libraries()
+include_hifi_library_headers(shared)
--- a/libraries/model-networking/CMakeLists.txt
+++ b/libraries/model-networking/CMakeLists.txt
@ -1,4 +1,4 @@
 set(TARGET_NAME model-networking)
 setup_hifi_library()
 link_hifi_libraries(shared networking model fbx ktx image)
-
+include_hifi_library_headers(gpu)
--- a/libraries/model-networking/src/model-networking/KTXCache.h
+++ b/libraries/model-networking/src/model-networking/KTXCache.h
@ -14,7 +14,7 @@

 #include <QUrl>

-#include <FileCache.h>
+#include <shared/FileCache.h>

 namespace ktx {
    class KTX;
--- a/libraries/model-networking/src/model-networking/TextureCache.cpp
+++ b/libraries/model-networking/src/model-networking/TextureCache.cpp
@ -630,9 +630,10 @@ void NetworkTexture::maybeHandleFinishedInitialLoad() {
            if (!texture) {
                KTXFilePointer ktxFile = textureCache->_ktxCache.getFile(hash);
                if (ktxFile) {
-                    texture = gpu::Texture::unserialize(ktxFile->getFilepath());
+                    texture = gpu::Texture::unserialize(ktxFile);
                    if (texture) {
                        texture = textureCache->cacheTextureByHash(hash, texture);
+                        _file = ktxFile;
                    }
                }
            }
@ -662,8 +663,8 @@ void NetworkTexture::maybeHandleFinishedInitialLoad() {

                auto newKtxDescriptor = memKtx->toDescriptor();

-                texture = gpu::Texture::unserialize(_file->getFilepath(), newKtxDescriptor);
-                texture->setKtxBacking(file->getFilepath());
+                texture = gpu::Texture::build(newKtxDescriptor);
+                texture->setKtxBacking(file);
                texture->setSource(filename);

                auto& images = _originalKtxDescriptor->images;
@ -814,7 +815,7 @@ void ImageReader::read() {
        if (!texture) {
            KTXFilePointer ktxFile = textureCache->_ktxCache.getFile(hash);
            if (ktxFile) {
-                texture = gpu::Texture::unserialize(ktxFile->getFilepath());
+                texture = gpu::Texture::unserialize(ktxFile);
                if (texture) {
                    texture = textureCache->cacheTextureByHash(hash, texture);
                } else {
@ -866,7 +867,7 @@ void ImageReader::read() {
            if (!networkTexture->_file) {
                qCWarning(modelnetworking) << _url << "file cache failed";
            } else {
-                texture->setKtxBacking(networkTexture->_file->getFilepath());
+                texture->setKtxBacking(networkTexture->_file);
            }
        } else {
            qCWarning(modelnetworking) << "Unable to serialize texture to KTX " << _url;
--- a/libraries/model/src/model/Geometry.h
+++ b/libraries/model/src/model/Geometry.h
@ -13,10 +13,10 @@

 #include <glm/glm.hpp>

-#include "AABox.h"
+#include <AABox.h>

-#include "gpu/Resource.h"
-#include "gpu/Stream.h"
+#include <gpu/Resource.h>
+#include <gpu/Stream.h>

 namespace model {
 typedef gpu::BufferView::Index Index;
--- a/libraries/octree/src/DirtyOctreeElementOperator.cpp
+++ b/libraries/octree/src/DirtyOctreeElementOperator.cpp
@ -11,20 +11,20 @@

 #include "DirtyOctreeElementOperator.h"

-DirtyOctreeElementOperator::DirtyOctreeElementOperator(OctreeElementPointer element)
+DirtyOctreeElementOperator::DirtyOctreeElementOperator(const OctreeElementPointer& element)
    :   _element(element) {
    assert(_element.get());
    _point = _element->getAACube().calcCenter();
 }

-bool DirtyOctreeElementOperator::preRecursion(OctreeElementPointer element) {
+bool DirtyOctreeElementOperator::preRecursion(const OctreeElementPointer& element) {
    if (element == _element) {
        return false;
    }
    return element->getAACube().contains(_point);
 }

-bool DirtyOctreeElementOperator::postRecursion(OctreeElementPointer element) {
+bool DirtyOctreeElementOperator::postRecursion(const OctreeElementPointer& element) {
    element->markWithChangedTime();
    return true;
 }
--- a/libraries/octree/src/DirtyOctreeElementOperator.h
+++ b/libraries/octree/src/DirtyOctreeElementOperator.h
@ -16,12 +16,12 @@

 class DirtyOctreeElementOperator : public RecurseOctreeOperator {
 public:
-    DirtyOctreeElementOperator(OctreeElementPointer element);
+    DirtyOctreeElementOperator(const OctreeElementPointer& element);

    ~DirtyOctreeElementOperator() {}

-    virtual bool preRecursion(OctreeElementPointer element) override;
-    virtual bool postRecursion(OctreeElementPointer element) override;
+    virtual bool preRecursion(const OctreeElementPointer& element) override;
+    virtual bool postRecursion(const OctreeElementPointer& element) override;
 private:
    glm::vec3 _point;
    OctreeElementPointer _element;
--- a/libraries/octree/src/Octree.cpp
+++ b/libraries/octree/src/Octree.cpp
@ -74,7 +74,7 @@ Octree::~Octree() {
 // non-sorted array
 // returns -1 if size exceeded
 // originalIndexArray is optional
-int insertOctreeElementIntoSortedArrays(OctreeElementPointer value, float key, int originalIndex,
+int insertOctreeElementIntoSortedArrays(const OctreeElementPointer& value, float key, int originalIndex,
                                        OctreeElementPointer* valueArray, float* keyArray, int* originalIndexArray,
                                        int currentCount, int maxCount) {

@ -108,17 +108,17 @@ int insertOctreeElementIntoSortedArrays(OctreeElementPointer value, float key, i

 // Recurses voxel tree calling the RecurseOctreeOperation function for each element.
 // stops recursion if operation function returns false.
-void Octree::recurseTreeWithOperation(RecurseOctreeOperation operation, void* extraData) {
+void Octree::recurseTreeWithOperation(const RecurseOctreeOperation& operation, void* extraData) {
    recurseElementWithOperation(_rootElement, operation, extraData);
 }

 // Recurses voxel tree calling the RecurseOctreePostFixOperation function for each element in post-fix order.
-void Octree::recurseTreeWithPostOperation(RecurseOctreeOperation operation, void* extraData) {
+void Octree::recurseTreeWithPostOperation(const RecurseOctreeOperation& operation, void* extraData) {
    recurseElementWithPostOperation(_rootElement, operation, extraData);
 }

 // Recurses voxel element with an operation function
-void Octree::recurseElementWithOperation(OctreeElementPointer element, RecurseOctreeOperation operation, void* extraData,
+void Octree::recurseElementWithOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation, void* extraData,
                        int recursionCount) {
    if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
        static QString repeatedMessage
@ -140,7 +140,7 @@ void Octree::recurseElementWithOperation(OctreeElementPointer element, RecurseOc
 }

 // Recurses voxel element with an operation function
-void Octree::recurseElementWithPostOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
+void Octree::recurseElementWithPostOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
                                             void* extraData, int recursionCount) {
    if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
        static QString repeatedMessage
@ -162,14 +162,14 @@ void Octree::recurseElementWithPostOperation(OctreeElementPointer element, Recur

 // Recurses voxel tree calling the RecurseOctreeOperation function for each element.
 // stops recursion if operation function returns false.
-void Octree::recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
+void Octree::recurseTreeWithOperationDistanceSorted(const RecurseOctreeOperation& operation,
                                                       const glm::vec3& point, void* extraData) {

    recurseElementWithOperationDistanceSorted(_rootElement, operation, point, extraData);
 }

 // Recurses voxel element with an operation function
-void Octree::recurseElementWithOperationDistanceSorted(OctreeElementPointer element, RecurseOctreeOperation operation,
+void Octree::recurseElementWithOperationDistanceSorted(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
                                                       const glm::vec3& point, void* extraData, int recursionCount) {

    if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
@ -212,7 +212,7 @@ void Octree::recurseTreeWithOperator(RecurseOctreeOperator* operatorObject) {
    recurseElementWithOperator(_rootElement, operatorObject);
 }

-bool Octree::recurseElementWithOperator(OctreeElementPointer element,
+bool Octree::recurseElementWithOperator(const OctreeElementPointer& element,
                                        RecurseOctreeOperator* operatorObject, int recursionCount) {
    if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
        static QString repeatedMessage
@ -245,7 +245,7 @@ bool Octree::recurseElementWithOperator(OctreeElementPointer element,
 }


-OctreeElementPointer Octree::nodeForOctalCode(OctreeElementPointer ancestorElement, const unsigned char* needleCode,
+OctreeElementPointer Octree::nodeForOctalCode(const OctreeElementPointer& ancestorElement, const unsigned char* needleCode,
                                              OctreeElementPointer* parentOfFoundElement) const {
    // special case for NULL octcode
    if (!needleCode) {
@ -281,7 +281,7 @@ OctreeElementPointer Octree::nodeForOctalCode(OctreeElementPointer ancestorEleme
 }

 // returns the element created!
-OctreeElementPointer Octree::createMissingElement(OctreeElementPointer lastParentElement,
+OctreeElementPointer Octree::createMissingElement(const OctreeElementPointer& lastParentElement,
                                                  const unsigned char* codeToReach, int recursionCount) {

    if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
@ -311,7 +311,7 @@ OctreeElementPointer Octree::createMissingElement(OctreeElementPointer lastParen
    }
 }

-int Octree::readElementData(OctreeElementPointer destinationElement, const unsigned char* nodeData, int bytesAvailable,
+int Octree::readElementData(const OctreeElementPointer& destinationElement, const unsigned char* nodeData, int bytesAvailable,
                            ReadBitstreamToTreeParams& args) {

    int bytesLeftToRead = bytesAvailable;
@ -529,7 +529,7 @@ void Octree::deleteOctalCodeFromTree(const unsigned char* codeBuffer, bool colla
    });
 }

-void Octree::deleteOctalCodeFromTreeRecursion(OctreeElementPointer element, void* extraData) {
+void Octree::deleteOctalCodeFromTreeRecursion(const OctreeElementPointer& element, void* extraData) {
    DeleteOctalCodeFromTreeArgs* args = (DeleteOctalCodeFromTreeArgs*)extraData;

    int lengthOfElementCode = numberOfThreeBitSectionsInCode(element->getOctalCode());
@ -703,7 +703,7 @@ public:
    void* penetratedObject; /// the type is defined by the type of Octree, the caller is assumed to know the type
 };

-bool findSpherePenetrationOp(OctreeElementPointer element, void* extraData) {
+bool findSpherePenetrationOp(const OctreeElementPointer& element, void* extraData) {
    SphereArgs* args = static_cast<SphereArgs*>(extraData);

    // coarse check against bounds
@ -765,7 +765,7 @@ public:
    CubeList* cubes;
 };

-bool findCapsulePenetrationOp(OctreeElementPointer element, void* extraData) {
+bool findCapsulePenetrationOp(const OctreeElementPointer& element, void* extraData) {
    CapsuleArgs* args = static_cast<CapsuleArgs*>(extraData);

    // coarse check against bounds
@ -798,7 +798,7 @@ uint qHash(const glm::vec3& point) {
        (((quint64)(point.z * RESOLUTION_PER_METER)) % MAX_SCALED_COMPONENT << 2 * BITS_PER_COMPONENT));
 }

-bool findContentInCubeOp(OctreeElementPointer element, void* extraData) {
+bool findContentInCubeOp(const OctreeElementPointer& element, void* extraData) {
    ContentArgs* args = static_cast<ContentArgs*>(extraData);

    // coarse check against bounds
@ -851,7 +851,7 @@ public:
 };

 // Find the smallest colored voxel enclosing a point (if there is one)
-bool getElementEnclosingOperation(OctreeElementPointer element, void* extraData) {
+bool getElementEnclosingOperation(const OctreeElementPointer& element, void* extraData) {
    GetElementEnclosingArgs* args = static_cast<GetElementEnclosingArgs*>(extraData);
    if (element->getAACube().contains(args->point)) {
        if (element->hasContent() && element->isLeaf()) {
@ -885,7 +885,7 @@ OctreeElementPointer Octree::getElementEnclosingPoint(const glm::vec3& point, Oc



-int Octree::encodeTreeBitstream(OctreeElementPointer element,
+int Octree::encodeTreeBitstream(const OctreeElementPointer& element,
                                OctreePacketData* packetData, OctreeElementBag& bag,
                                EncodeBitstreamParams& params) {

@ -979,7 +979,7 @@ int Octree::encodeTreeBitstream(OctreeElementPointer element,
    return bytesWritten;
 }

-int Octree::encodeTreeBitstreamRecursion(OctreeElementPointer element,
+int Octree::encodeTreeBitstreamRecursion(const OctreeElementPointer& element,
                                         OctreePacketData* packetData, OctreeElementBag& bag,
                                         EncodeBitstreamParams& params, int& currentEncodeLevel,
                                         const ViewFrustum::intersection& parentLocationThisView) const {
@ -1866,7 +1866,7 @@ bool Octree::readJSONFromStream(unsigned long streamLength, QDataStream& inputSt
    return success;
 }

-bool Octree::writeToFile(const char* fileName, OctreeElementPointer element, QString persistAsFileType) {
+bool Octree::writeToFile(const char* fileName, const OctreeElementPointer& element, QString persistAsFileType) {
    // make the sure file extension makes sense
    QString qFileName = fileNameWithoutExtension(QString(fileName), PERSIST_EXTENSIONS) + "." + persistAsFileType;
    QByteArray byteArray = qFileName.toUtf8();
@ -1883,7 +1883,7 @@ bool Octree::writeToFile(const char* fileName, OctreeElementPointer element, QSt
    return success;
 }

-bool Octree::writeToJSONFile(const char* fileName, OctreeElementPointer element, bool doGzip) {
+bool Octree::writeToJSONFile(const char* fileName, const OctreeElementPointer& element, bool doGzip) {
    QVariantMap entityDescription;

    qCDebug(octree, "Saving JSON SVO to file %s...", fileName);
@ -1937,7 +1937,7 @@ unsigned long Octree::getOctreeElementsCount() {
    return nodeCount;
 }

-bool Octree::countOctreeElementsOperation(OctreeElementPointer element, void* extraData) {
+bool Octree::countOctreeElementsOperation(const OctreeElementPointer& element, void* extraData) {
    (*(unsigned long*)extraData)++;
    return true; // keep going
 }
--- a/libraries/octree/src/Octree.h
+++ b/libraries/octree/src/Octree.h
@ -41,13 +41,13 @@ extern QVector<QString> PERSIST_EXTENSIONS;
 /// derive from this class to use the Octree::recurseTreeWithOperator() method
 class RecurseOctreeOperator {
 public:
-    virtual bool preRecursion(OctreeElementPointer element) = 0;
-    virtual bool postRecursion(OctreeElementPointer element) = 0;
-    virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) { return NULL; }
+    virtual bool preRecursion(const OctreeElementPointer& element) = 0;
+    virtual bool postRecursion(const OctreeElementPointer& element) = 0;
+    virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) { return NULL; }
 };

 // Callback function, for recuseTreeWithOperation
-typedef bool (*RecurseOctreeOperation)(OctreeElementPointer element, void* extraData);
+using RecurseOctreeOperation = std::function<bool(const OctreeElementPointer&, void*)>;
 typedef enum {GRADIENT, RANDOM, NATURAL} creationMode;
 typedef QHash<uint, AACube> CubeList;

@ -233,7 +233,7 @@ public:

    void readBitstreamToTree(const unsigned char* bitstream,  unsigned long int bufferSizeBytes, ReadBitstreamToTreeParams& args);
    void deleteOctalCodeFromTree(const unsigned char* codeBuffer, bool collapseEmptyTrees = DONT_COLLAPSE);
-    void reaverageOctreeElements(OctreeElementPointer startElement = NULL);
+    void reaverageOctreeElements(OctreeElementPointer startElement = OctreeElementPointer());

    void deleteOctreeElementAt(float x, float y, float z, float s);
    
@ -248,18 +248,18 @@ public:
    OctreeElementPointer getOrCreateChildElementAt(float x, float y, float z, float s);
    OctreeElementPointer getOrCreateChildElementContaining(const AACube& box);

-    void recurseTreeWithOperation(RecurseOctreeOperation operation, void* extraData = NULL);
-    void recurseTreeWithPostOperation(RecurseOctreeOperation operation, void* extraData = NULL);
+    void recurseTreeWithOperation(const RecurseOctreeOperation& operation, void* extraData = NULL);
+    void recurseTreeWithPostOperation(const RecurseOctreeOperation& operation, void* extraData = NULL);

    /// \param operation type of operation
    /// \param point point in world-frame (meters)
    /// \param extraData hook for user data to be interpreted by special context
-    void recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
+    void recurseTreeWithOperationDistanceSorted(const RecurseOctreeOperation& operation,
                                                const glm::vec3& point, void* extraData = NULL);

    void recurseTreeWithOperator(RecurseOctreeOperator* operatorObject);

-    int encodeTreeBitstream(OctreeElementPointer element, OctreePacketData* packetData, OctreeElementBag& bag,
+    int encodeTreeBitstream(const OctreeElementPointer& element, OctreePacketData* packetData, OctreeElementBag& bag,
                            EncodeBitstreamParams& params) ;
                            
    bool isDirty() const { return _isDirty; }
@ -293,8 +293,8 @@ public:
    void loadOctreeFile(const char* fileName);

    // Octree exporters
-    bool writeToFile(const char* filename, OctreeElementPointer element = NULL, QString persistAsFileType = "json.gz");
-    bool writeToJSONFile(const char* filename, OctreeElementPointer element = NULL, bool doGzip = false);
+    bool writeToFile(const char* filename, const OctreeElementPointer& element = NULL, QString persistAsFileType = "json.gz");
+    bool writeToJSONFile(const char* filename, const OctreeElementPointer& element = NULL, bool doGzip = false);
    virtual bool writeToMap(QVariantMap& entityDescription, OctreeElementPointer element, bool skipDefaultValues,
                            bool skipThoseWithBadParents) = 0;

@ -311,18 +311,18 @@ public:

    bool getShouldReaverage() const { return _shouldReaverage; }

-    void recurseElementWithOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
+    void recurseElementWithOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
                void* extraData, int recursionCount = 0);

    /// Traverse child nodes of node applying operation in post-fix order
    ///
-    void recurseElementWithPostOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
+    void recurseElementWithPostOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
                void* extraData, int recursionCount = 0);

-    void recurseElementWithOperationDistanceSorted(OctreeElementPointer element, RecurseOctreeOperation operation,
+    void recurseElementWithOperationDistanceSorted(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
                const glm::vec3& point, void* extraData, int recursionCount = 0);

-    bool recurseElementWithOperator(OctreeElementPointer element, RecurseOctreeOperator* operatorObject, int recursionCount = 0);
+    bool recurseElementWithOperator(const OctreeElementPointer& element, RecurseOctreeOperator* operatorObject, int recursionCount = 0);

    bool getIsViewing() const { return _isViewing; } /// This tree is receiving inbound viewer datagrams.
    void setIsViewing(bool isViewing) { _isViewing = isViewing; }
@ -353,18 +353,18 @@ public slots:


 protected:
-    void deleteOctalCodeFromTreeRecursion(OctreeElementPointer element, void* extraData);
+    void deleteOctalCodeFromTreeRecursion(const OctreeElementPointer& element, void* extraData);

-    int encodeTreeBitstreamRecursion(OctreeElementPointer element,
+    int encodeTreeBitstreamRecursion(const OctreeElementPointer& element,
                                     OctreePacketData* packetData, OctreeElementBag& bag,
                                     EncodeBitstreamParams& params, int& currentEncodeLevel,
                                     const ViewFrustum::intersection& parentLocationThisView) const;

-    static bool countOctreeElementsOperation(OctreeElementPointer element, void* extraData);
+    static bool countOctreeElementsOperation(const OctreeElementPointer& element, void* extraData);

-    OctreeElementPointer nodeForOctalCode(OctreeElementPointer ancestorElement, const unsigned char* needleCode, OctreeElementPointer* parentOfFoundElement) const;
-    OctreeElementPointer createMissingElement(OctreeElementPointer lastParentElement, const unsigned char* codeToReach, int recursionCount = 0);
-    int readElementData(OctreeElementPointer destinationElement, const unsigned char* nodeData,
+    OctreeElementPointer nodeForOctalCode(const OctreeElementPointer& ancestorElement, const unsigned char* needleCode, OctreeElementPointer* parentOfFoundElement) const;
+    OctreeElementPointer createMissingElement(const OctreeElementPointer& lastParentElement, const unsigned char* codeToReach, int recursionCount = 0);
+    int readElementData(const OctreeElementPointer& destinationElement, const unsigned char* nodeData,
                int bufferSizeBytes, ReadBitstreamToTreeParams& args);

    OctreeElementPointer _rootElement = nullptr;
--- a/libraries/octree/src/OctreeElement.cpp
+++ b/libraries/octree/src/OctreeElement.cpp
@ -233,7 +233,7 @@ OctreeElementPointer OctreeElement::removeChildAtIndex(int childIndex) {
    return returnedChild;
 }

-bool OctreeElement::isParentOf(OctreeElementPointer possibleChild) const {
+bool OctreeElement::isParentOf(const OctreeElementPointer& possibleChild) const {
    if (possibleChild) {
        for (int childIndex = 0; childIndex < NUMBER_OF_CHILDREN; childIndex++) {
            OctreeElementPointer childAt = getChildAtIndex(childIndex);
@ -300,7 +300,7 @@ void OctreeElement::deleteAllChildren() {
    }
 }

-void OctreeElement::setChildAtIndex(int childIndex, OctreeElementPointer child) {
+void OctreeElement::setChildAtIndex(int childIndex, const OctreeElementPointer& child) {
 #ifdef SIMPLE_CHILD_ARRAY
    int previousChildCount = getChildCount();
    if (child) {
--- a/libraries/octree/src/OctreeElement.h
+++ b/libraries/octree/src/OctreeElement.h
@ -122,7 +122,7 @@ public:
    OctreeElementPointer getChildAtIndex(int childIndex) const;
    void deleteChildAtIndex(int childIndex);
    OctreeElementPointer removeChildAtIndex(int childIndex);
-    bool isParentOf(OctreeElementPointer possibleChild) const;
+    bool isParentOf(const OctreeElementPointer& possibleChild) const;

    /// handles deletion of all descendants, returns false if delete not approved
    bool safeDeepDeleteChildAtIndex(int childIndex, int recursionCount = 0);
@ -222,7 +222,7 @@ public:
 protected:

    void deleteAllChildren();
-    void setChildAtIndex(int childIndex, OctreeElementPointer child);
+    void setChildAtIndex(int childIndex, const OctreeElementPointer& child);

    void calculateAACube();

--- a/libraries/octree/src/OctreeElementBag.cpp
+++ b/libraries/octree/src/OctreeElementBag.cpp
@ -23,7 +23,7 @@ bool OctreeElementBag::isEmpty() {
    return _bagElements.empty();
 }

-void OctreeElementBag::insert(OctreeElementPointer element) {
+void OctreeElementBag::insert(const OctreeElementPointer& element) {
    _bagElements[element.get()] = element;
 }

--- a/libraries/octree/src/OctreeElementBag.h
+++ b/libraries/octree/src/OctreeElementBag.h
@ -24,7 +24,7 @@ class OctreeElementBag {
    using Bag = std::unordered_map<OctreeElement*, OctreeElementWeakPointer>;
    
 public:
-    void insert(OctreeElementPointer element); // put a element into the bag
+    void insert(const OctreeElementPointer& element); // put a element into the bag

    OctreeElementPointer extract(); /// pull a element out of the bag (could come in any order) and if all of the
                                    /// elements have expired, a single null pointer will be returned
--- a/libraries/octree/src/OctreeProcessor.cpp
+++ b/libraries/octree/src/OctreeProcessor.cpp
@ -1,5 +1,5 @@
 //
-//  OctreeRenderer.cpp
+//  OctreeProcessor.cpp
 //  libraries/octree/src
 //
 //  Created by Brad Hefta-Gaub on 12/6/13.
@ -14,49 +14,48 @@

 #include <NumericalConstants.h>
 #include <PerfStat.h>
-#include <RenderArgs.h>
 #include <SharedUtil.h>

 #include "OctreeLogging.h"
-#include "OctreeRenderer.h"
+#include "OctreeProcessor.h"

-OctreeRenderer::OctreeRenderer() :
+OctreeProcessor::OctreeProcessor() :
    _tree(NULL),
    _managedTree(false)
 {
 }

-void OctreeRenderer::init() {
+void OctreeProcessor::init() {
    if (!_tree) {
        _tree = createTree();
        _managedTree = true;
    }
 }

-OctreeRenderer::~OctreeRenderer() {
+OctreeProcessor::~OctreeProcessor() {
 }

-void OctreeRenderer::setTree(OctreePointer newTree) {
+void OctreeProcessor::setTree(OctreePointer newTree) {
    _tree = newTree;
 }

-void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer sourceNode) {
+void OctreeProcessor::processDatagram(ReceivedMessage& message, SharedNodePointer sourceNode) {
    bool extraDebugging = false;

    if (extraDebugging) {
-        qCDebug(octree) << "OctreeRenderer::processDatagram()";
+        qCDebug(octree) << "OctreeProcessor::processDatagram()";
    }

    if (!_tree) {
-        qCDebug(octree) << "OctreeRenderer::processDatagram() called before init, calling init()...";
+        qCDebug(octree) << "OctreeProcessor::processDatagram() called before init, calling init()...";
        this->init();
    }

    bool showTimingDetails = false; // Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
-    PerformanceWarning warn(showTimingDetails, "OctreeRenderer::processDatagram()", showTimingDetails);
+    PerformanceWarning warn(showTimingDetails, "OctreeProcessor::processDatagram()", showTimingDetails);
    
    if (message.getType() == getExpectedPacketType()) {
-        PerformanceWarning warn(showTimingDetails, "OctreeRenderer::processDatagram expected PacketType", showTimingDetails);
+        PerformanceWarning warn(showTimingDetails, "OctreeProcessor::processDatagram expected PacketType", showTimingDetails);
        // if we are getting inbound packets, then our tree is also viewing, and we should remember that fact.
        _tree->setIsViewing(true);
        
@ -79,7 +78,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
        OCTREE_PACKET_INTERNAL_SECTION_SIZE sectionLength = 0;

        if (extraDebugging) {
-            qCDebug(octree) << "OctreeRenderer::processDatagram() ... "
+            qCDebug(octree) << "OctreeProcessor::processDatagram() ... "
                               "Got Packet Section color:" << packetIsColored <<
                               "compressed:" << packetIsCompressed <<
                               "sequence: " <<  sequence << 
@ -130,7 +129,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
                    packetData.loadFinalizedContent(reinterpret_cast<const unsigned char*>(message.getRawMessage() + message.getPosition()),
                        sectionLength);
                    if (extraDebugging) {
-                        qCDebug(octree) << "OctreeRenderer::processDatagram() ... "
+                        qCDebug(octree) << "OctreeProcessor::processDatagram() ... "
                            "Got Packet Section color:" << packetIsColored <<
                            "compressed:" << packetIsCompressed <<
                            "sequence: " << sequence <<
@ -143,13 +142,13 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
                    }

                    if (extraDebugging) {
-                        qCDebug(octree) << "OctreeRenderer::processDatagram() ******* START _tree->readBitstreamToTree()...";
+                        qCDebug(octree) << "OctreeProcessor::processDatagram() ******* START _tree->readBitstreamToTree()...";
                    }
                    startReadBitsteam = usecTimestampNow();
                    _tree->readBitstreamToTree(packetData.getUncompressedData(), packetData.getUncompressedSize(), args);
                    endReadBitsteam = usecTimestampNow();
                    if (extraDebugging) {
-                        qCDebug(octree) << "OctreeRenderer::processDatagram() ******* END _tree->readBitstreamToTree()...";
+                        qCDebug(octree) << "OctreeProcessor::processDatagram() ******* END _tree->readBitstreamToTree()...";
                    }
                });
                
@ -198,32 +197,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
    }
 }

-bool OctreeRenderer::renderOperation(OctreeElementPointer element, void* extraData) {
-    RenderArgs* args = static_cast<RenderArgs*>(extraData);
-    if (element->isInView(args->getViewFrustum())) {
-        if (element->hasContent()) {
-            if (element->calculateShouldRender(args->getViewFrustum(), args->_sizeScale, args->_boundaryLevelAdjust)) {
-                args->_renderer->renderElement(element, args);
-            } else {
-                return false; // if we shouldn't render, then we also should stop recursing.
-            }
-        }
-        return true; // continue recursing
-    }
-    // if not in view stop recursing
-    return false;
-}
-
-void OctreeRenderer::render(RenderArgs* renderArgs) {
-    if (_tree) {
-        renderArgs->_renderer = sharedFromThis();
-        _tree->withReadLock([&] {
-            _tree->recurseTreeWithOperation(renderOperation, renderArgs);
-        });
-    }
-}
-
-void OctreeRenderer::clear() {
+void OctreeProcessor::clear() {
    if (_tree) {
        _tree->withWriteLock([&] {
            _tree->eraseAllOctreeElements();
--- a/libraries/octree/src/OctreeProcessor.h
+++ b/libraries/octree/src/OctreeProcessor.h
@ -1,5 +1,5 @@
 //
-//  OctreeRenderer.h
+//  OctreeProcessor.h
 //  libraries/octree/src
 //
 //  Created by Brad Hefta-Gaub on 12/6/13.
@ -9,8 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#ifndef hifi_OctreeRenderer_h
-#define hifi_OctreeRenderer_h
+#ifndef hifi_OctreeProcessor_h
+#define hifi_OctreeProcessor_h

 #include <glm/glm.hpp>
 #include <stdint.h>
@ -18,27 +18,22 @@
 #include <QObject>

 #include <udt/PacketHeaders.h>
-#include <RenderArgs.h>
 #include <SharedUtil.h>
-#include <ViewFrustum.h>

 #include "Octree.h"
 #include "OctreePacketData.h"

-class OctreeRenderer;
-

 // Generic client side Octree renderer class.
-class OctreeRenderer : public QObject, public QEnableSharedFromThis<OctreeRenderer> {
+class OctreeProcessor : public QObject, public QEnableSharedFromThis<OctreeProcessor> {
    Q_OBJECT
 public:
-    OctreeRenderer();
-    virtual ~OctreeRenderer();
+    OctreeProcessor();
+    virtual ~OctreeProcessor();

    virtual char getMyNodeType() const = 0;
    virtual PacketType getMyQueryMessageType() const = 0;
    virtual PacketType getExpectedPacketType() const = 0;
-    virtual void renderElement(OctreeElementPointer element, RenderArgs* args) { }

    virtual void setTree(OctreePointer newTree);

@ -48,14 +43,6 @@ public:
    /// initialize and GPU/rendering related resources
    virtual void init();

-    /// render the content of the octree
-    virtual void render(RenderArgs* renderArgs);
-
-    const ViewFrustum& getViewFrustum() const { return _viewFrustum; }
-    void setViewFrustum(const ViewFrustum& viewFrustum) { _viewFrustum = viewFrustum; }
-
-    static bool renderOperation(OctreeElementPointer element, void* extraData);
-
    /// clears the tree
    virtual void clear();

@ -75,7 +62,6 @@ protected:

    OctreePointer _tree;
    bool _managedTree;
-    ViewFrustum _viewFrustum;

    SimpleMovingAverage _elementsPerPacket;
    SimpleMovingAverage _entitiesPerPacket;
@ -95,4 +81,4 @@ protected:

 };

-#endif // hifi_OctreeRenderer_h
+#endif // hifi_OctreeProcessor_h
--- a/libraries/octree/src/OctreeSceneStats.cpp
+++ b/libraries/octree/src/OctreeSceneStats.cpp
@ -141,7 +141,7 @@ OctreeSceneStats::~OctreeSceneStats() {
    reset();
 }

-void OctreeSceneStats::sceneStarted(bool isFullScene, bool isMoving, OctreeElementPointer root,
+void OctreeSceneStats::sceneStarted(bool isFullScene, bool isMoving, const OctreeElementPointer& root,
                                    JurisdictionMap* jurisdictionMap) {
    reset(); // resets packet and octree stats
    _isStarted = true;
@ -246,7 +246,7 @@ void OctreeSceneStats::packetSent(int bytes) {
    _bytes += bytes;
 }

-void OctreeSceneStats::traversed(const OctreeElementPointer element) {
+void OctreeSceneStats::traversed(const OctreeElementPointer& element) {
    _traversed++;
    if (element->isLeaf()) {
        _leaves++;
@ -255,7 +255,7 @@ void OctreeSceneStats::traversed(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::skippedDistance(const OctreeElementPointer element) {
+void OctreeSceneStats::skippedDistance(const OctreeElementPointer& element) {
    _skippedDistance++;
    if (element->isLeaf()) {
        _leavesSkippedDistance++;
@ -264,7 +264,7 @@ void OctreeSceneStats::skippedDistance(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer element) {
+void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer& element) {
    _skippedOutOfView++;
    if (element->isLeaf()) {
        _leavesSkippedOutOfView++;
@ -273,7 +273,7 @@ void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::skippedWasInView(const OctreeElementPointer element) {
+void OctreeSceneStats::skippedWasInView(const OctreeElementPointer& element) {
    _skippedWasInView++;
    if (element->isLeaf()) {
        _leavesSkippedWasInView++;
@ -282,7 +282,7 @@ void OctreeSceneStats::skippedWasInView(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::skippedNoChange(const OctreeElementPointer element) {
+void OctreeSceneStats::skippedNoChange(const OctreeElementPointer& element) {
    _skippedNoChange++;
    if (element->isLeaf()) {
        _leavesSkippedNoChange++;
@ -291,7 +291,7 @@ void OctreeSceneStats::skippedNoChange(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::skippedOccluded(const OctreeElementPointer element) {
+void OctreeSceneStats::skippedOccluded(const OctreeElementPointer& element) {
    _skippedOccluded++;
    if (element->isLeaf()) {
        _leavesSkippedOccluded++;
@ -300,7 +300,7 @@ void OctreeSceneStats::skippedOccluded(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::colorSent(const OctreeElementPointer element) {
+void OctreeSceneStats::colorSent(const OctreeElementPointer& element) {
    _colorSent++;
    if (element->isLeaf()) {
        _leavesColorSent++;
@ -309,7 +309,7 @@ void OctreeSceneStats::colorSent(const OctreeElementPointer element) {
    }
 }

-void OctreeSceneStats::didntFit(const OctreeElementPointer element) {
+void OctreeSceneStats::didntFit(const OctreeElementPointer& element) {
    _didntFit++;
    if (element->isLeaf()) {
        _leavesDidntFit++;
--- a/libraries/octree/src/OctreeSceneStats.h
+++ b/libraries/octree/src/OctreeSceneStats.h
@ -39,7 +39,7 @@ public:
    OctreeSceneStats& operator= (const OctreeSceneStats& other); // copy assignment

    /// Call when beginning the computation of a scene. Initializes internal structures
-    void sceneStarted(bool fullScene, bool moving, OctreeElementPointer root, JurisdictionMap* jurisdictionMap);
+    void sceneStarted(bool fullScene, bool moving, const OctreeElementPointer& root, JurisdictionMap* jurisdictionMap);
    bool getIsSceneStarted() const { return _isStarted; }

    /// Call when the computation of a scene is completed. Finalizes internal structures
@ -57,28 +57,28 @@ public:
    void encodeStopped();

    /// Track that a element was traversed as part of computation of a scene.
-    void traversed(const OctreeElementPointer element);
+    void traversed(const OctreeElementPointer& element);

    /// Track that a element was skipped as part of computation of a scene due to being beyond the LOD distance.
-    void skippedDistance(const OctreeElementPointer element);
+    void skippedDistance(const OctreeElementPointer& element);

    /// Track that a element was skipped as part of computation of a scene due to being out of view.
-    void skippedOutOfView(const OctreeElementPointer element);
+    void skippedOutOfView(const OctreeElementPointer& element);

    /// Track that a element was skipped as part of computation of a scene due to previously being in view while in delta sending
-    void skippedWasInView(const OctreeElementPointer element);
+    void skippedWasInView(const OctreeElementPointer& element);

    /// Track that a element was skipped as part of computation of a scene due to not having changed since last full scene sent
-    void skippedNoChange(const OctreeElementPointer element);
+    void skippedNoChange(const OctreeElementPointer& element);

    /// Track that a element was skipped as part of computation of a scene due to being occluded
-    void skippedOccluded(const OctreeElementPointer element);
+    void skippedOccluded(const OctreeElementPointer& element);

    /// Track that a element's color was was sent as part of computation of a scene
-    void colorSent(const OctreeElementPointer element);
+    void colorSent(const OctreeElementPointer& element);

    /// Track that a element was due to be sent, but didn't fit in the packet and was moved to next packet
-    void didntFit(const OctreeElementPointer element);
+    void didntFit(const OctreeElementPointer& element);

    /// Track that the color bitmask was was sent as part of computation of a scene
    void colorBitsWritten();
--- a/libraries/physics/CMakeLists.txt
+++ b/libraries/physics/CMakeLists.txt
@ -1,5 +1,11 @@
 set(TARGET_NAME physics)
 setup_hifi_library()
 link_hifi_libraries(shared fbx entities model)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(gpu)
+include_hifi_library_headers(avatars)
+include_hifi_library_headers(audio)
+include_hifi_library_headers(octree)
+include_hifi_library_headers(animation)

 target_bullet()
--- a/libraries/render-utils/CMakeLists.txt
+++ b/libraries/render-utils/CMakeLists.txt
@ -4,6 +4,9 @@ AUTOSCRIBE_SHADER_LIB(gpu model render)
 qt5_add_resources(QT_RESOURCES_FILE "${CMAKE_CURRENT_SOURCE_DIR}/res/fonts/fonts.qrc")
 setup_hifi_library(Widgets OpenGL Network Qml Quick Script)
 link_hifi_libraries(shared ktx gpu model model-networking render animation fbx entities image procedural)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(octree)
+include_hifi_library_headers(audio)

 if (NOT ANDROID)
  target_nsight()
--- a/libraries/render-utils/src/DeferredFrameTransform.h
+++ b/libraries/render-utils/src/DeferredFrameTransform.h
@ -12,10 +12,10 @@
 #ifndef hifi_DeferredFrameTransform_h
 #define hifi_DeferredFrameTransform_h

-#include "gpu/Resource.h"
-#include "render/DrawTask.h"
+#include <gpu/Resource.h>

-class RenderArgs;
+#include <render/Forward.h>
+#include <render/DrawTask.h>

 // DeferredFrameTransform is  a helper class gathering in one place the needed camera transform
 // and frame resolution needed for all the deferred rendering passes taking advantage of the Deferred buffers
--- a/libraries/render-utils/src/DeferredFramebuffer.h
+++ b/libraries/render-utils/src/DeferredFramebuffer.h
@ -15,7 +15,6 @@
 #include "gpu/Resource.h"
 #include "gpu/Framebuffer.h"

-class RenderArgs;

 // DeferredFramebuffer is  a helper class gathering in one place the GBuffer (Framebuffer) and lighting framebuffer
 class DeferredFramebuffer {
--- a/libraries/render-utils/src/DeferredLightingEffect.h
+++ b/libraries/render-utils/src/DeferredLightingEffect.h
@ -37,7 +37,6 @@
 #include "AmbientOcclusionEffect.h"


-class RenderArgs;
 struct LightLocations;
 using LightLocationsPtr = std::shared_ptr<LightLocations>;

--- a/libraries/render-utils/src/LightingModel.h
+++ b/libraries/render-utils/src/LightingModel.h
@ -12,10 +12,10 @@
 #ifndef hifi_LightingModel_h
 #define hifi_LightingModel_h

-#include "gpu/Resource.h"
-#include "render/DrawTask.h"
+#include <gpu/Resource.h>

-class RenderArgs;
+#include <render/Forward.h>
+#include <render/DrawTask.h>

 // LightingModel is  a helper class gathering in one place the flags to enable the lighting contributions
 class LightingModel {
--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@ -557,6 +557,7 @@ void ModelMeshPartPayload::render(RenderArgs* args) {

    if (_fadeState == FADE_WAITING_TO_START) {
        if (model->isLoaded()) {
+            // FIXME as far as I can tell this is the ONLY reason render-util depends on entities.
            if (EntityItem::getEntitiesShouldFadeFunction()()) {
                _fadeStartTime = usecTimestampNow();
                _fadeState = FADE_IN_PROGRESS;
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@ -9,6 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

+#include "Model.h"
+
 #include <QMetaType>
 #include <QRunnable>
 #include <QThreadPool>
@ -24,7 +26,6 @@

 #include "AbstractViewStateInterface.h"
 #include "MeshPartPayload.h"
-#include "Model.h"

 #include "RenderUtilsLogging.h"
 #include <Trace.h>
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@ -25,6 +25,7 @@
 #include <DependencyManager.h>
 #include <GeometryUtil.h>
 #include <gpu/Batch.h>
+#include <render/Forward.h>
 #include <render/Scene.h>
 #include <Transform.h>
 #include <SpatiallyNestable.h>
@ -34,10 +35,10 @@
 #include "TextureCache.h"
 #include "Rig.h"

+
 class AbstractViewStateInterface;
 class QScriptEngine;

-#include "RenderArgs.h"
 class ViewFrustum;

 namespace render {
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@ -14,7 +14,6 @@

 #include <PerfStat.h>
 #include <PathUtils.h>
-#include <RenderArgs.h>
 #include <ViewFrustum.h>
 #include <gpu/Context.h>

--- a/libraries/render-utils/src/RenderForwardTask.cpp
+++ b/libraries/render-utils/src/RenderForwardTask.cpp
@ -15,7 +15,6 @@

 #include <PerfStat.h>
 #include <PathUtils.h>
-#include <RenderArgs.h>
 #include <ViewFrustum.h>
 #include <gpu/Context.h>

--- a/libraries/render-utils/src/StencilMaskPass.cpp
+++ b/libraries/render-utils/src/StencilMaskPass.cpp
@ -11,7 +11,6 @@

 #include "StencilMaskPass.h"

-#include <RenderArgs.h>
 #include <ViewFrustum.h>
 #include <gpu/Context.h>

--- a/Show more
+++ b/Show more