merge with upstream team-teaching

assignment-client/src/octree/OctreeQueryNode.cpp

@@ -325,8 +325,7 @@ void OctreeQueryNode::updateLastKnownViewFrustum() {
     }
 
     // save that we know the view has been sent.
-    quint64 now = usecTimestampNow();
+    setLastTimeBagEmpty();
-    setLastTimeBagEmpty(now); // is this what we want? poor names
 }
 
 

assignment-client/src/octree/OctreeQueryNode.h

@@ -77,7 +77,7 @@ public:
     bool moveShouldDump() const;
 
     quint64 getLastTimeBagEmpty() const { return _lastTimeBagEmpty; }
-    void setLastTimeBagEmpty(quint64 lastTimeBagEmpty) { _lastTimeBagEmpty = lastTimeBagEmpty; }
+    void setLastTimeBagEmpty() { _lastTimeBagEmpty = _sceneSendStartTime; }
 
     bool getCurrentPacketIsColor() const { return _currentPacketIsColor; }
     bool getCurrentPacketIsCompressed() const { return _currentPacketIsCompressed; }
@@ -98,6 +98,8 @@ public:
     void setLastRootTimestamp(quint64 timestamp) { _lastRootTimestamp = timestamp; }
     unsigned int getlastOctreePacketLength() const { return _lastOctreePacketLength; }
     int getDuplicatePacketCount() const { return _duplicatePacketCount; }
+
+    void sceneStart(quint64 sceneSendStartTime) { _sceneSendStartTime = sceneSendStartTime; }
     
     void nodeKilled();
     void forceNodeShutdown();
@@ -158,6 +160,8 @@ private:
 
     SentPacketHistory _sentPacketHistory;
     QQueue<OCTREE_PACKET_SEQUENCE> _nackedSequenceNumbers;
+
+    quint64 _sceneSendStartTime = 0;
 };
 
 #endif // hifi_OctreeQueryNode_h

assignment-client/src/octree/OctreeSendThread.cpp

@@ -343,8 +343,7 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
 
         if (!viewFrustumChanged && !nodeData->getWantDelta()) {
             // only set our last sent time if we weren't resetting due to frustum change
-            quint64 now = usecTimestampNow();
+            nodeData->setLastTimeBagEmpty();
-            nodeData->setLastTimeBagEmpty(now);
         }
 
         // track completed scenes and send out the stats packet accordingly
@@ -368,9 +367,11 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
 
         // TODO: add these to stats page
         //::startSceneSleepTime = _usleepTime;
-        
+
+        nodeData->sceneStart(usecTimestampNow() - CHANGE_FUDGE);
         // start tracking our stats
-        nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged, _myServer->getOctree()->getRoot(), _myServer->getJurisdiction());
+        nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged,
+                                     _myServer->getOctree()->getRoot(), _myServer->getJurisdiction());
 
         // This is the start of "resending" the scene.
         bool dontRestartSceneOnMove = false; // this is experimental
@@ -561,6 +562,13 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
         }
 
 
+        if (somethingToSend) {
+            qDebug() << "Hit PPS Limit, packetsSentThisInterval =" << packetsSentThisInterval
+                     << "  maxPacketsPerInterval = " << maxPacketsPerInterval
+                     << "  clientMaxPacketsPerInterval = " << clientMaxPacketsPerInterval;
+        }
+
+
         // Here's where we can/should allow the server to send other data...
         // send the environment packet
         // TODO: should we turn this into a while loop to better handle sending multiple special packets

examples/defaultScripts.js

@@ -15,7 +15,6 @@ Script.load("controllers/hydra/hydraMove.js");
 Script.load("inspect.js");
 Script.load("lobby.js");
 Script.load("notifications.js");
-Script.load("look.js");
 Script.load("users.js");
 Script.load("grab.js");
 Script.load("pointer.js");

examples/look.js

@@ -1,183 +0,0 @@
-//
-//  look.js
-//  examples
-//
-//  Copyright 2015 High Fidelity, Inc.
-//
-//  This is an example script that demonstrates use of the Controller class
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-var wantDebugging = false;
-
-
-// Configuration
-var TOUCH_YAW_SCALE = -0.25;
-var TOUCH_PITCH_SCALE = -12.5;
-var FIXED_TOUCH_TIMESTEP = 0.016;
-
-var MOUSE_YAW_SCALE = -0.25;
-var MOUSE_PITCH_SCALE = -12.5;
-var FIXED_MOUSE_TIMESTEP = 0.016;
-
-// Mouse Data
-var alwaysLook = false; // if you want the mouse look to happen only when you click, change this to false
-var isMouseDown = false;
-var lastTouchX = 0;
-var lastTouchY = 0;
-var yawFromTouch = 0;
-var pitchFromTouch = 0;
-
-// Touch Data
-var TIME_BEFORE_GENERATED_END_TOUCH_EVENT = 50; // ms
-var startedTouching = false;
-var lastTouchEvent = 0;
-var lastMouseX = 0;
-var lastMouseY = 0;
-var yawFromMouse = 0;
-var pitchFromMouse = 0;
-
-
-// Mouse Events
-function mousePressEvent(event) {
-    if (wantDebugging) {
-        print("mousePressEvent event.x,y=" + event.x + ", " + event.y);
-    }
-    if (event.isRightButton) {
-        isMouseDown = true;
-        lastMouseX = event.x;
-        lastMouseY = event.y;
-    }
-}
-
-function mouseReleaseEvent(event) {
-    if (wantDebugging) {
-        print("mouseReleaseEvent event.x,y=" + event.x + ", " + event.y);
-    }
-    isMouseDown = false;
-}
-
-function mouseMoveEvent(event) {
-    if (wantDebugging) {
-        print("mouseMoveEvent event.x,y=" + event.x + ", " + event.y);
-    }
-
-    if (alwaysLook || isMouseDown) {
-        yawFromMouse += ((event.x - lastMouseX) * MOUSE_YAW_SCALE * FIXED_MOUSE_TIMESTEP);
-        pitchFromMouse += ((event.y - lastMouseY) * MOUSE_PITCH_SCALE * FIXED_MOUSE_TIMESTEP);
-        lastMouseX = event.x;
-        lastMouseY = event.y;
-    }
-}
-
-// Touch Events
-function touchBeginEvent(event) {
-    if (wantDebugging) {
-        print("touchBeginEvent event.x,y=" + event.x + ", " + event.y);
-    }
-    lastTouchX = event.x;
-    lastTouchY = event.y;
-    yawFromTouch = 0;
-    pitchFromTouch = 0;
-    startedTouching = true;
-    var d = new Date();
-    lastTouchEvent = d.getTime();
-}
-
-function touchEndEvent(event) {
-    if (wantDebugging) {
-        if (event) {
-            print("touchEndEvent event.x,y=" + event.x + ", " + event.y);
-        } else {
-            print("touchEndEvent generated");
-        }
-    }
-    startedTouching = false;
-}
-
-function touchUpdateEvent(event) {
-    // print("TOUCH UPDATE");
-    if (wantDebugging) {
-        print("touchUpdateEvent event.x,y=" + event.x + ", " + event.y);
-    }
-
-    if (!startedTouching) {
-        // handle Qt 5.4.x bug where we get touch update without a touch begin event
-        touchBeginEvent(event);
-        return;
-    }
-
-    yawFromTouch += ((event.x - lastTouchX) * TOUCH_YAW_SCALE * FIXED_TOUCH_TIMESTEP);
-    pitchFromTouch += ((event.y - lastTouchY) * TOUCH_PITCH_SCALE * FIXED_TOUCH_TIMESTEP);
-    lastTouchX = event.x;
-    lastTouchY = event.y;
-    var d = new Date();
-    lastTouchEvent = d.getTime();
-}
-
-
-function update(deltaTime) {
-    if (wantDebugging) {
-        print("update()...");
-    }
-    
-    if (startedTouching) {
-        var d = new Date();
-        var sinceLastTouch = d.getTime() - lastTouchEvent;
-        if (sinceLastTouch > TIME_BEFORE_GENERATED_END_TOUCH_EVENT) {
-            touchEndEvent();
-        }
-    }
-
-    if (yawFromTouch != 0 || yawFromMouse != 0) {
-        var newOrientation = Quat.multiply(MyAvatar.orientation, Quat.fromPitchYawRollRadians(0, yawFromTouch + yawFromMouse, 0));
-
-        if (wantDebugging) {
-            print("changing orientation"
-                + " [old]MyAvatar.orientation="+MyAvatar.orientation.x + "," + MyAvatar.orientation.y + ","
-                + MyAvatar.orientation.z + "," + MyAvatar.orientation.w
-                + " newOrientation="+newOrientation.x + "," + newOrientation.y + "," + newOrientation.z + "," + newOrientation.w);
-        }
-
-        MyAvatar.orientation = newOrientation;
-        yawFromTouch = 0;
-        yawFromMouse = 0;
-    }
-
-    if (pitchFromTouch != 0 || pitchFromMouse != 0) {
-        var newPitch = MyAvatar.headPitch + pitchFromTouch + pitchFromMouse;
-
-        if (wantDebugging) {
-            print("changing pitch [old]MyAvatar.headPitch="+MyAvatar.headPitch+ " newPitch="+newPitch);
-        }
-
-        MyAvatar.headPitch = newPitch;
-        pitchFromTouch = 0;
-        pitchFromMouse = 0;
-    }
-}
-
-
-// Map the mouse events to our functions
-Controller.mousePressEvent.connect(mousePressEvent);
-Controller.mouseMoveEvent.connect(mouseMoveEvent);
-Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
-
-// Map the mouse events to our functions
-Controller.touchBeginEvent.connect(touchBeginEvent);
-Controller.touchUpdateEvent.connect(touchUpdateEvent);
-Controller.touchEndEvent.connect(touchEndEvent);
-
-// disable the standard application for mouse events
-Controller.captureTouchEvents();
-
-function scriptEnding() {
-    // re-enabled the standard application for mouse events
-    Controller.releaseTouchEvents();
-}
-
-// would be nice to change to update
-Script.update.connect(update);
-Script.scriptEnding.connect(scriptEnding);

interface/src/Application.cpp

@@ -116,6 +116,7 @@
 #include "devices/TV3DManager.h"
 
 #include "gpu/Batch.h"
+#include "gpu/Context.h"
 #include "gpu/GLBackend.h"
 
 #include "scripting/AccountScriptingInterface.h"
@@ -835,6 +836,13 @@ void Application::initializeUi() {
 void Application::paintGL() {
     PROFILE_RANGE(__FUNCTION__);
     _glWidget->makeCurrent();
+
+    auto lodManager = DependencyManager::get<LODManager>();
+    gpu::Context context;
+    RenderArgs renderArgs(&context, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
+                          lodManager->getBoundaryLevelAdjust(), RenderArgs::DEFAULT_RENDER_MODE,
+                          RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
+
     PerformanceTimer perfTimer("paintGL");
     //Need accurate frame timing for the oculus rift
     if (OculusManager::isConnected()) {
@@ -848,7 +856,7 @@ void Application::paintGL() {
 
     {
         PerformanceTimer perfTimer("renderOverlay");
-        _applicationOverlay.renderOverlay();
+        _applicationOverlay.renderOverlay(&renderArgs);
     }
 
     glEnable(GL_LINE_SMOOTH);
@@ -897,22 +905,25 @@ void Application::paintGL() {
     loadViewFrustum(_myCamera, _viewFrustum);
 
     if (getShadowsEnabled()) {
-        updateShadowMap();
+        renderArgs._renderMode = RenderArgs::SHADOW_RENDER_MODE;
+        updateShadowMap(&renderArgs);
     }
 
+    renderArgs._renderMode = RenderArgs::DEFAULT_RENDER_MODE;
+
     if (OculusManager::isConnected()) {
         //When in mirror mode, use camera rotation. Otherwise, use body rotation
         if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
-            OculusManager::display(_glWidget, _myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
+            OculusManager::display(_glWidget, &renderArgs, _myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
         } else {
-            OculusManager::display(_glWidget, _myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
+            OculusManager::display(_glWidget, &renderArgs, _myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
         }
     } else if (TV3DManager::isConnected()) {
        
-        TV3DManager::display(_myCamera);
+        TV3DManager::display(&renderArgs, _myCamera);
 
     } else {
-        DependencyManager::get<GlowEffect>()->prepare();
+        DependencyManager::get<GlowEffect>()->prepare(&renderArgs);
 
         // Viewport is assigned to the size of the framebuffer
         QSize size = DependencyManager::get<TextureCache>()->getFrameBufferSize();
@@ -921,16 +932,16 @@ void Application::paintGL() {
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
         glLoadIdentity();
-        displaySide(_myCamera);
+        displaySide(&renderArgs, _myCamera);
         glPopMatrix();
 
         if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
-            _rearMirrorTools->render(true, _glWidget->mapFromGlobal(QCursor::pos()));
+            _rearMirrorTools->render(&renderArgs, true, _glWidget->mapFromGlobal(QCursor::pos()));
         } else if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
-            renderRearViewMirror(_mirrorViewRect);       
+            renderRearViewMirror(&renderArgs, _mirrorViewRect);       
         }
 
-        auto finalFbo = DependencyManager::get<GlowEffect>()->render();
+        auto finalFbo = DependencyManager::get<GlowEffect>()->render(&renderArgs);
 
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
         glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));
@@ -2884,7 +2895,7 @@ glm::vec3 Application::getSunDirection() {
 // FIXME, preprocessor guard this check to occur only in DEBUG builds
 static QThread * activeRenderingThread = nullptr;
 
-void Application::updateShadowMap() {
+void Application::updateShadowMap(RenderArgs* renderArgs) {
     activeRenderingThread = QThread::currentThread();
 
     PerformanceTimer perfTimer("shadowMap");
@@ -3005,23 +3016,23 @@ void Application::updateShadowMap() {
 
         {
             PerformanceTimer perfTimer("avatarManager");
-            DependencyManager::get<AvatarManager>()->renderAvatars(RenderArgs::SHADOW_RENDER_MODE);
+            DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs);
         }
 
         {
             PerformanceTimer perfTimer("entities");
-            _entities.render(RenderArgs::SHADOW_RENDER_MODE);
+            _entities.render(renderArgs);
         }
 
         // render JS/scriptable overlays
         {
             PerformanceTimer perfTimer("3dOverlays");
-            _overlays.renderWorld(false, RenderArgs::SHADOW_RENDER_MODE);
+            _overlays.renderWorld(renderArgs, false);
         }
 
         {
             PerformanceTimer perfTimer("3dOverlaysFront");
-            _overlays.renderWorld(true, RenderArgs::SHADOW_RENDER_MODE);
+            _overlays.renderWorld(renderArgs, true);
         }
 
         glDisable(GL_POLYGON_OFFSET_FILL);
@@ -3089,15 +3100,16 @@ PickRay Application::computePickRay(float x, float y) const {
     return result;
 }
 
-QImage Application::renderAvatarBillboard() {
+QImage Application::renderAvatarBillboard(RenderArgs* renderArgs) {
     auto primaryFramebuffer = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
     glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(primaryFramebuffer));
 
     // the "glow" here causes an alpha of one
-    Glower glower;
+    Glower glower(renderArgs);
 
     const int BILLBOARD_SIZE = 64;
-    renderRearViewMirror(QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,
+    // TODO: Pass a RenderArgs to renderAvatarBillboard
+    renderRearViewMirror(renderArgs, QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,
                                BILLBOARD_SIZE, BILLBOARD_SIZE),
                          true);
 
@@ -3152,6 +3164,7 @@ const ViewFrustum* Application::getDisplayViewFrustum() const {
 class MyFirstStuff {
 public:
     typedef render::Payload<MyFirstStuff> Payload;
+    typedef std::shared_ptr<Payload> PayloadPointer;
     typedef std::shared_ptr<MyFirstStuff> Pointer;
         
 };
@@ -3164,8 +3177,7 @@ template <> void render::payloadRender(const MyFirstStuff::Pointer& stuff, Rende
     }
 }
 
-
+void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool selfAvatarOnly) {
-void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs::RenderSide renderSide) {
     activeRenderingThread = QThread::currentThread();
     PROFILE_RANGE(__FUNCTION__);
     PerformanceTimer perfTimer("display");
@@ -3204,7 +3216,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
     if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
          viewTransform.setScale(Transform::Vec3(-1.0f, 1.0f, 1.0f));
     }
-    if (renderSide != RenderArgs::MONO) {
+    if (renderArgs->_renderSide != RenderArgs::MONO) {
         glm::mat4 invView = glm::inverse(_untranslatedViewMatrix);
         
         viewTransform.evalFromRawMatrix(invView);
@@ -3335,7 +3347,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
         // render JS/scriptable overlays
         {
             PerformanceTimer perfTimer("3dOverlays");
-            _overlays.renderWorld(false);
+            _overlays.renderWorld(renderArgs, false);
         }
         
         // render models...
@@ -3357,7 +3369,9 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
             if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
                 renderMode = RenderArgs::MIRROR_RENDER_MODE;
             }
-            _entities.render(renderMode, renderSide, renderDebugFlags);
+            renderArgs->_renderMode = renderMode;
+            renderArgs->_debugFlags = renderDebugFlags;
+            _entities.render(renderArgs);
             
             if (!Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) {
                 // Restaure polygon mode
@@ -3378,14 +3392,15 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
     
     {
         PerformanceTimer perfTimer("avatars");
-        DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
+        renderArgs->_renderMode = mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE;
-            false, selfAvatarOnly);   
+        DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs, false, selfAvatarOnly);   
+        renderArgs->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
     }
 
     static render::ItemID myFirstRenderItem = 0;
 
     if (myFirstRenderItem == 0) {
-        std::shared_ptr<MyFirstStuff::Payload> myFirstPayload(new MyFirstStuff::Payload(std::shared_ptr<MyFirstStuff>(new MyFirstStuff())));
+        auto myFirstPayload = MyFirstStuff::PayloadPointer(new MyFirstStuff::Payload(std::shared_ptr<MyFirstStuff>(new MyFirstStuff())));
         myFirstRenderItem = _main3DScene->allocateID();
 
         render::Scene::PendingChanges pendingChanges;
@@ -3413,8 +3428,9 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
 
     {
         PerformanceTimer perfTimer("avatarsPostLighting");
-        DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
+        renderArgs->_renderMode = mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE;
-            true, selfAvatarOnly);   
+        DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs, true, selfAvatarOnly);
+        renderArgs->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
     }
     
     //Render the sixense lasers
@@ -3438,7 +3454,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
                 "Application::displaySide() ... octree fades...");
             _octreeFadesLock.lockForWrite();
             for(std::vector<OctreeFade>::iterator fade = _octreeFades.begin(); fade != _octreeFades.end();) {
-                fade->render();
+                fade->render(renderArgs);
                 if(fade->isDone()) {
                     fade = _octreeFades.erase(fade);
                 } else {
@@ -3463,8 +3479,8 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
     {
         PerformanceTimer perfTimer("3dOverlaysFront");
         glClear(GL_DEPTH_BUFFER_BIT);
-        Glower glower;  // Sets alpha to 1.0
+        Glower glower(renderArgs);  // Sets alpha to 1.0
-        _overlays.renderWorld(true);
+        _overlays.renderWorld(renderArgs, true);
     }
     activeRenderingThread = nullptr;
 }
@@ -3542,7 +3558,7 @@ glm::vec2 Application::getScaledScreenPoint(glm::vec2 projectedPoint) {
     return screenPoint;
 }
 
-void Application::renderRearViewMirror(const QRect& region, bool billboard) {
+void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& region, bool billboard) {
     // Grab current viewport to reset it at the end
     int viewport[4];
     glGetIntegerv(GL_VIEWPORT, viewport);
@@ -3602,11 +3618,11 @@ void Application::renderRearViewMirror(const QRect& region, bool billboard) {
 
     // render rear mirror view
     glPushMatrix();
-    displaySide(_mirrorCamera, true);
+    displaySide(renderArgs, _mirrorCamera, true);
     glPopMatrix();
 
     if (!billboard) {
-        _rearMirrorTools->render(false, _glWidget->mapFromGlobal(QCursor::pos()));
+        _rearMirrorTools->render(renderArgs, false, _glWidget->mapFromGlobal(QCursor::pos()));
     }
 
     // reset Viewport and projection matrix

interface/src/Application.h

@@ -269,9 +269,9 @@ public:
     virtual void setupWorldLight();
     virtual bool shouldRenderMesh(float largestDimension, float distanceToCamera);
 
-    QImage renderAvatarBillboard();
+    QImage renderAvatarBillboard(RenderArgs* renderArgs);
 
-    void displaySide(Camera& whichCamera, bool selfAvatarOnly = false, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
+    void displaySide(RenderArgs* renderArgs, Camera& whichCamera, bool selfAvatarOnly = false);
 
     /// Stores the current modelview matrix as the untranslated view matrix to use for transforms and the supplied vector as
     /// the view matrix translation.
@@ -500,8 +500,8 @@ private:
 
     glm::vec3 getSunDirection();
 
-    void updateShadowMap();
+    void updateShadowMap(RenderArgs* renderArgs);
-    void renderRearViewMirror(const QRect& region, bool billboard = false);
+    void renderRearViewMirror(RenderArgs* renderArgs, const QRect& region, bool billboard = false);
     void setMenuShortcutsEnabled(bool enabled);
 
     static void attachNewHeadToNode(Node *newNode);

interface/src/avatar/Avatar.cpp

@@ -268,7 +268,7 @@ static TextRenderer* textRenderer(TextRendererType type) {
     return displayNameRenderer;
 }
 
-void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
+void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
     if (_referential) {
         _referential->update();
     }
@@ -339,7 +339,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
     // simple frustum check
     float boundingRadius = getBillboardSize();
     ViewFrustum* frustum = nullptr;
-    if (renderMode == RenderArgs::SHADOW_RENDER_MODE) {
+    if (renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) {
         frustum = Application::getInstance()->getShadowViewFrustum();
     } else {
         frustum = Application::getInstance()->getDisplayViewFrustum();
@@ -365,14 +365,14 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
             GLOW_FROM_AVERAGE_LOUDNESS = 0.0f;
         }
 
-        float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderMode == RenderArgs::NORMAL_RENDER_MODE
+        float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE
                       ? 1.0f
                       : GLOW_FROM_AVERAGE_LOUDNESS;
 
         // render body
-        renderBody(frustum, renderMode, postLighting, glowLevel);
+        renderBody(renderArgs, frustum, postLighting, glowLevel);
 
-        if (!postLighting && renderMode != RenderArgs::SHADOW_RENDER_MODE) {
+        if (!postLighting && renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE) {
             // add local lights
             const float BASE_LIGHT_DISTANCE = 2.0f;
             const float LIGHT_EXPONENT = 1.0f;
@@ -396,10 +396,10 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
                 _skeletonModel.renderJointCollisionShapes(0.7f);
             }
 
-            if (renderHead && shouldRenderHead(cameraPosition, renderMode)) {
+            if (renderHead && shouldRenderHead(renderArgs, cameraPosition)) {
                 getHead()->getFaceModel().renderJointCollisionShapes(0.7f);
             }
-            if (renderBounding && shouldRenderHead(cameraPosition, renderMode)) {
+            if (renderBounding && shouldRenderHead(renderArgs, cameraPosition)) {
                 _skeletonModel.renderBoundingCollisionShapes(0.7f);
             }
 
@@ -436,7 +436,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
             float angle = abs(angleBetween(toTarget + delta, toTarget - delta));
             float sphereRadius = getHead()->getAverageLoudness() * SPHERE_LOUDNESS_SCALING;
 
-            if (renderMode == RenderArgs::NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
+            if (renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
                     (angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) {
                 glPushMatrix();
                 glTranslatef(_position.x, _position.y, _position.z);
@@ -455,8 +455,8 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
     }
 
     const float DISPLAYNAME_DISTANCE = 20.0f;
-    setShowDisplayName(renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
+    setShowDisplayName(renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
-    if (!postLighting || renderMode != RenderArgs::NORMAL_RENDER_MODE || (isMyAvatar() &&
+    if (!postLighting || renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE || (isMyAvatar() &&
             Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_FIRST_PERSON)) {
         return;
     }
@@ -479,13 +479,12 @@ glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
     return glm::angleAxis(angle * proportion, axis);
 }
 
-void Avatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
+void Avatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
-    Model::RenderMode modelRenderMode = renderMode;
     {
-        Glower glower(glowLevel);
+        Glower glower(renderArgs, glowLevel);
 
         if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
-            if (postLighting || renderMode == RenderArgs::SHADOW_RENDER_MODE) {
+            if (postLighting || renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) {
                 // render the billboard until both models are loaded
                 renderBillboard();
             }
@@ -493,18 +492,16 @@ void Avatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode rende
         }
 
         if (postLighting) {
-            getHand()->render(false, modelRenderMode);
+            getHand()->render(renderArgs, false);
         } else {
-            RenderArgs args;
+            _skeletonModel.render(renderArgs, 1.0f);
-            args._viewFrustum = renderFrustum;
+            renderAttachments(renderArgs);
-            _skeletonModel.render(1.0f, modelRenderMode, &args);
-            renderAttachments(renderMode, &args);
         }
     }
-    getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting);
+    getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
 }
 
-bool Avatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
+bool Avatar::shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const {
     return true;
 }
 
@@ -528,11 +525,11 @@ void Avatar::simulateAttachments(float deltaTime) {
     }
 }
 
-void Avatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
+void Avatar::renderAttachments(RenderArgs* args) {
  //   RenderArgs::RenderMode modelRenderMode = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
   //      RenderArgs::SHADOW_RENDER_MODE : RenderArgs::DEFAULT_RENDER_MODE;
     foreach (Model* model, _attachmentModels) {
-        model->render(1.0f, renderMode, args);
+        model->render(args, 1.0f);
     }
 }
 

interface/src/avatar/Avatar.h

@@ -68,7 +68,7 @@ public:
     void init();
     void simulate(float deltaTime);
 
-    virtual void render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode = RenderArgs::NORMAL_RENDER_MODE,
+    virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition,
         bool postLighting = false);
 
     //setters
@@ -208,11 +208,11 @@ protected:
 
     float calculateDisplayNameScaleFactor(const glm::vec3& textPosition, bool inHMD);
     void renderDisplayName();
-    virtual void renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel = 0.0f);
+    virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f);
-    virtual bool shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const;
+    virtual bool shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const;
 
     void simulateAttachments(float deltaTime);
-    virtual void renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args);
+    virtual void renderAttachments(RenderArgs* args);
 
     virtual void updateJointMappings();
     

interface/src/avatar/AvatarManager.cpp

@@ -115,7 +115,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     simulateAvatarFades(deltaTime);
 }
 
-void AvatarManager::renderAvatars(RenderArgs::RenderMode renderMode, bool postLighting, bool selfAvatarOnly) {
+void AvatarManager::renderAvatars(RenderArgs* renderArgs, bool postLighting, bool selfAvatarOnly) {
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
                             "Application::renderAvatars()");
     bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors);
@@ -129,14 +129,14 @@ void AvatarManager::renderAvatars(RenderArgs::RenderMode renderMode, bool postLi
                 if (!avatar->isInitialized()) {
                     continue;
                 }
-                avatar->render(cameraPosition, renderMode, postLighting);
+                avatar->render(renderArgs, cameraPosition, postLighting);
                 avatar->setDisplayingLookatVectors(renderLookAtVectors);
             }
-            renderAvatarFades(cameraPosition, renderMode);
+            renderAvatarFades(renderArgs, cameraPosition);
         }
     } else {
         // just render myAvatar
-        _myAvatar->render(cameraPosition, renderMode, postLighting);
+        _myAvatar->render(renderArgs, cameraPosition, postLighting);
         _myAvatar->setDisplayingLookatVectors(renderLookAtVectors);
     }
 }
@@ -159,14 +159,14 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
     }
 }
 
-void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) {
+void AvatarManager::renderAvatarFades(RenderArgs* renderArgs, const glm::vec3& cameraPosition) {
     // render avatar fades
-    Glower glower(renderMode == RenderArgs::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
+    Glower glower(renderArgs, renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
     
     foreach(const AvatarSharedPointer& fadingAvatar, _avatarFades) {
         Avatar* avatar = static_cast<Avatar*>(fadingAvatar.data());
         if (avatar != static_cast<Avatar*>(_myAvatar.data()) && avatar->isInitialized()) {
-            avatar->render(cameraPosition, renderMode);
+            avatar->render(renderArgs, cameraPosition);
         }
     }
 }

interface/src/avatar/AvatarManager.h

@@ -37,7 +37,7 @@ public:
     
     void updateMyAvatar(float deltaTime);
     void updateOtherAvatars(float deltaTime);
-    void renderAvatars(RenderArgs::RenderMode renderMode, bool postLighting = false, bool selfAvatarOnly = false);
+    void renderAvatars(RenderArgs* renderArgs, bool postLighting = false, bool selfAvatarOnly = false);
     
     void clearOtherAvatars();
    
@@ -60,7 +60,7 @@ private:
     AvatarManager(const AvatarManager& other);
 
     void simulateAvatarFades(float deltaTime);
-    void renderAvatarFades(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode);
+    void renderAvatarFades(RenderArgs* renderArgs, const glm::vec3& cameraPosition);
     
     AvatarSharedPointer newSharedAvatar();
     

interface/src/avatar/Hand.cpp

@@ -102,8 +102,8 @@ void Hand::resolvePenetrations() {
     }
 }
 
-void Hand::render(bool isMine, Model::RenderMode renderMode) {
+void Hand::render(RenderArgs* renderArgs, bool isMine) {
-    if (renderMode != RenderArgs::SHADOW_RENDER_MODE && 
+    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE && 
                 Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes)) {
         // draw a green sphere at hand joint location, which is actually near the wrist)
         for (size_t i = 0; i < getNumPalms(); i++) {
@@ -119,7 +119,7 @@ void Hand::render(bool isMine, Model::RenderMode renderMode) {
         }
     }
     
-    if (renderMode != RenderArgs::SHADOW_RENDER_MODE && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHands)) {
+    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHands)) {
         renderHandTargets(isMine);
     }
 

interface/src/avatar/Hand.h

@@ -52,7 +52,7 @@ public:
     };
     
     void simulate(float deltaTime, bool isMine);
-    void render(bool isMine, Model::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE);
+    void render(RenderArgs* renderArgs, bool isMine);
 
     void collideAgainstAvatar(Avatar* avatar, bool isMyHand);
 

interface/src/avatar/Head.cpp

@@ -262,15 +262,13 @@ void Head::relaxLean(float deltaTime) {
     _deltaLeanForward *= relaxationFactor;
 }
 
-void Head::render(float alpha, ViewFrustum* renderFrustum, Model::RenderMode mode, bool postLighting) {
+void Head::render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting) {
     if (postLighting) {
         if (_renderLookatVectors) {
-            renderLookatVectors(_leftEyePosition, _rightEyePosition, getCorrectedLookAtPosition());    
+            renderLookatVectors(renderArgs, _leftEyePosition, _rightEyePosition, getCorrectedLookAtPosition());    
         }
     } else {
-        RenderArgs args;
+        _faceModel.render(renderArgs, alpha);
-        args._viewFrustum = renderFrustum;
-        _faceModel.render(alpha, mode, &args);
     }
 }
 
@@ -353,9 +351,9 @@ void Head::addLeanDeltas(float sideways, float forward) {
     _deltaLeanForward += forward;
 }
 
-void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {
+void Head::renderLookatVectors(RenderArgs* renderArgs, glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {
     auto geometryCache = DependencyManager::get<GeometryCache>();
-    DependencyManager::get<GlowEffect>()->begin();
+    DependencyManager::get<GlowEffect>()->begin(renderArgs);
     
     glLineWidth(2.0);
     
@@ -364,7 +362,7 @@ void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosi
     geometryCache->renderLine(leftEyePosition, lookatPosition, startColor, endColor, _leftEyeLookAtID);
     geometryCache->renderLine(rightEyePosition, lookatPosition, startColor, endColor, _rightEyeLookAtID);
 
-    DependencyManager::get<GlowEffect>()->end();
+    DependencyManager::get<GlowEffect>()->end(renderArgs);
 }
 
 

interface/src/avatar/Head.h

@@ -40,7 +40,7 @@ public:
     void init();
     void reset();
     void simulate(float deltaTime, bool isMine, bool billboard = false);
-    void render(float alpha, ViewFrustum* renderFrustum, Model::RenderMode mode, bool postLighting);
+    void render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting);
     void setScale(float scale);
     void setPosition(glm::vec3 position) { _position = position; }
     void setAverageLoudness(float averageLoudness) { _averageLoudness = averageLoudness; }
@@ -153,7 +153,7 @@ private:
     int _rightEyeLookAtID;
     
     // private methods
-    void renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition);
+    void renderLookatVectors(RenderArgs* renderArgs, glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition);
     void calculateMouthShapes();
 
     friend class FaceModel;

interface/src/avatar/MyAvatar.cpp

@@ -328,13 +328,13 @@ void MyAvatar::renderDebugBodyPoints() {
 }
 
 // virtual
-void MyAvatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
+void MyAvatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
     // don't render if we've been asked to disable local rendering
     if (!_shouldRender) {
         return; // exit early
     }
 
-    Avatar::render(cameraPosition, renderMode, postLighting);
+    Avatar::render(renderArgs, cameraPosition, postLighting);
     
     // don't display IK constraints in shadow mode
     if (Menu::getInstance()->isOptionChecked(MenuOption::ShowIKConstraints) && postLighting) {
@@ -1166,7 +1166,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName, const g
     Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved);
 }
 
-void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
+void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
     if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
         return; // wait until both models are loaded
     }
@@ -1190,28 +1190,25 @@ void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode ren
     }*/
 
     //  Render the body's voxels and head
-    RenderArgs::RenderMode modelRenderMode = renderMode;
     if (!postLighting) {
-        RenderArgs args;
+        _skeletonModel.render(renderArgs, 1.0f);
-        args._viewFrustum = renderFrustum;
+        renderAttachments(renderArgs);
-        _skeletonModel.render(1.0f, modelRenderMode, &args);
-        renderAttachments(renderMode, &args);
     }
     
     //  Render head so long as the camera isn't inside it
-    if (shouldRenderHead(cameraPos, renderMode)) {
+    if (shouldRenderHead(renderArgs, cameraPos)) {
-        getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting);
+        getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
     }
     if (postLighting) {
-        getHand()->render(true, modelRenderMode);
+        getHand()->render(renderArgs, true);
     }
 }
 
 const float RENDER_HEAD_CUTOFF_DISTANCE = 0.50f;
 
-bool MyAvatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
+bool MyAvatar::shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const {
     const Head* head = getHead();
-    return (renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) || 
+    return (renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) || 
         (glm::length(cameraPosition - head->getEyePosition()) > RENDER_HEAD_CUTOFF_DISTANCE * _scale);
 }
 
@@ -1474,7 +1471,8 @@ void MyAvatar::maybeUpdateBillboard() {
             return;
         }
     }
-    QImage image = Application::getInstance()->renderAvatarBillboard();
+    RenderArgs renderArgs;
+    QImage image = Application::getInstance()->renderAvatarBillboard(&renderArgs);
     _billboard.clear();
     QBuffer buffer(&_billboard);
     buffer.open(QIODevice::WriteOnly);
@@ -1551,9 +1549,9 @@ void MyAvatar::updateMotionBehavior() {
     _feetTouchFloor = menu->isOptionChecked(MenuOption::ShiftHipsForIdleAnimations);
 }
 
-void MyAvatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
+void MyAvatar::renderAttachments(RenderArgs* args) {
-    if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || renderMode == RenderArgs::MIRROR_RENDER_MODE) {
+    if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
-        Avatar::renderAttachments(renderMode, args);
+        Avatar::renderAttachments(args);
         return;
     }
     const FBXGeometry& geometry = _skeletonModel.getGeometry()->getFBXGeometry();
@@ -1563,7 +1561,7 @@ void MyAvatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs*
     for (int i = 0; i < _attachmentData.size(); i++) {
         const QString& jointName = _attachmentData.at(i).jointName;
         if (jointName != headJointName && jointName != "Head") {
-            _attachmentModels.at(i)->render(1.0f, renderMode, args);        
+            _attachmentModels.at(i)->render(args, 1.0f);
         }
     }
 }

interface/src/avatar/MyAvatar.h

@@ -37,9 +37,9 @@ public:
     void simulate(float deltaTime);
     void updateFromTrackers(float deltaTime);
 
-    void render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode = RenderArgs::NORMAL_RENDER_MODE, bool postLighting = false);
+    void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting = false);
-    void renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel = 0.0f);
+    void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f);
-    bool shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const;
+    bool shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const override;
     void renderDebugBodyPoints();
 
     // setters
@@ -198,7 +198,7 @@ signals:
     void transformChanged();
 
 protected:
-    virtual void renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args);
+    virtual void renderAttachments(RenderArgs* args);
     
 private:
 

interface/src/devices/OculusManager.cpp

@@ -465,7 +465,7 @@ void OculusManager::configureCamera(Camera& camera) {
 }
 
 //Displays everything for the oculus, frame timing must be active
-void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera) {
+void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera) {
 
 #ifdef DEBUG
     // Ensure the frame counter always increments by exactly 1
@@ -532,7 +532,7 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
 
     //Bind our framebuffer object. If we are rendering the glow effect, we let the glow effect shader take care of it
     if (Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect)) {
-        DependencyManager::get<GlowEffect>()->prepare();
+        DependencyManager::get<GlowEffect>()->prepare(renderArgs);
     } else {
         auto primaryFBO = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
         glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(primaryFBO));
@@ -613,7 +613,8 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
 
         glViewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h);
 
-        qApp->displaySide(*_camera, false, RenderArgs::MONO);
+        renderArgs->_renderSide = RenderArgs::MONO;
+        qApp->displaySide(renderArgs, *_camera, false);
         qApp->getApplicationOverlay().displayOverlayTextureHmd(*_camera);
     });
     _activeEye = ovrEye_Count;
@@ -625,7 +626,7 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
     if (Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect)) {
         //Full texture viewport for glow effect
         glViewport(0, 0, _renderTargetSize.w, _renderTargetSize.h);
-        finalFbo = DependencyManager::get<GlowEffect>()->render();
+        finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);
     } else {
         finalFbo = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer(); 
         glBindFramebuffer(GL_FRAMEBUFFER, 0);

interface/src/devices/OculusManager.h

@@ -20,6 +20,8 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
+#include "RenderArgs.h"
+
 class Camera;
 class PalmData;
 class Text3DOverlay;
@@ -61,7 +63,7 @@ public:
     static void endFrameTiming();
     static bool allowSwap();
     static void configureCamera(Camera& camera);
-    static void display(QGLWidget * glCanvas, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);
+    static void display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);
     static void reset();
     
     /// param \yaw[out] yaw in radians

interface/src/devices/TV3DManager.cpp

@@ -80,7 +80,7 @@ void TV3DManager::configureCamera(Camera& whichCamera, int screenWidth, int scre
     glLoadIdentity();
 }
 
-void TV3DManager::display(Camera& whichCamera) {
+void TV3DManager::display(RenderArgs* renderArgs, Camera& whichCamera) {
     double nearZ = DEFAULT_NEAR_CLIP; // near clipping plane
     double farZ = DEFAULT_FAR_CLIP; // far clipping plane
 
@@ -93,7 +93,7 @@ void TV3DManager::display(Camera& whichCamera) {
     int portalH = deviceSize.height();
 
 
-    DependencyManager::get<GlowEffect>()->prepare();
+    DependencyManager::get<GlowEffect>()->prepare(renderArgs);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     Camera eyeCamera;
@@ -118,7 +118,8 @@ void TV3DManager::display(Camera& whichCamera) {
 
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
-        qApp->displaySide(eyeCamera, false, RenderArgs::MONO);
+        renderArgs->_renderSide = RenderArgs::MONO;
+        qApp->displaySide(renderArgs, eyeCamera, false);
         qApp->getApplicationOverlay().displayOverlayTextureStereo(whichCamera, _aspect, fov);
         _activeEye = NULL;
     }, [&]{
@@ -128,7 +129,7 @@ void TV3DManager::display(Camera& whichCamera) {
     glPopMatrix();
     glDisable(GL_SCISSOR_TEST);
 
-    auto finalFbo = DependencyManager::get<GlowEffect>()->render();
+    auto finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);
     auto fboSize = finalFbo->getSize();
     // Get the ACTUAL device size for the BLIT
     deviceSize = qApp->getDeviceSize();

interface/src/devices/TV3DManager.h

@@ -33,7 +33,7 @@ public:
     static void connect();
     static bool isConnected();
     static void configureCamera(Camera& camera, int screenWidth, int screenHeight);
-    static void display(Camera& whichCamera);
+    static void display(RenderArgs* renderArgs, Camera& whichCamera);
     static void overrideOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,
         float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane);
 private:    

interface/src/octree/OctreeFade.cpp

@@ -37,8 +37,8 @@ OctreeFade::OctreeFade(FadeDirection direction, float red, float green, float bl
     opacity = (direction == FADE_OUT) ? FADE_OUT_START : FADE_IN_START;
 }
 
-void OctreeFade::render() {
+void OctreeFade::render(RenderArgs* renderArgs) {
-    DependencyManager::get<GlowEffect>()->begin();
+    DependencyManager::get<GlowEffect>()->begin(renderArgs);
 
     glDisable(GL_LIGHTING);
     glPushMatrix();
@@ -53,7 +53,7 @@ void OctreeFade::render() {
     glEnable(GL_LIGHTING);
     
     
-    DependencyManager::get<GlowEffect>()->end();
+    DependencyManager::get<GlowEffect>()->end(renderArgs);
     
     opacity *= (direction == FADE_OUT) ? FADE_OUT_STEP : FADE_IN_STEP;
 }

interface/src/octree/OctreeFade.h

@@ -39,7 +39,7 @@ public:
     OctreeFade(FadeDirection direction = FADE_OUT, float red = DEFAULT_RED, 
               float green = DEFAULT_GREEN, float blue = DEFAULT_BLUE);
     
-    void render();
+    void render(RenderArgs* renderArgs);
     bool isDone() const;
 };
 

interface/src/ui/ApplicationOverlay.cpp

@@ -185,7 +185,7 @@ ApplicationOverlay::~ApplicationOverlay() {
 }
 
 // Renders the overlays either to a texture or to the screen
-void ApplicationOverlay::renderOverlay() {
+void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "ApplicationOverlay::displayOverlay()");
     Overlays& overlays = qApp->getOverlays();
     
@@ -222,7 +222,7 @@ void ApplicationOverlay::renderOverlay() {
         // give external parties a change to hook in
         emit qApp->renderingOverlay();
 
-        overlays.renderHUD();
+        overlays.renderHUD(renderArgs);
 
         renderPointers();
 
@@ -979,6 +979,14 @@ void ApplicationOverlay::renderStatsAndLogs() {
     glLineWidth(1.0f);
     glPointSize(1.0f);
 
+    // Determine whether to compute timing details
+    bool shouldDisplayTimingDetail = Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails) &&
+                                     Menu::getInstance()->isOptionChecked(MenuOption::Stats) &&
+                                     Stats::getInstance()->isExpanded();
+    if (shouldDisplayTimingDetail != PerformanceTimer::isActive()) {
+        PerformanceTimer::setActive(shouldDisplayTimingDetail);
+    }
+    
     if (Menu::getInstance()->isOptionChecked(MenuOption::Stats)) {
         // let's set horizontal offset to give stats some margin to mirror
         int horizontalOffset = MIRROR_VIEW_WIDTH + MIRROR_VIEW_LEFT_PADDING * 2;

interface/src/ui/ApplicationOverlay.h

@@ -32,7 +32,7 @@ public:
     ApplicationOverlay();
     ~ApplicationOverlay();
 
-    void renderOverlay();
+    void renderOverlay(RenderArgs* renderArgs);
     void displayOverlayTexture();
     void displayOverlayTextureStereo(Camera& whichCamera, float aspectRatio, float fov);
     void displayOverlayTextureHmd(Camera& whichCamera);

interface/src/ui/JSConsole.cpp

@@ -59,6 +59,7 @@ JSConsole::JSConsole(QWidget* parent, ScriptEngine* scriptEngine) :
     connect(_scriptEngine, SIGNAL(evaluationFinished(QScriptValue, bool)),
             this, SLOT(handleEvalutationFinished(QScriptValue, bool)));
     connect(_scriptEngine, SIGNAL(printedMessage(const QString&)), this, SLOT(handlePrint(const QString&)));
+    connect(_scriptEngine, SIGNAL(errorMessage(const QString&)), this, SLOT(handleError(const QString&)));
 
     resizeTextInput();
 }
@@ -96,6 +97,10 @@ void JSConsole::handleEvalutationFinished(QScriptValue result, bool isException)
     appendMessage(gutter, resultStr);
 }
 
+void JSConsole::handleError(const QString& message) {
+    appendMessage(GUTTER_ERROR, "<span style='" + RESULT_ERROR_STYLE + "'>" + message.toHtmlEscaped() + "</span>");
+}
+
 void JSConsole::handlePrint(const QString& message) {
     appendMessage("", message);
 }

interface/src/ui/JSConsole.h

@@ -49,6 +49,7 @@ protected slots:
     void resizeTextInput();
     void handleEvalutationFinished(QScriptValue result, bool isException);
     void handlePrint(const QString& message);
+    void handleError(const QString& message);
 
 private:
     void appendMessage(const QString& gutter, const QString& message);

interface/src/ui/RearMirrorTools.cpp

@@ -47,7 +47,7 @@ RearMirrorTools::RearMirrorTools(QRect& bounds) :
     _headZoomIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.bottom() - ICON_PADDING - ICON_SIZE, ICON_SIZE, ICON_SIZE);
 }
 
-void RearMirrorTools::render(bool fullScreen, const QPoint & mousePosition) {
+void RearMirrorTools::render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePosition) {
     if (fullScreen) {
         _fullScreen = true;
         displayIcon(QRect(QPoint(), qApp->getDeviceSize()), _shrinkIconRect, _closeTexture);

interface/src/ui/RearMirrorTools.h

@@ -24,7 +24,7 @@ class RearMirrorTools : public QObject {
     Q_OBJECT
 public:
     RearMirrorTools(QRect& bounds);
-    void render(bool fullScreen, const QPoint & mousePos);
+    void render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePos);
     bool mousePressEvent(int x, int y);
     
     static Setting::Handle<int> rearViewZoomLevel;

interface/src/ui/Stats.cpp

@@ -224,9 +224,10 @@ void Stats::display(
     lines = 5;
     int columnOneWidth = _generalStatsWidth;
 
-    PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
+    bool performanceTimerIsActive = PerformanceTimer::isActive();
-    
+    bool displayPerf = _expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails);
-    if (_expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails)) {
+    if (displayPerf && performanceTimerIsActive) {
+        PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
 
         columnOneWidth = _generalStatsWidth + _pingStatsWidth + _geoStatsWidth; // 3 columns wide...
         // we will also include room for 1 line per timing record and a header of 4 lines
@@ -276,7 +277,7 @@ void Stats::display(
 
     
     // TODO: the display of these timing details should all be moved to JavaScript
-    if (_expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails)) {
+    if (displayPerf && performanceTimerIsActive) {
         bool onlyDisplayTopTen = Menu::getInstance()->isOptionChecked(MenuOption::OnlyDisplayTopTen);
         // Timing details...
         verticalOffset += STATS_PELS_PER_LINE * 4; // skip 3 lines to be under the other columns

interface/src/ui/Stats.h

@@ -27,6 +27,8 @@ public:
     static void drawBackground(unsigned int rgba, int x, int y, int width, int height);
 
     void toggleExpanded();
+    bool isExpanded() { return _expanded; }
+    
     void checkClick(int mouseX, int mouseY, int mouseDragStartedX, int mouseDragStartedY, int horizontalOffset);
     void resetWidth(int width, int horizontalOffset);
     void display(const float* color, int horizontalOffset, float fps, int inPacketsPerSecond, int outPacketsPerSecond,

interface/src/ui/overlays/LocalModelsOverlay.cpp

@@ -47,7 +47,7 @@ void LocalModelsOverlay::render(RenderArgs* args) {
             Application* app = Application::getInstance();
             glm::vec3 oldTranslation = app->getViewMatrixTranslation();
             app->setViewMatrixTranslation(oldTranslation + _position);
-            _entityTreeRenderer->render();
+            _entityTreeRenderer->render(args);
             Application::getInstance()->setViewMatrixTranslation(oldTranslation);
         } glPopMatrix();
 

interface/src/ui/overlays/ModelOverlay.cpp

@@ -68,7 +68,7 @@ void ModelOverlay::render(RenderArgs* args) {
             if (glowLevel > 0.0f) {
                 glower = new Glower(glowLevel);
             }
-            _model.render(getAlpha(), RenderArgs::DEFAULT_RENDER_MODE, args);
+            _model.render(args, getAlpha());
             if (glower) {
                 delete glower;
             }

interface/src/ui/overlays/Overlays.cpp

@@ -82,34 +82,27 @@ void Overlays::update(float deltatime) {
     
 }
 
-void Overlays::renderHUD() {
+void Overlays::renderHUD(RenderArgs* renderArgs) {
     QReadLocker lock(&_lock);
     
     auto lodManager = DependencyManager::get<LODManager>();
-    RenderArgs args(NULL, Application::getInstance()->getViewFrustum(),
-                    lodManager->getOctreeSizeScale(),
-                    lodManager->getBoundaryLevelAdjust(),
-                    RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
 
     foreach(Overlay* thisOverlay, _overlaysHUD) {
         if (thisOverlay->is3D()) {
             glEnable(GL_DEPTH_TEST);
             glEnable(GL_LIGHTING);
 
-            thisOverlay->render(&args);
+            thisOverlay->render(renderArgs);
 
             glDisable(GL_LIGHTING);
             glDisable(GL_DEPTH_TEST);
         } else{
-            thisOverlay->render(&args);
+            thisOverlay->render(renderArgs);
         }
     }
 }
 
-void Overlays::renderWorld(bool drawFront,
+void Overlays::renderWorld(RenderArgs* renderArgs, bool drawFront) {
-                           RenderArgs::RenderMode renderMode,
-                           RenderArgs::RenderSide renderSide,
-                           RenderArgs::DebugFlags renderDebugFlags) {
     QReadLocker lock(&_lock);
     if (_overlaysWorld.size() == 0) {
         return;
@@ -123,11 +116,6 @@ void Overlays::renderWorld(bool drawFront,
     float myAvatarScale = 1.0f;
     
     auto lodManager = DependencyManager::get<LODManager>();
-    RenderArgs args(NULL, Application::getInstance()->getDisplayViewFrustum(),
-                    lodManager->getOctreeSizeScale(),
-                    lodManager->getBoundaryLevelAdjust(),
-                    renderMode, renderSide, renderDebugFlags);
-    
 
     foreach(Overlay* thisOverlay, _overlaysWorld) {
         Base3DOverlay* overlay3D = static_cast<Base3DOverlay*>(thisOverlay);
@@ -154,7 +142,7 @@ void Overlays::renderWorld(bool drawFront,
             default:
                 break;
         }
-        thisOverlay->render(&args);
+        thisOverlay->render(renderArgs);
         glPopMatrix();
     }
 }

interface/src/ui/overlays/Overlays.h

@@ -53,10 +53,8 @@ public:
     ~Overlays();
     void init();
     void update(float deltatime);
-    void renderWorld(bool drawFront, RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
+    void renderWorld(RenderArgs* renderArgs, bool drawFront);
-                     RenderArgs::RenderSide renderSide = RenderArgs::MONO,
+    void renderHUD(RenderArgs* renderArgs);
-                     RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
-    void renderHUD();
 
 public slots:
     /// adds an overlay with the specific properties

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -474,13 +474,11 @@ void EntityTreeRenderer::applyZonePropertiesToScene(const ZoneEntityItem* zone)
     }
 }
 
-void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
+void EntityTreeRenderer::render(RenderArgs* renderArgs) {
-                                RenderArgs::RenderSide renderSide,
-                                RenderArgs::DebugFlags renderDebugFlags) {
     if (_tree && !_shuttingDown) {
-        Model::startScene(renderSide);
+        Model::startScene(renderArgs->_renderSide);
 
-        ViewFrustum* frustum = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
+        ViewFrustum* frustum = (renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
             _viewState->getShadowViewFrustum() : _viewState->getCurrentViewFrustum();
         
         // Setup batch transform matrices
@@ -492,44 +490,44 @@ void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
         batch.setProjectionTransform(projMat);
         batch.setViewTransform(viewMat);
         
-        RenderArgs args(this, frustum, getSizeScale(), getBoundaryLevelAdjust(),
+        renderArgs->_renderer = this;
-                        renderMode, renderSide, renderDebugFlags, &batch);
+        renderArgs->_batch = &batch;
 
         _tree->lockForRead();
 
         // Whenever you're in an intersection between zones, we will always choose the smallest zone.
         _bestZone = NULL;
         _bestZoneVolume = std::numeric_limits<float>::max();
-        _tree->recurseTreeWithOperation(renderOperation, &args);
+        _tree->recurseTreeWithOperation(renderOperation, renderArgs);
 
         applyZonePropertiesToScene(_bestZone);
 
         // we must call endScene while we still have the tree locked so that no one deletes a model
         // on us while rendering the scene    
-        Model::endScene(renderMode, &args);
+        Model::endScene(renderArgs);
         _tree->unlock();
         
         glPushMatrix();
-        gpu::GLBackend::renderBatch(batch, true);
+        renderArgs->_context->enqueueBatch(batch);
         glPopMatrix();
         
         // stats...
-        _meshesConsidered = args._meshesConsidered;
+        _meshesConsidered = renderArgs->_meshesConsidered;
-        _meshesRendered = args._meshesRendered;
+        _meshesRendered = renderArgs->_meshesRendered;
-        _meshesOutOfView = args._meshesOutOfView;
+        _meshesOutOfView = renderArgs->_meshesOutOfView;
-        _meshesTooSmall = args._meshesTooSmall;
+        _meshesTooSmall = renderArgs->_meshesTooSmall;
 
-        _elementsTouched = args._elementsTouched;
+        _elementsTouched = renderArgs->_elementsTouched;
-        _itemsRendered = args._itemsRendered;
+        _itemsRendered = renderArgs->_itemsRendered;
-        _itemsOutOfView = args._itemsOutOfView;
+        _itemsOutOfView = renderArgs->_itemsOutOfView;
-        _itemsTooSmall = args._itemsTooSmall;
+        _itemsTooSmall = renderArgs->_itemsTooSmall;
 
-        _materialSwitches = args._materialSwitches;
+        _materialSwitches = renderArgs->_materialSwitches;
-        _trianglesRendered = args._trianglesRendered;
+        _trianglesRendered = renderArgs->_trianglesRendered;
-        _quadsRendered = args._quadsRendered;
+        _quadsRendered = renderArgs->_quadsRendered;
 
-        _translucentMeshPartsRendered = args._translucentMeshPartsRendered;
+        _translucentMeshPartsRendered = renderArgs->_translucentMeshPartsRendered;
-        _opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
+        _opaqueMeshPartsRendered = renderArgs->_opaqueMeshPartsRendered;
     }
     deleteReleasedModels(); // seems like as good as any other place to do some memory cleanup
 }
@@ -713,7 +711,7 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args)
                     
                     Glower* glower = NULL;
                     if (entityItem->getGlowLevel() > 0.0f) {
-                        glower = new Glower(entityItem->getGlowLevel());
+                        glower = new Glower(args, entityItem->getGlowLevel());
                     }
                     entityItem->render(args);
                     args->_itemsRendered++;
@@ -1159,7 +1157,7 @@ void EntityTreeRenderer::entityCollisionWithEntity(const EntityItemID& idA, cons
         return;
     }
     // Don't respond to small continuous contacts.
-    const float COLLISION_MINUMUM_PENETRATION = 0.005;
+    const float COLLISION_MINUMUM_PENETRATION = 0.005f;
     if ((collision.type != CONTACT_EVENT_TYPE_START) && (glm::length(collision.penetration) < COLLISION_MINUMUM_PENETRATION)) {
         return;
     }

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -58,9 +58,7 @@ public:
     void processEraseMessage(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode);
 
     virtual void init();
-    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, 
+    virtual void render(RenderArgs* renderArgs) override;
-                        RenderArgs::RenderSide renderSide = RenderArgs::MONO,
-                        RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
 
     virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem);
     virtual const Model* getModelForEntityItem(const EntityItem* entityItem);

libraries/entities-renderer/src/RenderableWebEntityItem.cpp

@@ -25,8 +25,8 @@
 
 #include "EntityTreeRenderer.h"
 
-const float DPI = 30.47;
+const float DPI = 30.47f;
-const float METERS_TO_INCHES = 39.3701;
+const float METERS_TO_INCHES = 39.3701f;
 
 EntityItem* RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     return new RenderableWebEntityItem(entityID, properties);

libraries/gpu/src/gpu/Context.cpp

@@ -15,9 +15,22 @@
 
 using namespace gpu;
 
+Context::Context() {
+}
+
+Context::Context(const Context& context) {
+}
+
+Context::~Context() {
+}
+
 bool Context::makeProgram(Shader& shader, const Shader::BindingSet& bindings) {
     if (shader.isProgram()) {
         return GLBackend::makeProgram(shader, bindings);
     }
     return false;
-}
+}
+
+void Context::enqueueBatch(Batch& batch) {
+    GLBackend::renderBatch(batch, true);
+}

libraries/octree/src/OctreeHeadlessViewer.h

@@ -33,9 +33,7 @@ public:
     virtual void renderElement(OctreeElement* element, RenderArgs* args) { /* swallow these */ }
 
     virtual void init();
-    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
+    virtual void render(RenderArgs* renderArgs) override { /* swallow these */ }
-                        RenderArgs::RenderSide renderSide = RenderArgs::MONO,
-                        RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE) { /* swallow these */ }
 
     void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }
 

libraries/octree/src/OctreeRenderer.cpp

@@ -164,32 +164,29 @@ bool OctreeRenderer::renderOperation(OctreeElement* element, void* extraData) {
     return false;
 }
 
-void OctreeRenderer::render(RenderArgs::RenderMode renderMode,
+void OctreeRenderer::render(RenderArgs* renderArgs) {
-                            RenderArgs::RenderSide renderSide,
-                            RenderArgs::DebugFlags renderDebugFlags) {
-    RenderArgs args(this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(),
-                    renderMode, renderSide, renderDebugFlags);
     if (_tree) {
+        renderArgs->_renderer = this;
         _tree->lockForRead();
-        _tree->recurseTreeWithOperation(renderOperation, &args);
+        _tree->recurseTreeWithOperation(renderOperation, renderArgs);
         _tree->unlock();
     }
-    _meshesConsidered = args._meshesConsidered;
+    _meshesConsidered = renderArgs->_meshesConsidered;
-    _meshesRendered = args._meshesRendered;
+    _meshesRendered = renderArgs->_meshesRendered;
-    _meshesOutOfView = args._meshesOutOfView;
+    _meshesOutOfView = renderArgs->_meshesOutOfView;
-    _meshesTooSmall = args._meshesTooSmall;
+    _meshesTooSmall = renderArgs->_meshesTooSmall;
 
-    _elementsTouched = args._elementsTouched;
+    _elementsTouched = renderArgs->_elementsTouched;
-    _itemsRendered = args._itemsRendered;
+    _itemsRendered = renderArgs->_itemsRendered;
-    _itemsOutOfView = args._itemsOutOfView;
+    _itemsOutOfView = renderArgs->_itemsOutOfView;
-    _itemsTooSmall = args._itemsTooSmall;
+    _itemsTooSmall = renderArgs->_itemsTooSmall;
 
-    _materialSwitches = args._materialSwitches;
+    _materialSwitches = renderArgs->_materialSwitches;
-    _trianglesRendered = args._trianglesRendered;
+    _trianglesRendered = renderArgs->_trianglesRendered;
-    _quadsRendered = args._quadsRendered;
+    _quadsRendered = renderArgs->_quadsRendered;
 
-    _translucentMeshPartsRendered = args._translucentMeshPartsRendered;
+    _translucentMeshPartsRendered = renderArgs->_translucentMeshPartsRendered;
-    _opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
+    _opaqueMeshPartsRendered = renderArgs->_opaqueMeshPartsRendered;
 
 }
 

libraries/octree/src/OctreeRenderer.h

@@ -51,9 +51,7 @@ public:
     virtual void init();
 
     /// render the content of the octree
-    virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, 
+    virtual void render(RenderArgs* renderArgs);
-                        RenderArgs::RenderSide renderSide = RenderArgs::MONO,
-                        RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
 
     ViewFrustum* getViewFrustum() const { return _viewFrustum; }
     void setViewFrustum(ViewFrustum* viewFrustum) { _viewFrustum = viewFrustum; }

libraries/render-utils/src/GlowEffect.cpp

@@ -94,7 +94,7 @@ void GlowEffect::init(bool enabled) {
     _enabled = enabled;
 }
 
-void GlowEffect::prepare() {
+void GlowEffect::prepare(RenderArgs* renderArgs) {
     auto primaryFBO = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
     GLuint fbo = gpu::GLBackend::getFramebufferID(primaryFBO);
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
@@ -105,19 +105,19 @@ void GlowEffect::prepare() {
     _isOddFrame = !_isOddFrame;
 }
 
-void GlowEffect::begin(float intensity) {
+void GlowEffect::begin(RenderArgs* renderArgs, float intensity) {
     // store the current intensity and add the new amount
     _intensityStack.push(_intensity);
     glBlendColor(0.0f, 0.0f, 0.0f, _intensity += intensity);
     _isEmpty &= (_intensity == 0.0f);
 }
 
-void GlowEffect::end() {
+void GlowEffect::end(RenderArgs* renderArgs) {
     // restore the saved intensity
     glBlendColor(0.0f, 0.0f, 0.0f, _intensity = _intensityStack.pop());
 }
 
-gpu::FramebufferPointer GlowEffect::render() {
+gpu::FramebufferPointer GlowEffect::render(RenderArgs* renderArgs) {
     PerformanceTimer perfTimer("glowEffect");
 
     auto textureCache = DependencyManager::get<TextureCache>();
@@ -212,10 +212,14 @@ void GlowEffect::toggleGlowEffect(bool enabled) {
 }
 
 Glower::Glower(float amount) {
-    DependencyManager::get<GlowEffect>()->begin(amount);
+    RenderArgs renderArgs;
+    DependencyManager::get<GlowEffect>()->begin(&renderArgs, amount);
+}
+Glower::Glower(RenderArgs* renderArgs, float amount) : _renderArgs(renderArgs) {
+    DependencyManager::get<GlowEffect>()->begin(_renderArgs, amount);
 }
 
 Glower::~Glower() {
-    DependencyManager::get<GlowEffect>()->end();
+    DependencyManager::get<GlowEffect>()->end(_renderArgs);
 }
 

libraries/render-utils/src/GlowEffect.h

@@ -15,6 +15,8 @@
 #include <gpu/GPUConfig.h>
 #include <gpu/Framebuffer.h>
 
+#include "RenderArgs.h"
+
 #include <QObject>
 #include <QGLWidget>
 #include <QStack>
@@ -37,14 +39,14 @@ public:
     void init(bool enabled);
     
     /// Prepares the glow effect for rendering the current frame.  To be called before rendering the scene.
-    void prepare();
+    void prepare(RenderArgs* renderArgs);
     
     /// Starts using the glow effect.
     /// \param intensity the desired glow intensity, from zero to one
-    void begin(float intensity = 1.0f);
+    void begin(RenderArgs* renderArgs, float intensity = 1.0f);
     
     /// Stops using the glow effect.
-    void end();
+    void end(RenderArgs* renderArgs);
     
     /// Returns the current glow intensity.
     float getIntensity() const { return _intensity; }
@@ -52,7 +54,7 @@ public:
     /// Renders the glow effect.  To be called after rendering the scene.
     /// \param toTexture whether to render to a texture, rather than to the frame buffer
     /// \return the framebuffer object to which we rendered, or NULL if to the frame buffer
-    gpu::FramebufferPointer render();
+    gpu::FramebufferPointer render(RenderArgs* renderArgs);
 
 public slots:
     void toggleGlowEffect(bool enabled);
@@ -85,7 +87,11 @@ class Glower {
 public:
     
     Glower(float amount = 1.0f);
+    Glower(RenderArgs* renderArgs, float amount = 1.0f);
     ~Glower();
+
+private:
+    RenderArgs* _renderArgs;
 };
 
 #endif // hifi_GlowEffect_h

libraries/render-utils/src/Model.cpp

@@ -765,27 +765,29 @@ void Model::renderSetup(RenderArgs* args) {
     }
 }
 
-bool Model::render(float alpha, RenderMode mode, RenderArgs* args) {
+bool Model::render(RenderArgs* renderArgs, float alpha) {
     PROFILE_RANGE(__FUNCTION__);
 
     // render the attachments
     foreach (Model* attachment, _attachments) {
-        attachment->render(alpha, mode, args);
+        attachment->render(renderArgs, alpha);
     }
     if (_meshStates.isEmpty()) {
         return false;
     }
 
-    renderSetup(args);
+    renderSetup(renderArgs);
-    return renderCore(alpha, mode, args);
+    return renderCore(renderArgs, alpha);
 }
 
-bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
+bool Model::renderCore(RenderArgs* args, float alpha) {
     PROFILE_RANGE(__FUNCTION__);
     if (!_viewState) {
         return false;
     }
 
+    auto mode = args->_renderMode;
+
     // Let's introduce a gpu::Batch to capture all the calls to the graphics api
     _renderBatch.clear();
     gpu::Batch& batch = _renderBatch;
@@ -1844,7 +1846,7 @@ void Model::setupBatchTransform(gpu::Batch& batch, RenderArgs* args) {
     batch.setViewTransform(_transforms[0]);
 }
 
-void Model::endScene(RenderMode mode, RenderArgs* args) {
+void Model::endScene(RenderArgs* args) {
     PROFILE_RANGE(__FUNCTION__);
 
 
@@ -1853,6 +1855,8 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
     glPushMatrix();
 #endif 
 
+    auto mode = args->_renderMode;
+
     RenderArgs::RenderSide renderSide = RenderArgs::MONO;
     if (args) {
         renderSide = args->_renderSide;

libraries/render-utils/src/Model.h

@@ -98,12 +98,12 @@ public:
     void reset();
     virtual void simulate(float deltaTime, bool fullUpdate = true);
 
-    bool render(float alpha = 1.0f, RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
+    bool render(RenderArgs* renderArgs, float alpha = 1.0f);
     
     // Scene rendering support
     static void startScene(RenderArgs::RenderSide renderSide);
     bool renderInScene(float alpha = 1.0f, RenderArgs* args = NULL);
-    static void endScene(RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
+    static void endScene(RenderArgs* args);
 
     /// Sets the URL of the model to render.
     /// \param fallback the URL of a fallback model to render if the requested model fails to load
@@ -371,7 +371,7 @@ private:
 
     // helper functions used by render() or renderInScene()
     void renderSetup(RenderArgs* args);
-    bool renderCore(float alpha, RenderArgs::RenderMode mode, RenderArgs* args);
+    bool renderCore(RenderArgs* args, float alpha);
     int renderMeshes(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
                         bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, bool isWireframe, RenderArgs* args = NULL,
                         bool forceRenderMeshes = false);

libraries/shared/src/PerfStat.cpp

@@ -79,29 +79,50 @@ void PerformanceTimerRecord::tallyResult(const quint64& now) {
 // PerformanceTimer
 // ----------------------------------------------------------------------------
 
+std::atomic<bool> PerformanceTimer::_isActive(false);
 QHash<QThread*, QString> PerformanceTimer::_fullNames;
 QMap<QString, PerformanceTimerRecord> PerformanceTimer::_records;
 
 
-PerformanceTimer::PerformanceTimer(const QString& name) :
+PerformanceTimer::PerformanceTimer(const QString& name) {
-    _start(0),
+    if (_isActive) {
-    _name(name) 
+        _name = name;
-{
+        QString& fullName = _fullNames[QThread::currentThread()];
-    QString& fullName = _fullNames[QThread::currentThread()];
+        fullName.append("/");
-    fullName.append("/");
+        fullName.append(_name);
-    fullName.append(_name);
+        _start = usecTimestampNow();
-    _start = usecTimestampNow();
+    }
 }
 
 PerformanceTimer::~PerformanceTimer() {
-    quint64 elapsedusec = (usecTimestampNow() - _start);
+    if (_isActive && _start != 0) {
-    QString& fullName = _fullNames[QThread::currentThread()];
+        quint64 elapsedusec = (usecTimestampNow() - _start);
-    PerformanceTimerRecord& namedRecord = _records[fullName];
+        QString& fullName = _fullNames[QThread::currentThread()];
-    namedRecord.accumulateResult(elapsedusec);
+        PerformanceTimerRecord& namedRecord = _records[fullName];
-    fullName.resize(fullName.size() - (_name.size() + 1));
+        namedRecord.accumulateResult(elapsedusec);
+        fullName.resize(fullName.size() - (_name.size() + 1));
+    }
 }
 
-// static 
+// static
+bool PerformanceTimer::isActive() {
+    return _isActive;
+}
+
+// static
+void PerformanceTimer::setActive(bool active) {
+    if (active != _isActive) {
+        _isActive.store(active);
+        if (!active) {
+            _fullNames.clear();
+            _records.clear();
+        }
+        
+        qDebug() << "PerformanceTimer has been turned" << ((active) ? "on" : "off");
+    }
+}
+
+// static
 void PerformanceTimer::tallyAllTimerRecords() {
     QMap<QString, PerformanceTimerRecord>::iterator recordsItr = _records.begin();
     QMap<QString, PerformanceTimerRecord>::const_iterator recordsEnd = _records.end();

libraries/shared/src/PerfStat.h

@@ -19,6 +19,7 @@
 #include "SharedUtil.h"
 #include "SimpleMovingAverage.h"
 
+#include <atomic>
 #include <cstring>
 #include <string>
 #include <map>
@@ -76,14 +77,18 @@ public:
     PerformanceTimer(const QString& name);
     ~PerformanceTimer();
     
+    static bool isActive();
+    static void setActive(bool active);
+    
     static const PerformanceTimerRecord& getTimerRecord(const QString& name) { return _records[name]; };
     static const QMap<QString, PerformanceTimerRecord>& getAllTimerRecords() { return _records; };
     static void tallyAllTimerRecords();
     static void dumpAllTimerRecords();
 
 private:
-    quint64 _start;
+    quint64 _start = 0;
     QString _name;
+    static std::atomic<bool> _isActive;
     static QHash<QThread*, QString> _fullNames;
     static QMap<QString, PerformanceTimerRecord> _records;
 };

libraries/shared/src/RenderArgs.h

@@ -16,6 +16,7 @@ class ViewFrustum;
 class OctreeRenderer;
 namespace gpu {
 class Batch;
+class Context;
 }
 
 class RenderArgs {
@@ -30,7 +31,8 @@ public:
         RENDER_DEBUG_SIMULATION_OWNERSHIP = 2,
     };
     
-    RenderArgs(OctreeRenderer* renderer = nullptr,
+    RenderArgs(gpu::Context* context = nullptr,
+               OctreeRenderer* renderer = nullptr,
                ViewFrustum* viewFrustum = nullptr,
                float sizeScale = 1.0f,
                int boundaryLevelAdjust = 0,
@@ -55,6 +57,7 @@ public:
                
                int translucentMeshPartsRendered = 0,
                int opaqueMeshPartsRendered = 0) :
+    _context(context),
     _renderer(renderer),
     _viewFrustum(viewFrustum),
     _sizeScale(sizeScale),
@@ -82,6 +85,7 @@ public:
     _opaqueMeshPartsRendered(opaqueMeshPartsRendered) {
     }
 
+    gpu::Context* _context;
     OctreeRenderer* _renderer;
     ViewFrustum* _viewFrustum;
     float _sizeScale;

libraries/shared/src/Transform.h

@@ -24,13 +24,13 @@
 
 inline bool isValidScale(glm::vec3 scale) {
     bool result = scale.x != 0.0f && scale.y != 0.0f && scale.z != 0.0f;
-    assert(result);
+    // assert(result);
     return result;
 }
 
 inline bool isValidScale(float scale) {
     bool result = scale != 0.0f;
-    assert(result);
+    // assert(result);
     return result;
 }
 

tools/vhacd-util/src/VHACDUtilApp.cpp

@@ -255,27 +255,27 @@ VHACDUtilApp::VHACDUtilApp(int argc, char* argv[]) :
         vHacdDepth = parser.value(vHacdDepthOption).toInt();
     }
 
-    float vHacdAlpha = 0.05;
+    float vHacdAlpha = 0.05f;
     if (parser.isSet(vHacdAlphaOption)) {
         vHacdAlpha = parser.value(vHacdAlphaOption).toFloat();
     }
 
-    float vHacdBeta = 0.05;
+    float vHacdBeta = 0.05f;
     if (parser.isSet(vHacdBetaOption)) {
         vHacdBeta = parser.value(vHacdBetaOption).toFloat();
     }
 
-    float vHacdGamma = 0.00125;
+    float vHacdGamma = 0.00125f;
     if (parser.isSet(vHacdGammaOption)) {
         vHacdGamma = parser.value(vHacdGammaOption).toFloat();
     }
 
-    float vHacdDelta = 0.05;
+    float vHacdDelta = 0.05f;
     if (parser.isSet(vHacdDeltaOption)) {
         vHacdDelta = parser.value(vHacdDeltaOption).toFloat();
     }
 
-    float vHacdConcavity = 0.0025;
+    float vHacdConcavity = 0.0025f;
     if (parser.isSet(vHacdConcavityOption)) {
         vHacdConcavity = parser.value(vHacdConcavityOption).toFloat();
     }