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

assignment-client/src/octree/OctreeServer.cpp

@@ -1176,12 +1176,21 @@ void OctreeServer::aboutToFinish() {
         _jurisdictionSender->terminating();
     }
     
-    // force a shutdown of all of our OctreeSendThreads - at this point it has to be impossible for a
+    QSet<SharedNodePointer> nodesToShutdown;
-    // linkedDataCreateCallback to be called for a new node
+
-    nodeList->eachNode([this](const SharedNodePointer& node) {
+    // Force a shutdown of all of our OctreeSendThreads.
+    // At this point it has to be impossible for a linkedDataCreateCallback to be called for a new node
+    nodeList->eachNode([&nodesToShutdown](const SharedNodePointer& node) {
+        nodesToShutdown << node;
+    });
+    
+    // What follows is a hack to force OctreeSendThreads to cleanup before the OctreeServer is gone.
+    // I would prefer to allow the SharedNodePointer ref count drop to zero to do this automatically
+    // but that isn't possible as long as the OctreeSendThread has an OctreeServer* that it uses.
+    for (auto& node : nodesToShutdown) {
         qDebug() << qPrintable(_safeServerName) << "server about to finish while node still connected node:" << *node;
         forceNodeShutdown(node);
-    });
+    }
 
     if (_persistThread) {
         _persistThread->aboutToFinish();

examples/edit.js

@@ -318,11 +318,15 @@ var toolBar = (function () {
                         print("Resize failed: timed out waiting for model (" + url + ") to load");
                     }
                 } else {
-                    entityProperties.dimensions = naturalDimensions;
+                    Entities.editEntity(entityId, { dimensions: naturalDimensions });
-                    Entities.editEntity(entityId, entityProperties);
+
+                    // Reset selection so that the selection overlays will be updated
+                    selectionManager.setSelections([entityId]);
                 }
             }
 
+            selectionManager.setSelections([entityId]);
+
             Script.setTimeout(resize, RESIZE_INTERVAL);
         } else {
             print("Can't add model: Model would be out of bounds.");

interface/src/Application.cpp

@@ -766,27 +766,8 @@ void Application::initializeGL() {
     }
     #endif
 
-#ifdef WIN32
+    // Where the gpuContext is created and where the TRUE Backend is created and assigned
-    GLenum err = glewInit();
+    _gpuContext = std::make_shared<gpu::Context>(new gpu::GLBackend());
-    if (GLEW_OK != err) {
-        /* Problem: glewInit failed, something is seriously wrong. */
-        qCDebug(interfaceapp, "Error: %s\n", glewGetErrorString(err));
-    }
-    qCDebug(interfaceapp, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
-
-    if (wglewGetExtension("WGL_EXT_swap_control")) {
-        int swapInterval = wglGetSwapIntervalEXT();
-        qCDebug(interfaceapp, "V-Sync is %s\n", (swapInterval > 0 ? "ON" : "OFF"));
-    }
-#endif
-
-#if defined(Q_OS_LINUX)
-    // TODO: Write the correct  code for Linux...
-    /* if (wglewGetExtension("WGL_EXT_swap_control")) {
-        int swapInterval = wglGetSwapIntervalEXT();
-        qCDebug(interfaceapp, "V-Sync is %s\n", (swapInterval > 0 ? "ON" : "OFF"));
-    }*/
-#endif
 
     initDisplay();
     qCDebug(interfaceapp, "Initialized Display.");
@@ -875,8 +856,9 @@ void Application::paintGL() {
     _glWidget->makeCurrent();
 
     auto lodManager = DependencyManager::get<LODManager>();
-    gpu::Context context(new gpu::GLBackend());
+
-    RenderArgs renderArgs(&context, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
+
+    RenderArgs renderArgs(_gpuContext, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
                           lodManager->getBoundaryLevelAdjust(), RenderArgs::DEFAULT_RENDER_MODE,
                           RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
 
@@ -892,6 +874,7 @@ void Application::paintGL() {
     PerformanceWarning warn(showWarnings, "Application::paintGL()");
     resizeGL();
 
+
     {
         PerformanceTimer perfTimer("renderOverlay");
         
@@ -902,8 +885,6 @@ void Application::paintGL() {
         _applicationOverlay.renderOverlay(&renderArgs);
     }
 
-    glEnable(GL_LINE_SMOOTH);
-
     if (_myCamera.getMode() == CAMERA_MODE_FIRST_PERSON || _myCamera.getMode() == CAMERA_MODE_THIRD_PERSON) {
         Menu::getInstance()->setIsOptionChecked(MenuOption::FirstPerson, _myAvatar->getBoomLength() <= MyAvatar::ZOOM_MIN);
         Menu::getInstance()->setIsOptionChecked(MenuOption::ThirdPerson, !(_myAvatar->getBoomLength() <= MyAvatar::ZOOM_MIN));
@@ -954,7 +935,6 @@ void Application::paintGL() {
     }
 
     // Sync up the View Furstum with the camera
-    // FIXME: it's happening again in the updateSHadow and it shouldn't, this should be the place
     loadViewFrustum(_myCamera, _viewFrustum);
 
 
@@ -993,7 +973,7 @@ void Application::paintGL() {
 
         displaySide(&renderArgs, _myCamera);
 
-        if (_myCamera.getMode() != CAMERA_MODE_MIRROR && Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
+        if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
             renderArgs._renderMode = RenderArgs::MIRROR_RENDER_MODE;
             renderRearViewMirror(&renderArgs, _mirrorViewRect);
             renderArgs._renderMode = RenderArgs::NORMAL_RENDER_MODE;
@@ -1817,6 +1797,13 @@ void Application::idle() {
     }
     double timeSinceLastUpdate = (double)_lastTimeUpdated.nsecsElapsed() / 1000000.0;
     if (timeSinceLastUpdate > targetFramePeriod) {
+        
+        {
+            static const int IDLE_EVENT_PROCESS_MAX_TIME_MS = 2;
+            PerformanceTimer perfTimer("processEvents");
+            processEvents(QEventLoop::AllEvents, IDLE_EVENT_PROCESS_MAX_TIME_MS);
+        }
+        
         _lastTimeUpdated.start();
         {
             PerformanceTimer perfTimer("update");
@@ -1841,11 +1828,19 @@ void Application::idle() {
                 _idleLoopMeasuredJitter = _idleLoopStdev.getStDev();
                 _idleLoopStdev.reset();
             }
-
         }
+        
         // After finishing all of the above work, ensure the idle timer is set to the proper interval,
-        // depending on whether we're throttling or not
+        // depending on whether we're throttling or not.
-        idleTimer->start(_glWidget->isThrottleRendering() ? THROTTLED_IDLE_TIMER_DELAY : 1);
+        // Once rendering is off on another thread we should be able to have Application::idle run at start(0) in
+        // perpetuity and not expect events to get backed up.
+        
+        static const int IDLE_TIMER_DELAY_MS = 0;
+        int desiredInterval = _glWidget->isThrottleRendering() ? THROTTLED_IDLE_TIMER_DELAY : IDLE_TIMER_DELAY_MS;
+        
+        if (idleTimer->interval() != desiredInterval) {
+            idleTimer->start(desiredInterval);
+        }
     }
 
     // check for any requested background downloads.
@@ -3168,10 +3163,6 @@ namespace render {
                 model::Skybox::render(batch, *(Application::getInstance()->getDisplayViewFrustum()), *skybox);
             }
         }
-        // FIX ME - If I don't call this renderBatch() here, then the atmosphere and skybox don't render, but it
-        // seems like these payloadRender() methods shouldn't be doing this. We need to investigate why the engine
-        // isn't rendering our batch
-        gpu::GLBackend::renderBatch(batch, true);
     }
 }
 
@@ -3437,10 +3428,6 @@ void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& regi
         renderArgs->_context->render(batch);
     }
 
-    bool updateViewFrustum = false;
-    loadViewFrustum(_mirrorCamera, _viewFrustum);
-
-
     // render rear mirror view
     displaySide(renderArgs, _mirrorCamera, true, billboard);
 

interface/src/Application.h

@@ -68,6 +68,7 @@
 #include "octree/OctreePacketProcessor.h"
 #include "UndoStackScriptingInterface.h"
 
+#include "gpu/Context.h"
 #include "render/Engine.h"
 
 class QGLWidget;
@@ -325,6 +326,8 @@ public:
 
     render::ScenePointer getMain3DScene() const { return _main3DScene; }
 
+    gpu::ContextPointer getGPUContext() const { return _gpuContext; }
+
 signals:
 
     /// Fired when we're simulating; allows external parties to hook in.
@@ -481,6 +484,7 @@ private:
     glm::vec3 getSunDirection();
 
     void renderRearViewMirror(RenderArgs* renderArgs, const QRect& region, bool billboard = false);
+
     void setMenuShortcutsEnabled(bool enabled);
 
     static void attachNewHeadToNode(Node *newNode);
@@ -631,6 +635,7 @@ private:
 
     render::ScenePointer _main3DScene{ new render::Scene() };
     render::EnginePointer _renderEngine{ new render::Engine() };
+    gpu::ContextPointer _gpuContext; // initialized during window creation
 
     Overlays _overlays;
     ApplicationOverlay _applicationOverlay;

interface/src/avatar/Avatar.cpp

@@ -316,15 +316,14 @@ void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::S
     }
 }
 
-void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
+void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition) {
     if (_referential) {
         _referential->update();
     }
 
     auto& batch = *renderArgs->_batch;
 
-    if (postLighting &&
+    if (glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(), _position) < 10.0f) {
-        glm::distance(DependencyManager::get<AvatarManager>()->getMyAvatar()->getPosition(), _position) < 10.0f) {
         auto geometryCache = DependencyManager::get<GeometryCache>();
         auto deferredLighting = DependencyManager::get<DeferredLightingEffect>();
 
@@ -414,9 +413,9 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo
                       : GLOW_FROM_AVERAGE_LOUDNESS;
 
         // render body
-        renderBody(renderArgs, frustum, postLighting, glowLevel);
+        renderBody(renderArgs, frustum, glowLevel);
 
-        if (!postLighting && renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE) {
+        if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE) {
             // add local lights
             const float BASE_LIGHT_DISTANCE = 2.0f;
             const float LIGHT_EXPONENT = 1.0f;
@@ -431,21 +430,17 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo
             }
         }
 
-        if (postLighting) {
+        bool renderSkeleton = Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes);
-            bool renderSkeleton = Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes);
+        bool renderHead = Menu::getInstance()->isOptionChecked(MenuOption::RenderHeadCollisionShapes);
-            bool renderHead = Menu::getInstance()->isOptionChecked(MenuOption::RenderHeadCollisionShapes);
+        bool renderBounding = Menu::getInstance()->isOptionChecked(MenuOption::RenderBoundingCollisionShapes);
-            bool renderBounding = Menu::getInstance()->isOptionChecked(MenuOption::RenderBoundingCollisionShapes);
+        if (renderSkeleton) {
-
+            _skeletonModel.renderJointCollisionShapes(0.7f);
-            if (renderSkeleton) {
+        }
-                _skeletonModel.renderJointCollisionShapes(0.7f);
+        if (renderHead && shouldRenderHead(renderArgs)) {
-            }
+            getHead()->getFaceModel().renderJointCollisionShapes(0.7f);
-
+        }
-            if (renderHead && shouldRenderHead(renderArgs)) {
+        if (renderBounding && shouldRenderHead(renderArgs)) {
-                getHead()->getFaceModel().renderJointCollisionShapes(0.7f);
+            _skeletonModel.renderBoundingCollisionShapes(*renderArgs->_batch, 0.7f);
-            }
-            if (renderBounding && shouldRenderHead(renderArgs)) {
-                _skeletonModel.renderBoundingCollisionShapes(*renderArgs->_batch, 0.7f);
-            }
         }
 
         // Stack indicator spheres
@@ -569,24 +564,20 @@ void Avatar::fixupModelsInScene() {
     scene->enqueuePendingChanges(pendingChanges);
 }
 
-void Avatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
+void Avatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, float glowLevel) {
 
     fixupModelsInScene();
     
     {
         if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
-            if (postLighting || renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) {
+            // render the billboard until both models are loaded
-                // render the billboard until both models are loaded
+            renderBillboard(renderArgs);
-                renderBillboard(renderArgs);
-            }
             return;
         }
 
-        if (postLighting) {
+        getHand()->render(renderArgs, false);
-            getHand()->render(renderArgs, false);
-        }
     }
-    getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
+    getHead()->render(renderArgs, 1.0f, renderFrustum);
 }
 
 bool Avatar::shouldRenderHead(const RenderArgs* renderArgs) const {

interface/src/avatar/Avatar.h

@@ -81,8 +81,7 @@ public:
     void init();
     void simulate(float deltaTime);
 
-    virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition,
+    virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition);
-        bool postLighting = false);
 
     bool addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene,
                             render::PendingChanges& pendingChanges);
@@ -235,7 +234,7 @@ protected:
 
     Transform calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize, const glm::ivec4& viewport) const;
     void renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum, const glm::ivec4& viewport) const;
-    virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f);
+    virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, float glowLevel = 0.0f);
     virtual bool shouldRenderHead(const RenderArgs* renderArgs) const;
     virtual void fixupModelsInScene();
 

interface/src/avatar/Head.cpp

@@ -293,7 +293,7 @@ void Head::relaxLean(float deltaTime) {
     _deltaLeanForward *= relaxationFactor;
 }
 
-void Head::render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting) {
+void Head::render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum) {
     if (_renderLookatVectors) {
         renderLookatVectors(renderArgs, _leftEyePosition, _rightEyePosition, getCorrectedLookAtPosition());
     }

interface/src/avatar/Head.h

@@ -33,7 +33,7 @@ public:
     void init();
     void reset();
     void simulate(float deltaTime, bool isMine, bool billboard = false);
-    void render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting);
+    void render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum);
     void setScale(float scale);
     void setPosition(glm::vec3 position) { _position = position; }
     void setAverageLoudness(float averageLoudness) { _averageLoudness = averageLoudness; }

interface/src/avatar/MyAvatar.cpp

@@ -332,13 +332,13 @@ void MyAvatar::updateFromTrackers(float deltaTime) {
 
 
 // virtual
-void MyAvatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
+void MyAvatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition) {
     // don't render if we've been asked to disable local rendering
     if (!_shouldRender) {
         return; // exit early
     }
 
-    Avatar::render(renderArgs, cameraPosition, postLighting);
+    Avatar::render(renderArgs, cameraPosition);
 
     // don't display IK constraints in shadow mode
     if (Menu::getInstance()->isOptionChecked(MenuOption::ShowIKConstraints) &&
@@ -1226,7 +1226,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName, const g
     Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved);
 }
 
-void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
+void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, float glowLevel) {
 
     if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
         return; // wait until all models are loaded
@@ -1236,7 +1236,7 @@ void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bo
 
     //  Render head so long as the camera isn't inside it
     if (shouldRenderHead(renderArgs)) {
-        getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
+        getHead()->render(renderArgs, 1.0f, renderFrustum);
     }
     getHand()->render(renderArgs, true);
 }
@@ -1532,8 +1532,8 @@ void MyAvatar::maybeUpdateBillboard() {
             return;
         }
     }
-    gpu::Context context(new gpu::GLBackend());
+
-    RenderArgs renderArgs(&context);
+    RenderArgs renderArgs(qApp->getGPUContext());
     QImage image = qApp->renderAvatarBillboard(&renderArgs);
     _billboard.clear();
     QBuffer buffer(&_billboard);

interface/src/avatar/MyAvatar.h

@@ -45,8 +45,8 @@ public:
     void preRender(RenderArgs* renderArgs);
     void updateFromTrackers(float deltaTime);
 
-    virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting = false) override;
+    virtual void render(RenderArgs* renderArgs, const glm::vec3& cameraPositio) override;
-    virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f) override;
+    virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, float glowLevel = 0.0f) override;
     virtual bool shouldRenderHead(const RenderArgs* renderArgs) const override;
 
     // setters

interface/src/avatar/SkeletonModel.cpp

@@ -13,6 +13,7 @@
 #include <QMultiMap>
 
 #include <CapsuleShape.h>
+#include <DeferredLightingEffect.h>
 #include <SphereShape.h>
 
 #include "Application.h"
@@ -785,30 +786,33 @@ void SkeletonModel::resetShapePositionsToDefaultPose() {
 void SkeletonModel::renderBoundingCollisionShapes(gpu::Batch& batch, float alpha) {
     const int BALL_SUBDIVISIONS = 10;
     if (_shapes.isEmpty()) {
-        // the bounding shape has not been propery computed
+        // the bounding shape has not been properly computed
         // so no need to render it
         return;
     }
 
-    // draw a blue sphere at the capsule endpoint
+    auto geometryCache = DependencyManager::get<GeometryCache>();
+    auto deferredLighting = DependencyManager::get<DeferredLightingEffect>();
+    Transform transform; // = Transform();
+
+    // draw a blue sphere at the capsule end point
     glm::vec3 endPoint;
     _boundingShape.getEndPoint(endPoint);
     endPoint = endPoint + _translation;
-    Transform transform = Transform();
     transform.setTranslation(endPoint);
     batch.setModelTransform(transform);
-    auto geometryCache = DependencyManager::get<GeometryCache>();
+    deferredLighting->bindSimpleProgram(batch);
     geometryCache->renderSphere(batch, _boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS,
                                 glm::vec4(0.6f, 0.6f, 0.8f, alpha));
 
-    // draw a yellow sphere at the capsule startpoint
+    // draw a yellow sphere at the capsule start point
     glm::vec3 startPoint;
     _boundingShape.getStartPoint(startPoint);
     startPoint = startPoint + _translation;
     glm::vec3 axis = endPoint - startPoint;
-    Transform axisTransform = Transform();
+    transform.setTranslation(startPoint);
-    axisTransform.setTranslation(-axis);
+    batch.setModelTransform(transform);
-    batch.setModelTransform(axisTransform);
+    deferredLighting->bindSimpleProgram(batch);
     geometryCache->renderSphere(batch, _boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS,
                                 glm::vec4(0.8f, 0.8f, 0.6f, alpha));
 

interface/src/ui/ApplicationOverlay.h

@@ -49,7 +49,6 @@ private:
     gpu::TexturePointer _overlayDepthTexture;
     gpu::TexturePointer _overlayColorTexture;
     gpu::FramebufferPointer _overlayFramebuffer;
-
 };
 
 #endif // hifi_ApplicationOverlay_h

interface/src/ui/overlays/BillboardOverlay.cpp

@@ -91,6 +91,7 @@ void BillboardOverlay::render(RenderArgs* args) {
     if (batch) {
         Transform transform = _transform;
         transform.postScale(glm::vec3(getDimensions(), 1.0f));
+        transform.setRotation(rotation);
         
         batch->setModelTransform(transform);
         batch->setResourceTexture(0, _texture->getGPUTexture());

libraries/gpu/src/gpu/Context.h

@@ -134,7 +134,7 @@ protected:
 
     friend class Shader;
 };
-
+typedef std::shared_ptr<Context> ContextPointer;
 
 };
 

libraries/gpu/src/gpu/GLBackend.cpp

@@ -8,6 +8,7 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
+#include <mutex>
 #include "GPULogging.h"
 #include "GLBackendShared.h"
 #include <glm/gtc/type_ptr.hpp>
@@ -89,6 +90,36 @@ GLBackend::GLBackend() :
     _pipeline(),
     _output()
 {
+    static std::once_flag once;
+    std::call_once(once, [] {
+        qCDebug(gpulogging) << "GL Version: " << QString((const char*) glGetString(GL_VERSION));
+        qCDebug(gpulogging) << "GL Shader Language Version: " << QString((const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
+        qCDebug(gpulogging) << "GL Vendor: " << QString((const char*) glGetString(GL_VENDOR));
+        qCDebug(gpulogging) << "GL Renderer: " << QString((const char*) glGetString(GL_RENDERER));
+
+#ifdef WIN32
+        GLenum err = glewInit();
+        if (GLEW_OK != err) {
+            /* Problem: glewInit failed, something is seriously wrong. */
+            qCDebug(gpulogging, "Error: %s\n", glewGetErrorString(err));
+        }
+        qCDebug(gpulogging, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
+
+        if (wglewGetExtension("WGL_EXT_swap_control")) {
+            int swapInterval = wglGetSwapIntervalEXT();
+            qCDebug(gpulogging, "V-Sync is %s\n", (swapInterval > 0 ? "ON" : "OFF"));
+        }
+#endif
+
+#if defined(Q_OS_LINUX)
+        // TODO: Write the correct  code for Linux...
+        /* if (wglewGetExtension("WGL_EXT_swap_control")) {
+            int swapInterval = wglGetSwapIntervalEXT();
+            qCDebug(gpulogging, "V-Sync is %s\n", (swapInterval > 0 ? "ON" : "OFF"));
+        }*/
+#endif
+    });
+
     initInput();
     initTransform();
 }
@@ -113,6 +144,7 @@ void GLBackend::render(Batch& batch) {
 }
 
 void GLBackend::renderBatch(Batch& batch, bool syncCache) {
+    qCDebug(gpulogging) << "GLBackend::renderBatch : Deprecated call, don;t do it!!!";
     GLBackend backend;
     if (syncCache) {
         backend.syncCache();
@@ -166,6 +198,8 @@ void GLBackend::syncCache() {
     syncTransformStateCache();
     syncPipelineStateCache();
     syncInputStateCache();
+
+    glEnable(GL_LINE_SMOOTH);
 }
 
 void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {

libraries/gpu/src/gpu/GLBackend.h

@@ -447,7 +447,6 @@ protected:
 
     typedef void (GLBackend::*CommandCall)(Batch&, uint32);
     static CommandCall _commandCalls[Batch::NUM_COMMANDS];
-
 };
 
 

libraries/physics/src/ShapeFactory.cpp

@@ -43,9 +43,18 @@ btConvexHullShape* ShapeFactory::createConvexHull(const QVector<glm::vec3>& poin
 
     const float MIN_MARGIN = 0.01f;
     glm::vec3 diagonal = maxCorner - minCorner;
-    float minDimension = glm::min(diagonal[0], diagonal[1]);
+    float smallestDimension = glm::min(diagonal[0], diagonal[1]);
-    minDimension = glm::min(minDimension, diagonal[2]);
+    smallestDimension = glm::min(smallestDimension, diagonal[2]);
-    margin = glm::min(glm::max(0.5f * minDimension, MIN_MARGIN), margin);
+    const float MIN_DIMENSION = 2.0f * MIN_MARGIN + 0.001f;
+    if (smallestDimension < MIN_DIMENSION) {
+        for (int i = 0; i < 3; ++i) {
+            if (diagonal[i] < MIN_DIMENSION) {
+                diagonal[i] = MIN_DIMENSION;
+            }
+        }
+        smallestDimension = MIN_DIMENSION;
+    }
+    margin = glm::min(glm::max(0.5f * smallestDimension, MIN_MARGIN), margin);
     hull->setMargin(margin);
 
     // add the points, correcting for margin

libraries/render-utils/src/FramebufferCache.cpp

@@ -103,22 +103,6 @@ gpu::TexturePointer FramebufferCache::getPrimarySpecularTexture() {
     return _primarySpecularTexture;
 }
 
-void FramebufferCache::setPrimaryDrawBuffers(gpu::Batch& batch, bool color, bool normal, bool specular) {
-    GLenum buffers[3];
-    int bufferCount = 0;
-    if (color) {
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
-    }
-    if (normal) {
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
-    }
-    if (specular) {
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
-    }
-    batch._glDrawBuffers(bufferCount, buffers);
-}
-
-
 gpu::FramebufferPointer FramebufferCache::getFramebuffer() {
     if (_cachedFramebuffers.isEmpty()) {
         _cachedFramebuffers.push_back(gpu::FramebufferPointer(gpu::Framebuffer::create(gpu::Element::COLOR_RGBA_32, _frameBufferSize.width(), _frameBufferSize.height())));

libraries/render-utils/src/FramebufferCache.h

@@ -39,9 +39,6 @@ public:
     /// Returns the framebuffer object used to render shadow maps;
     gpu::FramebufferPointer getShadowFramebuffer();
 
-    /// Enables or disables draw buffers on the primary framebuffer.  Note: the primary framebuffer must be bound.
-    void setPrimaryDrawBuffers(gpu::Batch& batch, bool color, bool normal = false, bool specular = false);
-    
     /// Returns a free framebuffer with a single color attachment for temp or intra-frame operations
     gpu::FramebufferPointer getFramebuffer();
     // TODO add sync functionality to the release, so we don't reuse a framebuffer being read from

libraries/shared/src/RenderArgs.h

@@ -80,7 +80,7 @@ public:
         RENDER_DEBUG_SIMULATION_OWNERSHIP = 2,
     };
     
-    RenderArgs(gpu::Context* context = nullptr,
+    RenderArgs(std::shared_ptr<gpu::Context> context = nullptr,
                OctreeRenderer* renderer = nullptr,
                ViewFrustum* viewFrustum = nullptr,
                float sizeScale = 1.0f,
@@ -102,7 +102,7 @@ public:
     _shouldRender(shouldRender) {
     }
 
-    gpu::Context* _context = nullptr;
+    std::shared_ptr<gpu::Context> _context = nullptr;
     OctreeRenderer* _renderer = nullptr;
     ViewFrustum* _viewFrustum = nullptr;
     glm::ivec4 _viewport{ 0, 0, 1, 1 };