Merge branch 'master' of github.com:highfidelity/hifi into acceleration-and-owner-in-wire-protocol

domain-server/src/DomainServer.cpp

@@ -302,6 +302,9 @@ bool DomainServer::didSetupAccountManagerWithAccessToken() {
                     << "at keypath metaverse.access_token or in your ENV at key DOMAIN_SERVER_ACCESS_TOKEN";
                 return false;
             }
+        } else {
+            qDebug() << "Using access token from DOMAIN_SERVER_ACCESS_TOKEN in env. This overrides any access token present"
+                << " in the user or master config.";
         }
         
         // give this access token to the AccountManager

examples/example/misc/sunLightExample.js

@@ -41,7 +41,8 @@ panel.newSlider("Year Time", 0, 364,
 );
 
 panel.newSlider("Day Time", 0, 24, 
-    function(value) { Scene.setStageDayTime(value); },
+        
+    function(value) { Scene.setStageDayTime(value); panel.update("Light Direction"); },
     function() { return Scene.getStageDayTime(); },
     function(value) {
         var hour = Math.floor(value);
@@ -72,12 +73,36 @@ function runStageTime() {
 }
 Script.setInterval(runStageTime, tickTackPeriod);
 
+panel.newCheckbox("Enable Earth Sun Model", 
+    function(value) { Scene.setStageEarthSunModelEnable((value != 0)); },
+    function() { return Scene.isStageEarthSunModelEnabled(); },
+    function(value) { return (value); }
+);
+
+panel.newDirectionBox("Light Direction", 
+    function(value) { Scene.setSunDirection(value); },
+    function() { return Scene.getSunDirection(); },
+    function(value) { return value.x.toFixed(2) + "," + value.y.toFixed(2) + "," + value.z.toFixed(2); }
+);
+
 panel.newSlider("Light Intensity", 0.0, 5, 
     function(value) { Scene.setSunIntensity(value); },
     function() { return Scene.getSunIntensity(); },
     function(value) { return (value).toFixed(2); }
 );
 
+panel.newSlider("Ambient Light Intensity", 0.0, 1.0, 
+    function(value) { Scene.setSunAmbientIntensity(value); },
+    function() { return Scene.getSunAmbientIntensity(); },
+    function(value) { return (value).toFixed(2); }
+);
+
+panel.newColorBox("Light Color", 
+    function(value) { Scene.setSunColor(value); },
+    function() { return Scene.getSunColor(); },
+    function(value) { return (value); } // "(" + value.x + "," = value.y + "," + value.z + ")"; }
+);
+
 Controller.mouseMoveEvent.connect(function panelMouseMoveEvent(event) { return panel.mouseMoveEvent(event); });
 Controller.mousePressEvent.connect( function panelMousePressEvent(event) { return panel.mousePressEvent(event); });
 Controller.mouseReleaseEvent.connect(function(event) { return panel.mouseReleaseEvent(event); });

examples/utilities/tools/cookies.js

@@ -12,6 +12,129 @@
 
 // The Slider class
 Slider = function(x,y,width,thumbSize) {
+    this.background = Overlays.addOverlay("text", {
+                    backgroundColor: { red: 125, green: 125, blue: 255 },
+                    x: x,
+                    y: y,
+                    width: width,
+                    height: thumbSize,
+                    alpha: 1.0,
+                    backgroundAlpha: 0.5,
+                    visible: true
+                });
+    this.thumb = Overlays.addOverlay("text", {
+                    backgroundColor: { red: 255, green: 255, blue: 255 },
+                    x: x,
+                    y: y,
+                    width: thumbSize,
+                    height: thumbSize,
+                    alpha: 1.0,
+                    backgroundAlpha: 1.0,
+                    visible: true
+                });
+
+
+    this.thumbSize = thumbSize;
+    this.thumbHalfSize = 0.5 * thumbSize;
+
+    this.minThumbX = x + this.thumbHalfSize;
+    this.maxThumbX = x + width - this.thumbHalfSize;
+    this.thumbX = this.minThumbX;
+
+    this.minValue = 0.0;
+    this.maxValue = 1.0;
+
+    this.clickOffsetX = 0;
+    this.isMoving = false;
+
+    this.updateThumb = function() { 
+        thumbTruePos = this.thumbX - 0.5 * this.thumbSize;
+        Overlays.editOverlay(this.thumb, { x: thumbTruePos } );
+    };
+
+    this.isClickableOverlayItem = function(item) {
+        return (item == this.thumb) || (item == this.background);
+    };
+
+    this.onMouseMoveEvent = function(event) { 
+        if (this.isMoving) {
+            newThumbX = event.x - this.clickOffsetX;
+            if (newThumbX < this.minThumbX) {
+                newThumbX = this.minThumbX;
+            }
+            if (newThumbX > this.maxThumbX) {
+                newThumbX = this.maxThumbX;
+            }
+            this.thumbX = newThumbX;
+            this.updateThumb();
+            this.onValueChanged(this.getValue());
+        }
+    };
+
+    this.onMousePressEvent = function(event, clickedOverlay) {
+        if (!this.isClickableOverlayItem(clickedOverlay)) {
+            this.isMoving = false;
+            return;
+        }
+        this.isMoving = true;
+        var clickOffset = event.x - this.thumbX;
+        if ((clickOffset > -this.thumbHalfSize) && (clickOffset < this.thumbHalfSize)) {
+            this.clickOffsetX = clickOffset;
+        } else {
+            this.clickOffsetX = 0;
+            this.thumbX = event.x;
+            this.updateThumb();
+            this.onValueChanged(this.getValue());
+        }
+
+    };
+
+    this.onMouseReleaseEvent = function(event) {
+        this.isMoving = false;
+    };
+
+    // Public members:
+
+    this.setNormalizedValue = function(value) {
+        if (value < 0.0) {
+            this.thumbX = this.minThumbX;
+        } else if (value > 1.0) {
+            this.thumbX = this.maxThumbX;
+        } else {
+            this.thumbX = value * (this.maxThumbX - this.minThumbX) + this.minThumbX;
+        }
+        this.updateThumb();
+    };
+    this.getNormalizedValue = function() {
+        return (this.thumbX - this.minThumbX) / (this.maxThumbX - this.minThumbX);
+    };
+
+    this.setValue = function(value) {
+        var normValue = (value - this.minValue) / (this.maxValue - this.minValue);
+        this.setNormalizedValue(normValue);
+    };
+
+    this.getValue = function() {
+        return this.getNormalizedValue() * (this.maxValue - this.minValue) + this.minValue;
+    };
+
+    this.onValueChanged = function(value) {};
+
+    this.destroy = function() {
+        Overlays.deleteOverlay(this.background);
+        Overlays.deleteOverlay(this.thumb);
+    };
+
+    this.setThumbColor = function(color) {
+        Overlays.editOverlay(this.thumb, {backgroundColor: { red: color.x*255, green: color.y*255, blue: color.z*255 }});
+    };
+    this.setBackgroundColor = function(color) {
+        Overlays.editOverlay(this.background, {backgroundColor: { red: color.x*255, green: color.y*255, blue: color.z*255 }});
+    };
+}
+
+// The Checkbox class
+Checkbox = function(x,y,width,thumbSize) {
 
     this.thumb = Overlays.addOverlay("text", {
                     backgroundColor: { red: 255, green: 255, blue: 255 },
@@ -52,6 +175,10 @@ Slider = function(x,y,width,thumbSize) {
         Overlays.editOverlay(this.thumb, { x: thumbTruePos } );
     };
 
+    this.isClickableOverlayItem = function(item) {
+        return item == this.background;
+    };
+
     this.onMouseMoveEvent = function(event) { 
         if (this.isMoving) {
             newThumbX = event.x - this.clickOffsetX;
@@ -67,7 +194,11 @@ Slider = function(x,y,width,thumbSize) {
         }
     };
 
-    this.onMousePressEvent = function(event) {
+    this.onMousePressEvent = function(event, clickedOverlay) {
+        if (this.background != clickedOverlay) {
+            this.isMoving = false;
+            return;
+        }
         this.isMoving = true;
         var clickOffset = event.x - this.thumbX;
         if ((clickOffset > -this.thumbHalfSize) && (clickOffset < this.thumbHalfSize)) {
@@ -118,6 +249,167 @@ Slider = function(x,y,width,thumbSize) {
     };
 }
 
+// The ColorBox class
+ColorBox = function(x,y,width,thumbSize) {
+    var self = this;
+    
+    var slideHeight = thumbSize / 3;
+    var sliderWidth = width;
+    this.red = new Slider(x, y, width, slideHeight);
+    this.green = new Slider(x, y + slideHeight, width, slideHeight);
+    this.blue = new Slider(x, y + 2 * slideHeight, width, slideHeight);
+    this.red.setBackgroundColor({x: 1, y: 0, z: 0});
+    this.green.setBackgroundColor({x: 0, y: 1, z: 0});
+    this.blue.setBackgroundColor({x: 0, y: 0, z: 1});
+
+    this.isClickableOverlayItem = function(item) {
+        return this.red.isClickableOverlayItem(item) 
+            || this.green.isClickableOverlayItem(item)
+            || this.blue.isClickableOverlayItem(item);
+    };
+
+    this.onMouseMoveEvent = function(event) { 
+        this.red.onMouseMoveEvent(event);
+        this.green.onMouseMoveEvent(event);
+        this.blue.onMouseMoveEvent(event);
+    };
+
+    this.onMousePressEvent = function(event, clickedOverlay) {
+        this.red.onMousePressEvent(event, clickedOverlay);
+        if (this.red.isMoving) {
+            return;
+        }
+
+        this.green.onMousePressEvent(event, clickedOverlay);
+        if (this.green.isMoving) {
+            return;
+        }
+        
+        this.blue.onMousePressEvent(event, clickedOverlay);
+    };
+
+    this.onMouseReleaseEvent = function(event) {
+        this.red.onMouseReleaseEvent(event);
+        this.green.onMouseReleaseEvent(event);
+        this.blue.onMouseReleaseEvent(event);
+    };
+
+    this.setterFromWidget = function(value) {
+        var color = self.getValue();
+        self.onValueChanged(color);
+        self.updateRGBSliders(color);
+    };
+
+    this.red.onValueChanged = this.setterFromWidget;
+    this.green.onValueChanged = this.setterFromWidget;
+    this.blue.onValueChanged = this.setterFromWidget;
+
+    this.updateRGBSliders = function(color) {
+        this.red.setThumbColor({x: color.x, y: 0, z: 0});
+        this.green.setThumbColor({x: 0, y: color.y, z: 0});
+        this.blue.setThumbColor({x: 0, y: 0, z: color.z});
+    };
+
+    // Public members:
+    this.setValue = function(value) {
+        this.red.setValue(value.x);
+        this.green.setValue(value.y);
+        this.blue.setValue(value.z);
+        this.updateRGBSliders(value);  
+    };
+
+    this.getValue = function() {
+        var value = {x:this.red.getValue(), y:this.green.getValue(),z:this.blue.getValue()};
+        return value;
+    };
+
+    this.destroy = function() {
+        this.red.destroy();
+        this.green.destroy();
+        this.blue.destroy();
+    };
+
+    this.onValueChanged = function(value) {};
+}
+
+// The DirectionBox class
+DirectionBox = function(x,y,width,thumbSize) {
+    var self = this;
+    
+    var slideHeight = thumbSize / 2;
+    var sliderWidth = width;
+    this.yaw = new Slider(x, y, width, slideHeight);
+    this.pitch = new Slider(x, y + slideHeight, width, slideHeight);
+    
+    this.yaw.setThumbColor({x: 1, y: 0, z: 0});
+    this.yaw.minValue = -180;
+    this.yaw.maxValue = +180;
+
+    this.pitch.setThumbColor({x: 0, y: 0, z: 1});
+    this.pitch.minValue = -1;
+    this.pitch.maxValue = +1;
+
+    this.isClickableOverlayItem = function(item) {
+        return this.yaw.isClickableOverlayItem(item) 
+            || this.pitch.isClickableOverlayItem(item);
+    };
+
+    this.onMouseMoveEvent = function(event) { 
+        this.yaw.onMouseMoveEvent(event);
+        this.pitch.onMouseMoveEvent(event);
+    };
+
+    this.onMousePressEvent = function(event, clickedOverlay) {
+        this.yaw.onMousePressEvent(event, clickedOverlay);
+        if (this.yaw.isMoving) {
+            return;
+        }
+        this.pitch.onMousePressEvent(event, clickedOverlay);
+    };
+
+    this.onMouseReleaseEvent = function(event) {
+        this.yaw.onMouseReleaseEvent(event);
+        this.pitch.onMouseReleaseEvent(event);
+    };
+
+    this.setterFromWidget = function(value) {
+        var yawPitch = self.getValue();
+        self.onValueChanged(yawPitch);
+    };
+
+    this.yaw.onValueChanged = this.setterFromWidget;
+    this.pitch.onValueChanged = this.setterFromWidget;
+
+    // Public members:
+    this.setValue = function(direction) {
+        var flatXZ = Math.sqrt(direction.x * direction.x + direction.z * direction.z);
+        if (flatXZ > 0.0) {
+            var flatX = direction.x / flatXZ;
+            var flatZ = direction.z / flatXZ;
+            var yaw = Math.acos(flatX) * 180 / Math.PI;
+            if (flatZ < 0) {
+                yaw = -yaw;
+            }
+            this.yaw.setValue(yaw);
+        }
+        this.pitch.setValue(direction.y);
+    };
+
+    this.getValue = function() {
+        var dirZ = this.pitch.getValue();
+        var yaw = this.yaw.getValue() * Math.PI / 180;
+        var cosY = Math.sqrt(1 - dirZ*dirZ);
+        var value = {x:cosY * Math.cos(yaw), y:dirZ, z: cosY * Math.sin(yaw)};
+        return value;
+    };
+
+    this.destroy = function() {
+        this.yaw.destroy();
+        this.pitch.destroy();
+    };
+
+    this.onValueChanged = function(value) {};
+}
 
 var textFontSize = 16;
 
@@ -167,7 +459,12 @@ function PanelItem(name, setter, getter, displayer, x, y, textWidth, valueWidth,
     };
     this.setterFromWidget = function(value) {
         setter(value);
-        Overlays.editOverlay(this.value, {text: this.displayer(getter())});    
+        // ANd loop back the value after the final setter has been called
+        var value = getter();
+        if (this.widget) {
+            this.widget.setValue(value);
+        }        
+        Overlays.editOverlay(this.value, {text: this.displayer(value)});    
     };
 
     
@@ -219,9 +516,9 @@ Panel = function(x, y) {
         for (var i in this.items) {
             var widget = this.items[i].widget;
 
-            if (clickedOverlay == widget.background) {
+            if (widget.isClickableOverlayItem(clickedOverlay)) {
                 this.activeWidget = widget;
-                this.activeWidget.onMousePressEvent(event);        
+                this.activeWidget.onMousePressEvent(event, clickedOverlay);        
               //  print("clicked... widget=" + i);        
                 break;
             }    
@@ -237,21 +534,63 @@ Panel = function(x, y) {
 
     this.newSlider = function(name, minValue, maxValue, setValue, getValue, displayValue) {
 
-        var sliderItem = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
+        var item = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
 
         var slider = new Slider(this.widgetX, this.nextY, widgetWidth, rawHeight);
         slider.minValue = minValue;
         slider.maxValue = maxValue;
-        slider.onValueChanged = function(value) { sliderItem.setterFromWidget(value); };
 
 
-        sliderItem.widget = slider;
+        item.widget = slider;
-        sliderItem.setter(getValue());        
+        item.widget.onValueChanged = function(value) { item.setterFromWidget(value); };
-        this.items[name] = sliderItem;
+        item.setter(getValue());        
+        this.items[name] = item;
         this.nextY += rawYDelta;
       //  print("created Item... slider=" + name);     
     };
 
+    this.newCheckbox = function(name, setValue, getValue, displayValue) {
+
+        var item = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
+
+        var checkbox = new Checkbox(this.widgetX, this.nextY, widgetWidth, rawHeight);
+ 
+        item.widget = checkbox;
+        item.widget.onValueChanged = function(value) { item.setterFromWidget(value); };
+        item.setter(getValue());        
+        this.items[name] = item;
+        this.nextY += rawYDelta;
+      //  print("created Item... slider=" + name);     
+    };
+
+    this.newColorBox = function(name, setValue, getValue, displayValue) {
+
+        var item = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
+
+        var colorBox = new ColorBox(this.widgetX, this.nextY, widgetWidth, rawHeight);
+
+        item.widget = colorBox;
+        item.widget.onValueChanged = function(value) { item.setterFromWidget(value); };
+        item.setter(getValue());      
+        this.items[name] = item;
+        this.nextY += rawYDelta;
+      //  print("created Item... colorBox=" + name);     
+    };
+
+    this.newDirectionBox= function(name, setValue, getValue, displayValue) {
+
+        var item = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
+
+        var directionBox = new DirectionBox(this.widgetX, this.nextY, widgetWidth, rawHeight);
+
+        item.widget = directionBox;
+        item.widget.onValueChanged = function(value) { item.setterFromWidget(value); };
+        item.setter(getValue());      
+        this.items[name] = item;
+        this.nextY += rawYDelta;
+      //  print("created Item... directionBox=" + name);     
+    };
+
     this.destroy = function() {
         for (var i in this.items) {
             this.items[i].destroy();  
@@ -273,6 +612,15 @@ Panel = function(x, y) {
         }
         return null;
     }
+
+    this.update = function(name) {
+        var item = this.items[name];
+        if (item != null) {
+            return item.setter(item.getter());
+        }
+        return null;
+    }
+
 };
 
 

interface/src/Application.cpp

@@ -1748,7 +1748,10 @@ void Application::setActiveFaceTracker() {
     DependencyManager::get<Faceshift>()->setTCPEnabled(Menu::getInstance()->isOptionChecked(MenuOption::Faceshift));
 #endif
 #ifdef HAVE_DDE
-    DependencyManager::get<DdeFaceTracker>()->setEnabled(Menu::getInstance()->isOptionChecked(MenuOption::DDEFaceRegression));
+    bool isUsingDDE = Menu::getInstance()->isOptionChecked(MenuOption::DDEFaceRegression);
+    Menu::getInstance()->getActionForOption(MenuOption::DDEFiltering)->setVisible(isUsingDDE);
+    Menu::getInstance()->getActionForOption(MenuOption::ResetDDETracking)->setVisible(isUsingDDE);
+    DependencyManager::get<DdeFaceTracker>()->setEnabled(isUsingDDE);
 #endif
 #ifdef HAVE_VISAGE
     DependencyManager::get<Visage>()->updateEnabled();
@@ -3046,7 +3049,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
     {
         DependencyManager::get<DeferredLightingEffect>()->setAmbientLightMode(getRenderAmbientLight());
         auto skyStage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
-        DependencyManager::get<DeferredLightingEffect>()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity());
+        DependencyManager::get<DeferredLightingEffect>()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity(), skyStage->getSunLight()->getAmbientIntensity());
         DependencyManager::get<DeferredLightingEffect>()->setGlobalAtmosphere(skyStage->getAtmosphere());
 
         PROFILE_RANGE("DeferredLighting"); 

interface/src/Application.h

@@ -210,7 +210,6 @@ public:
     bool getLastMouseMoveWasSimulated() const { return _lastMouseMoveWasSimulated; }
     
     FaceTracker* getActiveFaceTracker();
-    void setActiveFaceTracker();
 
     QSystemTrayIcon* getTrayIcon() { return _trayIcon; }
     ApplicationOverlay& getApplicationOverlay() { return _applicationOverlay; }
@@ -385,6 +384,8 @@ public slots:
     void setVSyncEnabled();
 
     void resetSensors();
+    void setActiveFaceTracker();
+
     void aboutApp();
     void showEditEntitiesHelp();
     

interface/src/DiscoverabilityManager.cpp

@@ -18,6 +18,7 @@
 #include <UUID.h>
 
 #include "DiscoverabilityManager.h"
+#include "Menu.h"
 
 const Discoverability::Mode DEFAULT_DISCOVERABILITY_MODE = Discoverability::All;
 
@@ -96,4 +97,32 @@ void DiscoverabilityManager::setDiscoverabilityMode(Discoverability::Mode discov
 
         emit discoverabilityModeChanged(discoverabilityMode);
     }
-}
+}
+
+void DiscoverabilityManager::setVisibility() {
+    Menu* menu = Menu::getInstance();
+
+    if (menu->isOptionChecked(MenuOption::VisibleToEveryone)) {
+        this->setDiscoverabilityMode(Discoverability::All);
+    } else if (menu->isOptionChecked(MenuOption::VisibleToFriends)) {
+        this->setDiscoverabilityMode(Discoverability::Friends);
+    } else if (menu->isOptionChecked(MenuOption::VisibleToNoOne)) {
+        this->setDiscoverabilityMode(Discoverability::None);
+    } else {
+        qDebug() << "ERROR DiscoverabilityManager::setVisibility() called with unrecognized value.";
+    }
+}
+
+void DiscoverabilityManager::visibilityChanged(Discoverability::Mode discoverabilityMode) {
+    Menu* menu = Menu::getInstance();
+
+    if (discoverabilityMode == Discoverability::All) {
+        menu->setIsOptionChecked(MenuOption::VisibleToEveryone, true);
+    } else if (discoverabilityMode == Discoverability::Friends) {
+        menu->setIsOptionChecked(MenuOption::VisibleToFriends, true);
+    } else if (discoverabilityMode == Discoverability::None) {
+        menu->setIsOptionChecked(MenuOption::VisibleToNoOne, true);
+    } else {
+        qDebug() << "ERROR DiscoverabilityManager::visibilityChanged() called with unrecognized value.";
+    }
+}

interface/src/DiscoverabilityManager.h

@@ -36,6 +36,9 @@ public slots:
     Discoverability::Mode getDiscoverabilityMode() { return static_cast<Discoverability::Mode>(_mode.get()); }
     void setDiscoverabilityMode(Discoverability::Mode discoverabilityMode);
 
+    void setVisibility();
+    void visibilityChanged(Discoverability::Mode discoverabilityMode);
+
 signals:
     void discoverabilityModeChanged(Discoverability::Mode discoverabilityMode);
 

interface/src/Menu.cpp

@@ -163,21 +163,21 @@ Menu::Menu() {
 
         QAction* visibleToEveryone = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToEveryone,
             0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::All,
-            this, SLOT(setVisibility()));
+            discoverabilityManager.data(), SLOT(setVisibility()));
         visibilityGroup->addAction(visibleToEveryone);
 
         QAction* visibleToFriends = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToFriends,
             0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::Friends,
-            this, SLOT(setVisibility()));
+            discoverabilityManager.data(), SLOT(setVisibility()));
         visibilityGroup->addAction(visibleToFriends);
 
         QAction* visibleToNoOne = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToNoOne,
             0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::None,
-            this, SLOT(setVisibility()));
+            discoverabilityManager.data(), SLOT(setVisibility()));
         visibilityGroup->addAction(visibleToNoOne);
 
         connect(discoverabilityManager.data(), &DiscoverabilityManager::discoverabilityModeChanged, 
-            this, &Menu::visibilityChanged);
+            discoverabilityManager.data(), &DiscoverabilityManager::visibilityChanged);
     }
 
     addActionToQMenuAndActionHash(toolsMenu,
@@ -362,30 +362,32 @@ Menu::Menu() {
 
         QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking,
             0, true,
-            this, SLOT(setActiveFaceTracker()));
+            qApp, SLOT(setActiveFaceTracker()));
         faceTrackerGroup->addAction(noFaceTracker);
 
 #ifdef HAVE_FACESHIFT
         QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
             0, false,
-            this, SLOT(setActiveFaceTracker()));
+            qApp, SLOT(setActiveFaceTracker()));
         faceTrackerGroup->addAction(faceshiftFaceTracker);
 #endif
 #ifdef HAVE_DDE
         QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::DDEFaceRegression, 
             0, false,
-            this, SLOT(setActiveFaceTracker()));
+            qApp, SLOT(setActiveFaceTracker()));
         faceTrackerGroup->addAction(ddeFaceTracker);
 #endif
 #ifdef HAVE_VISAGE
         QAction* visageFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Visage, 
             0, false,
-            this, SLOT(setActiveFaceTracker()));
+            qApp, SLOT(setActiveFaceTracker()));
         faceTrackerGroup->addAction(visageFaceTracker);
 #endif
     }
 #ifdef HAVE_DDE
     faceTrackingMenu->addSeparator();
+    QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::DDEFiltering, 0, true);
+    ddeFiltering->setVisible(false);
     QAction* ddeFaceTrackerReset = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::ResetDDETracking, 
         Qt::CTRL | Qt::Key_Apostrophe,
         DependencyManager::get<DdeFaceTracker>().data(), SLOT(resetTracking()));
@@ -961,37 +963,3 @@ bool Menu::menuItemExists(const QString& menu, const QString& menuitem) {
     }
     return false;
 };
-
-void Menu::setVisibility() {
-    auto discoverabilityManager = DependencyManager::get<DiscoverabilityManager>();
-
-    if (Menu::getInstance()->isOptionChecked(MenuOption::VisibleToEveryone)) {
-        discoverabilityManager->setDiscoverabilityMode(Discoverability::All);
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::VisibleToFriends)) {
-        discoverabilityManager->setDiscoverabilityMode(Discoverability::Friends);
-    } else if (Menu::getInstance()->isOptionChecked(MenuOption::VisibleToNoOne)) {
-        discoverabilityManager->setDiscoverabilityMode(Discoverability::None);
-    } else {
-        qCDebug(interfaceapp) << "ERROR Menu::setVisibility() called with unrecognized value.";
-    }
-}
-
-void Menu::visibilityChanged(Discoverability::Mode discoverabilityMode) {
-    if (discoverabilityMode == Discoverability::All) {
-        setIsOptionChecked(MenuOption::VisibleToEveryone, true);
-    } else if (discoverabilityMode == Discoverability::Friends) {
-        setIsOptionChecked(MenuOption::VisibleToFriends, true);
-    } else if (discoverabilityMode == Discoverability::None) {
-        setIsOptionChecked(MenuOption::VisibleToNoOne, true);
-    } else {
-        qCDebug(interfaceapp) << "ERROR Menu::visibilityChanged() called with unrecognized value.";
-    }
-}
-
-void Menu::setActiveFaceTracker() {
-#ifdef HAVE_DDE
-    bool isUsingDDE = Menu::getInstance()->isOptionChecked(MenuOption::DDEFaceRegression);
-    Menu::getInstance()->getActionForOption(MenuOption::ResetDDETracking)->setVisible(isUsingDDE);
-#endif
-    qApp->setActiveFaceTracker();
-}

interface/src/Menu.h

@@ -66,10 +66,6 @@ public slots:
     bool isOptionChecked(const QString& menuOption) const;
     void setIsOptionChecked(const QString& menuOption, bool isChecked);
     
-private slots:
-    void setVisibility();
-    void setActiveFaceTracker();
-
 private:
     static Menu* _instance;
     Menu();
@@ -100,8 +96,6 @@ private:
     int findPositionOfMenuItem(QMenu* menu, const QString& searchMenuItem);
     int positionBeforeSeparatorIfNeeded(QMenu* menu, int requestedPosition);
     
-    void visibilityChanged(Discoverability::Mode discoverabilityMode);
-    
     QHash<QString, QAction*> _actionHash;
 };
 
@@ -137,6 +131,7 @@ namespace MenuOption {
     const QString CopyAddress = "Copy Address to Clipboard";
     const QString CopyPath = "Copy Path to Clipboard";
     const QString DDEFaceRegression = "DDE Face Regression";
+    const QString DDEFiltering = "DDE Filtering";
     const QString DecreaseAvatarSize = "Decrease Avatar Size";
     const QString DeleteBookmark = "Delete Bookmark...";
     const QString DisableActivityLogger = "Disable Activity Logger";

interface/src/devices/DdeFaceTracker.cpp

@@ -17,6 +17,8 @@
 #include <QJsonObject>
 #include <QElapsedTimer>
 
+#include <GLMHelpers.h>
+
 #include "DdeFaceTracker.h"
 #include "FaceshiftConstants.h"
 #include "InterfaceLogging.h"
@@ -27,9 +29,9 @@ static const QHostAddress DDE_SERVER_ADDR("127.0.0.1");
 static const quint16 DDE_SERVER_PORT = 64204;
 static const quint16 DDE_CONTROL_PORT = 64205;
 #if defined(Q_OS_WIN)
-static const QString DDE_PROGRAM_PATH = QCoreApplication::applicationDirPath() + "/dde/dde.exe";
+static const QString DDE_PROGRAM_PATH = "/dde/dde.exe";
 #elif defined(Q_OS_MAC)
-static const QString DDE_PROGRAM_PATH = QCoreApplication::applicationDirPath() + "/dde.app/Contents/MacOS/dde";
+static const QString DDE_PROGRAM_PATH = "/dde.app/Contents/MacOS/dde";
 #endif
 static const QStringList DDE_ARGUMENTS = QStringList() 
     << "--udp=" + DDE_SERVER_ADDR.toString() + ":" + QString::number(DDE_SERVER_PORT) 
@@ -132,6 +134,8 @@ struct Packet {
     char name[MAX_NAME_SIZE + 1];
 };
 
+const float STARTING_DDE_MESSAGE_TIME = 0.033f;
+
 DdeFaceTracker::DdeFaceTracker() :
     DdeFaceTracker(QHostAddress::Any, DDE_SERVER_PORT, DDE_CONTROL_PORT)
 {
@@ -157,11 +161,16 @@ DdeFaceTracker::DdeFaceTracker(const QHostAddress& host, quint16 serverPort, qui
     _mouthSmileLeftIndex(28),
     _mouthSmileRightIndex(29),
     _jawOpenIndex(21),
-    _previousTranslation(glm::vec3()),
+    _lastMessageReceived(0),
-    _previousRotation(glm::quat())
+    _averageMessageTime(STARTING_DDE_MESSAGE_TIME),
+    _lastHeadTranslation(glm::vec3(0.0f)),
+    _filteredHeadTranslation(glm::vec3(0.0f)),
+    _lastLeftEyeBlink(0.0f),
+    _filteredLeftEyeBlink(0.0f),
+    _lastRightEyeBlink(0.0f),
+    _filteredRightEyeBlink(0.0f)
 {
     _coefficients.resize(NUM_FACESHIFT_BLENDSHAPES);
-    _previousCoefficients.resize(NUM_FACESHIFT_BLENDSHAPES);
 
     _blendshapeCoefficients.resize(NUM_FACESHIFT_BLENDSHAPES);
     
@@ -272,6 +281,8 @@ float DdeFaceTracker::getBlendshapeCoefficient(int index) const {
 
 void DdeFaceTracker::decodePacket(const QByteArray& buffer) {
     if(buffer.size() > MIN_PACKET_SIZE) {
+        bool isFiltering = Menu::getInstance()->isOptionChecked(MenuOption::DDEFiltering);
+
         Packet packet;
         int bytesToCopy = glm::min((int)sizeof(packet), buffer.size());
         memset(&packet.name, '\n', MAX_NAME_SIZE + 1);
@@ -292,13 +303,36 @@ void DdeFaceTracker::decodePacket(const QByteArray& buffer) {
         translation -= _referenceTranslation;
         translation /= LEAN_DAMPING_FACTOR;
         translation.x *= -1;
-        _headTranslation = (translation + _previousTranslation) / 2.0f;
+        if (isFiltering) {
-        _previousTranslation = translation;
+            glm::vec3 linearVelocity = (translation - _lastHeadTranslation) / _averageMessageTime;
+            const float LINEAR_VELOCITY_FILTER_STRENGTH = 0.3f;
+            float velocityFilter = glm::clamp(1.0f - glm::length(linearVelocity) *
+                LINEAR_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
+            _filteredHeadTranslation = velocityFilter * _filteredHeadTranslation + (1.0f - velocityFilter) * translation;
+            _lastHeadTranslation = translation;
+            _headTranslation = _filteredHeadTranslation;
+        } else {
+            _headTranslation = translation;
+        }
 
         // Compute relative rotation
         rotation = glm::inverse(_referenceRotation) * rotation;
-        _headRotation = (rotation + _previousRotation) / 2.0f;
+        if (isFiltering) {
-        _previousRotation = rotation;
+            glm::quat r = rotation * glm::inverse(_headRotation);
+            float theta = 2 * acos(r.w);
+            glm::vec3 angularVelocity;
+            if (theta > EPSILON) {
+                float rMag = glm::length(glm::vec3(r.x, r.y, r.z));
+                angularVelocity = theta / _averageMessageTime * glm::vec3(r.x, r.y, r.z) / rMag;
+            } else {
+                angularVelocity = glm::vec3(0, 0, 0);
+            }
+            const float ANGULAR_VELOCITY_FILTER_STRENGTH = 0.3f;
+            _headRotation = safeMix(_headRotation, rotation, glm::clamp(glm::length(angularVelocity) *
+                ANGULAR_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f));
+        } else {
+            _headRotation = rotation;
+        }
 
         // Translate DDE coefficients to Faceshift compatible coefficients
         for (int i = 0; i < NUM_EXPRESSIONS; i += 1) {
@@ -307,8 +341,23 @@ void DdeFaceTracker::decodePacket(const QByteArray& buffer) {
 
         // Use EyeBlink values to control both EyeBlink and EyeOpen
         static const float RELAXED_EYE_VALUE = 0.1f;
-        float leftEye = (_coefficients[_leftBlinkIndex] + _previousCoefficients[_leftBlinkIndex]) / 2.0f;
+        float leftEye = _coefficients[_leftBlinkIndex];
-        float rightEye = (_coefficients[_rightBlinkIndex] + _previousCoefficients[_rightBlinkIndex]) / 2.0f;
+        float rightEye = _coefficients[_rightBlinkIndex];
+        if (isFiltering) {
+            const float BLINK_VELOCITY_FILTER_STRENGTH = 0.3f;
+
+            float velocity = fabs(leftEye - _lastLeftEyeBlink) / _averageMessageTime;
+            float velocityFilter = glm::clamp(velocity * BLINK_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
+            _filteredLeftEyeBlink = velocityFilter * leftEye + (1.0f - velocityFilter) * _filteredLeftEyeBlink;
+            _lastLeftEyeBlink = leftEye;
+            leftEye = _filteredLeftEyeBlink;
+
+            velocity = fabs(rightEye - _lastRightEyeBlink) / _averageMessageTime;
+            velocityFilter = glm::clamp(velocity * BLINK_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
+            _filteredRightEyeBlink = velocityFilter * rightEye + (1.0f - velocityFilter) * _filteredRightEyeBlink;
+            _lastRightEyeBlink = rightEye;
+            rightEye = _filteredRightEyeBlink;
+        }
         if (leftEye > RELAXED_EYE_VALUE) {
             _coefficients[_leftBlinkIndex] = leftEye - RELAXED_EYE_VALUE;
             _coefficients[_leftEyeOpenIndex] = 0.0f;
@@ -343,10 +392,18 @@ void DdeFaceTracker::decodePacket(const QByteArray& buffer) {
         // Scale all coefficients
         for (int i = 0; i < NUM_EXPRESSIONS; i += 1) {
             _blendshapeCoefficients[i]
-                = glm::clamp(DDE_COEFFICIENT_SCALES[i] * (_coefficients[i] + _previousCoefficients[i]) / 2.0f, 0.0f, 1.0f);
+                = glm::clamp(DDE_COEFFICIENT_SCALES[i] * _coefficients[i], 0.0f, 1.0f);
-            _previousCoefficients[i] = _coefficients[i];
         }
 
+        // Calculate average frame time
+        const float FRAME_AVERAGING_FACTOR = 0.99f;
+        quint64 usecsNow = usecTimestampNow();
+        if (_lastMessageReceived != 0) {
+            _averageMessageTime = FRAME_AVERAGING_FACTOR * _averageMessageTime 
+                + (1.0f - FRAME_AVERAGING_FACTOR) * (float)(usecsNow - _lastMessageReceived) / 1000000.0f;
+        }
+        _lastMessageReceived = usecsNow;
+    
     } else {
         qCDebug(interfaceapp) << "[Error] DDE Face Tracker Decode Error";
     }

interface/src/devices/DdeFaceTracker.h

@@ -101,10 +101,14 @@ private:
 
     QVector<float> _coefficients;
 
-    // Previous values for simple smoothing
+    quint64 _lastMessageReceived;
-    glm::vec3 _previousTranslation;
+    float _averageMessageTime;
-    glm::quat _previousRotation;
+    glm::vec3 _lastHeadTranslation;
-    QVector<float> _previousCoefficients;
+    glm::vec3 _filteredHeadTranslation;
+    float _lastLeftEyeBlink;
+    float _filteredLeftEyeBlink;
+    float _lastRightEyeBlink;
+    float _filteredRightEyeBlink;
 };
 
 #endif // hifi_DdeFaceTracker_h

libraries/fbx/src/FBXReader.cpp

@@ -1705,7 +1705,12 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                     material._material->setDiffuse(material.diffuse); 
                     material._material->setSpecular(material.specular); 
                     material._material->setShininess(material.shininess); 
-                    material._material->setOpacity(material.opacity); 
+
+                    if (material.opacity <= 0.0f) {
+                        material._material->setOpacity(1.0f); 
+                    } else {
+                        material._material->setOpacity(material.opacity); 
+                    }
 
                     materials.insert(material.id, material);
 

libraries/model/src/model/Light.cpp

@@ -64,6 +64,10 @@ void Light::setIntensity(float intensity) {
     editSchema()._intensity = intensity;
 }
 
+void Light::setAmbientIntensity(float intensity) {
+    editSchema()._ambientIntensity = intensity;
+}
+
 void Light::setMaximumRadius(float radius) {
     if (radius <= 0.f) {
         radius = 1.0f;

libraries/model/src/model/Light.h

@@ -244,6 +244,10 @@ public:
     void setShowContour(float show);
     float getShowContour() const { return getSchema()._control.w; }
 
+    // If the light has an ambient (Indirect) component, then the Ambientintensity can be used to control its contribution to the lighting
+    void setAmbientIntensity(float intensity);
+    float getAmbientIntensity() const { return getSchema()._ambientIntensity; }
+
     // Spherical Harmonics storing the Ambien lighting approximation used for the Sun typed light
     void setAmbientSphere(const SphericalHarmonics& sphere) { _ambientSphere = sphere; }
     const SphericalHarmonics& getAmbientSphere() const { return _ambientSphere; }
@@ -254,14 +258,14 @@ public:
     public:
         Vec4 _position{0.0f, 0.0f, 0.0f, 1.0f}; 
         Vec3 _direction{0.0f, 0.0f, -1.0f};
-        float _spare0{0.0f};
+        float _ambientIntensity{0.0f};
         Color _color{1.0f};
         float _intensity{1.0f};
         Vec4 _attenuation{1.0f};
         Vec4 _spot{0.0f, 0.0f, 0.0f, 3.0f};
         Vec4 _shadow{0.0f};
 
-        Vec4 _control{0.0f};
+        Vec4 _control{0.0f, 0.0f, 0.0f, 0.0f};
 
         Schema() {}
     };

libraries/model/src/model/Light.slh

@@ -27,6 +27,7 @@ vec3 getLightDirection(Light l) { return l._direction.xyz; } // direction is -Z
 
 vec3 getLightColor(Light l) { return l._color.rgb; }
 float getLightIntensity(Light l) { return l._color.w; }
+float getLightAmbientIntensity(Light l) { return l._direction.w; }
 
 float evalLightAttenuation(Light l, float r) {
     float d = max(r - l._attenuation.x, 0.0);

libraries/model/src/model/Stage.cpp

@@ -203,6 +203,7 @@ SunSkyStage::SunSkyStage() :
     _sunLight->setType(Light::SUN);
  
     setSunIntensity(1.0f);
+    setSunAmbientIntensity(0.5f);
     setSunColor(Vec3(1.0f, 1.0f, 1.0f));
 
     // Default origin location is a special place in the world...
@@ -249,12 +250,26 @@ void SunSkyStage::setOriginLocation(float longitude, float latitude, float altit
     invalidate();
 }
 
+void SunSkyStage::setEarthSunModelEnable(bool isEnabled) {
+    _earthSunModelEnable = isEnabled;
+    invalidate();
+}
+
 void SunSkyStage::setSunColor(const Vec3& color) {
     _sunLight->setColor(color);
 }
 void SunSkyStage::setSunIntensity(float intensity) {
     _sunLight->setIntensity(intensity);
 }
+void SunSkyStage::setSunAmbientIntensity(float intensity) {
+    _sunLight->setAmbientIntensity(intensity);
+}
+
+void SunSkyStage::setSunDirection(const Vec3& direction) {
+    if (!isEarthSunModelEnabled()) {
+        _sunLight->setDirection(direction);
+    }
+}
 
 // THe sun declinaison calculus is taken from https://en.wikipedia.org/wiki/Position_of_the_Sun
 double evalSunDeclinaison(double dayNumber) {
@@ -271,19 +286,19 @@ void SunSkyStage::updateGraphicsObject() const {
     // And update the sunLAtitude as the declinaison depending of the time of the year
     _earthSunModel.setSunLatitude(evalSunDeclinaison(_yearTime)); 
 
-    Vec3d sunLightDir = -_earthSunModel.getSurfaceSunDir();
+    if (isEarthSunModelEnabled()) {
-    _sunLight->setDirection(Vec3(sunLightDir.x, sunLightDir.y, sunLightDir.z));
+        Vec3d sunLightDir = -_earthSunModel.getSurfaceSunDir();
+        _sunLight->setDirection(Vec3(sunLightDir.x, sunLightDir.y, sunLightDir.z));
 
-    double originAlt = _earthSunModel.getAltitude();
+        double originAlt = _earthSunModel.getAltitude();
-    _sunLight->setPosition(Vec3(0.0f, originAlt, 0.0f));
+        _sunLight->setPosition(Vec3(0.0f, originAlt, 0.0f));
+    }
 
     static int firstTime = 0;
     if (firstTime == 0) {
         firstTime++;
         gpu::Shader::makeProgram(*(_skyPipeline->getProgram()));
-    
     }
-
 }
 
 void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {

libraries/model/src/model/Stage.h

@@ -203,12 +203,22 @@ public:
     float getOriginLongitude() const { return _earthSunModel.getLongitude(); }
     float getOriginSurfaceAltitude() const { return _earthSunModel.getAltitude(); }
 
+    // Enable / disable the effect of the time and location on the sun direction and color
+    void setEarthSunModelEnable(bool isEnabled);
+    bool isEarthSunModelEnabled() const { return _earthSunModelEnable; }
+
     // Sun properties
     void setSunColor(const Vec3& color);
     const Vec3& getSunColor() const { return getSunLight()->getColor(); }
     void setSunIntensity(float intensity);
     float getSunIntensity() const { return getSunLight()->getIntensity(); }
+    void setSunAmbientIntensity(float intensity);
+    float getSunAmbientIntensity() const { return getSunLight()->getAmbientIntensity(); }
 
+    // The sun direction is expressed in the world space
+    void setSunDirection(const Vec3& direction);
+    const Vec3& getSunDirection() const { return getSunLight()->getDirection(); }
+
     LightPointer getSunLight() const { valid(); return _sunLight;  }
     AtmospherePointer getAtmosphere() const { valid(); return _atmosphere;  }
  
@@ -223,10 +233,10 @@ protected:
 
     gpu::PipelinePointer _skyPipeline;
 
-    float _dayTime;
+    float _dayTime = 12.0f;
-    int _yearTime;
+    int _yearTime = 0;
-
     mutable EarthSunModel _earthSunModel;
+    bool _earthSunModelEnable = true;
  
     mutable bool _invalid = true;
     void invalidate() const { _invalid = true; }

libraries/networking/src/AccountManager.cpp

@@ -366,7 +366,7 @@ void AccountManager::setAccessTokenForCurrentAuthURL(const QString& accessToken)
     OAuthAccessToken newOAuthToken;
     newOAuthToken.token = accessToken;
     
-    qCDebug(networking) << "Setting new account manager access token to" << accessToken;
+    qCDebug(networking) << "Setting new account manager access token. F2C:" << accessToken.left(2) << "L2C:" << accessToken.right(2);
     
     _accountInfo.setAccessToken(newOAuthToken);
 }

libraries/render-utils/CMakeLists.txt

@@ -12,4 +12,16 @@ add_dependency_external_projects(glm)
 find_package(GLM REQUIRED)
 target_include_directories(${TARGET_NAME} PUBLIC ${GLM_INCLUDE_DIRS})
 
+if (WIN32)
+  if (USE_NSIGHT)
+    # try to find the Nsight package and add it to the build if we find it
+    find_package(NSIGHT)
+    if (NSIGHT_FOUND)
+      include_directories(${NSIGHT_INCLUDE_DIRS})
+      add_definitions(-DNSIGHT_FOUND)
+      target_link_libraries(${TARGET_NAME} "${NSIGHT_LIBRARIES}")
+    endif ()
+  endif()
+endif (WIN32)
+
 link_hifi_libraries(animation fbx shared gpu)

libraries/render-utils/src/DeferredGlobalLight.slh

@@ -66,7 +66,7 @@ vec3 evalAmbienGlobalColor(float shadowAttenuation, vec3 position, vec3 normal,
     vec4 fragEyeVector = invViewMat * vec4(-position, 0.0);
     vec3 fragEyeDir = normalize(fragEyeVector.xyz);
 
-    vec3 color = diffuse.rgb * getLightColor(light) * 0.5;
+    vec3 color = diffuse.rgb * getLightColor(light) * getLightAmbientIntensity(light);
 
     vec4 shading = evalFragShading(fragNormal, -getLightDirection(light), fragEyeDir, specular, gloss);
 
@@ -83,7 +83,7 @@ vec3 evalAmbienSphereGlobalColor(float shadowAttenuation, vec3 position, vec3 no
     vec3 fragEyeDir = normalize(fragEyeVector.xyz);
     
     vec3 ambientNormal = fragNormal.xyz;
-    vec3 color = diffuse.rgb * 0.5 * evalSphericalLight(ambientSphere, ambientNormal).xyz;
+    vec3 color = diffuse.rgb * evalSphericalLight(ambientSphere, ambientNormal).xyz * getLightAmbientIntensity(light);
 
     vec4 shading = evalFragShading(fragNormal, -getLightDirection(light), fragEyeDir, specular, gloss);
 
@@ -112,7 +112,7 @@ vec3 evalLightmappedColor(float shadowAttenuation, vec3 normal, vec3 diffuse, ve
     vec3 diffuseLight = lightAttenuation * lightmap;
 
     // ambient is a tiny percentage of the lightmap and only when in the shadow
-    vec3 ambientLight = (1 - lightAttenuation) * 0.5 * lightmap; 
+    vec3 ambientLight = (1 - lightAttenuation) * lightmap * getLightAmbientIntensity(light); 
 
     return diffuse * (ambientLight +  diffuseLight);
 }

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -554,11 +554,12 @@ void DeferredLightingEffect::setAmbientLightMode(int preset) {
     }
 }
 
-void DeferredLightingEffect::setGlobalLight(const glm::vec3& direction, const glm::vec3& diffuse, float intensity) {
+void DeferredLightingEffect::setGlobalLight(const glm::vec3& direction, const glm::vec3& diffuse, float intensity, float ambientIntensity) {
     auto light = _allocatedLights.front();
     light->setDirection(direction);
     light->setColor(diffuse);
     light->setIntensity(intensity);
+    light->setAmbientIntensity(ambientIntensity);
 }
 
 void DeferredLightingEffect::setGlobalSkybox(const model::SkyboxPointer& skybox) {

libraries/render-utils/src/DeferredLightingEffect.h

@@ -73,7 +73,7 @@ public:
 
     // update global lighting
     void setAmbientLightMode(int preset);
-    void setGlobalLight(const glm::vec3& direction, const glm::vec3& diffuse, float intensity);
+    void setGlobalLight(const glm::vec3& direction, const glm::vec3& diffuse, float intensity, float ambientIntensity);
     void setGlobalAtmosphere(const model::AtmospherePointer& atmosphere) { _atmosphere = atmosphere; }
 
     void setGlobalSkybox(const model::SkyboxPointer& skybox);

libraries/render-utils/src/Model.cpp

@@ -244,13 +244,6 @@ void Model::initJointTransforms() {
 
 void Model::init() {
     if (_renderPipelineLib.empty()) {
-        gpu::Shader::BindingSet slotBindings;
-        slotBindings.insert(gpu::Shader::Binding(std::string("materialBuffer"), MATERIAL_GPU_SLOT));
-        slotBindings.insert(gpu::Shader::Binding(std::string("diffuseMap"), 0));
-        slotBindings.insert(gpu::Shader::Binding(std::string("normalMap"), 1));
-        slotBindings.insert(gpu::Shader::Binding(std::string("specularMap"), 2));
-        slotBindings.insert(gpu::Shader::Binding(std::string("emissiveMap"), 3));
-
         // Vertex shaders
         auto modelVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_vert)));
         auto modelNormalMapVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_normal_map_vert)));
@@ -291,10 +284,24 @@ void Model::init() {
             RenderKey(RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR),
             modelNormalMapVertex, modelNormalSpecularMapPixel);
 
+
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::IS_TRANSLUCENT),
             modelVertex, modelTranslucentPixel);
  
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::HAS_TANGENTS | RenderKey::IS_TRANSLUCENT),
+            modelNormalMapVertex, modelTranslucentPixel);
+
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::HAS_SPECULAR | RenderKey::IS_TRANSLUCENT),
+            modelVertex, modelTranslucentPixel);
+
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR | RenderKey::IS_TRANSLUCENT),
+            modelNormalMapVertex, modelTranslucentPixel);
+
+
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::HAS_LIGHTMAP),
             modelLightmapVertex, modelLightmapPixel);
@@ -310,6 +317,7 @@ void Model::init() {
             RenderKey(RenderKey::HAS_LIGHTMAP | RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR),
             modelLightmapNormalMapVertex, modelLightmapNormalSpecularMapPixel);
 
+
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::IS_SKINNED),
             skinModelVertex, modelPixel);
@@ -326,15 +334,29 @@ void Model::init() {
             RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR),
             skinModelNormalMapVertex, modelNormalSpecularMapPixel);
 
+
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_TRANSLUCENT),
             skinModelVertex, modelTranslucentPixel);
 
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_TANGENTS | RenderKey::IS_TRANSLUCENT),
+            skinModelNormalMapVertex, modelTranslucentPixel);
+
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_SPECULAR | RenderKey::IS_TRANSLUCENT),
+            skinModelVertex, modelTranslucentPixel);
+
+        _renderPipelineLib.addRenderPipeline(
+            RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR | RenderKey::IS_TRANSLUCENT),
+            skinModelNormalMapVertex, modelTranslucentPixel);
+
 
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
             modelShadowVertex, modelShadowPixel);
 
+
         _renderPipelineLib.addRenderPipeline(
             RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
             skinModelShadowVertex, modelShadowPixel);
@@ -1935,55 +1957,7 @@ bool Model::renderInScene(float alpha, RenderArgs* args) {
 }
 
 void Model::segregateMeshGroups() {
-    _meshesTranslucentTangents.clear();
+    _renderBuckets.clear();
-    _meshesTranslucent.clear();
-    _meshesTranslucentTangentsSpecular.clear();
-    _meshesTranslucentSpecular.clear();
-
-    _meshesTranslucentTangentsSkinned.clear();
-    _meshesTranslucentSkinned.clear();
-    _meshesTranslucentTangentsSpecularSkinned.clear();
-    _meshesTranslucentSpecularSkinned.clear();
-
-    _meshesOpaqueTangents.clear();
-    _meshesOpaque.clear();
-    _meshesOpaqueTangentsSpecular.clear();
-    _meshesOpaqueSpecular.clear();
-
-    _meshesOpaqueTangentsSkinned.clear();
-    _meshesOpaqueSkinned.clear();
-    _meshesOpaqueTangentsSpecularSkinned.clear();
-    _meshesOpaqueSpecularSkinned.clear();
-
-    _meshesOpaqueLightmapTangents.clear();
-    _meshesOpaqueLightmap.clear();
-    _meshesOpaqueLightmapTangentsSpecular.clear();
-    _meshesOpaqueLightmapSpecular.clear();
-
-    _unsortedMeshesTranslucentTangents.clear();
-    _unsortedMeshesTranslucent.clear();
-    _unsortedMeshesTranslucentTangentsSpecular.clear();
-    _unsortedMeshesTranslucentSpecular.clear();
-
-    _unsortedMeshesTranslucentTangentsSkinned.clear();
-    _unsortedMeshesTranslucentSkinned.clear();
-    _unsortedMeshesTranslucentTangentsSpecularSkinned.clear();
-    _unsortedMeshesTranslucentSpecularSkinned.clear();
-
-    _unsortedMeshesOpaqueTangents.clear();
-    _unsortedMeshesOpaque.clear();
-    _unsortedMeshesOpaqueTangentsSpecular.clear();
-    _unsortedMeshesOpaqueSpecular.clear();
-
-    _unsortedMeshesOpaqueTangentsSkinned.clear();
-    _unsortedMeshesOpaqueSkinned.clear();
-    _unsortedMeshesOpaqueTangentsSpecularSkinned.clear();
-    _unsortedMeshesOpaqueSpecularSkinned.clear();
-
-    _unsortedMeshesOpaqueLightmapTangents.clear();
-    _unsortedMeshesOpaqueLightmap.clear();
-    _unsortedMeshesOpaqueLightmapTangentsSpecular.clear();
-    _unsortedMeshesOpaqueLightmapSpecular.clear();
 
     const FBXGeometry& geometry = _geometry->getFBXGeometry();
     const QVector<NetworkMesh>& networkMeshes = _geometry->getMeshes();
@@ -2017,201 +1991,19 @@ void Model::segregateMeshGroups() {
             qCDebug(renderutils) << "materialID:" << materialID << "parts:" << mesh.parts.size();
         }
 
-        if (!hasLightmap) {
+        RenderKey key(translucentMesh, hasLightmap, hasTangents, hasSpecular, isSkinned);
-            if (translucentMesh && !hasTangents && !hasSpecular && !isSkinned) {
 
-                _unsortedMeshesTranslucent.insertMulti(materialID, i);
+        // reuse or create the bucket corresponding to that key and insert the mesh as unsorted
-
+        _renderBuckets[key.getRaw()]._unsortedMeshes.insertMulti(materialID, i);
-            } else if (translucentMesh && hasTangents && !hasSpecular && !isSkinned) {
-
-                _unsortedMeshesTranslucentTangents.insertMulti(materialID, i);
-
-            } else if (translucentMesh && hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesTranslucentTangentsSpecular.insertMulti(materialID, i);
-
-            } else if (translucentMesh && !hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesTranslucentSpecular.insertMulti(materialID, i);
-
-            } else if (translucentMesh && hasTangents && !hasSpecular && isSkinned) {
-
-                _unsortedMeshesTranslucentTangentsSkinned.insertMulti(materialID, i);
-
-            } else if (translucentMesh && !hasTangents && !hasSpecular && isSkinned) {
-
-                _unsortedMeshesTranslucentSkinned.insertMulti(materialID, i);
-
-            } else if (translucentMesh && hasTangents && hasSpecular && isSkinned) {
-
-                _unsortedMeshesTranslucentTangentsSpecularSkinned.insertMulti(materialID, i);
-
-            } else if (translucentMesh && !hasTangents && hasSpecular && isSkinned) {
-
-                _unsortedMeshesTranslucentSpecularSkinned.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && !hasTangents && !hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaque.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && !hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueTangents.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueTangentsSpecular.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && !hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueSpecular.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && !hasSpecular && isSkinned) {
-
-                _unsortedMeshesOpaqueTangentsSkinned.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && !hasTangents && !hasSpecular && isSkinned) {
-
-                _unsortedMeshesOpaqueSkinned.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && hasSpecular && isSkinned) {
-
-                _unsortedMeshesOpaqueTangentsSpecularSkinned.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && !hasTangents && hasSpecular && isSkinned) {
-
-                _unsortedMeshesOpaqueSpecularSkinned.insertMulti(materialID, i);
-            } else {
-                qCDebug(renderutils) << "unexpected!!! this mesh didn't fall into any or our groups???";
-            }
-        } else {
-            if (!translucentMesh && !hasTangents && !hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueLightmap.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && !hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueLightmapTangents.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueLightmapTangentsSpecular.insertMulti(materialID, i);
-
-            } else if (!translucentMesh && !hasTangents && hasSpecular && !isSkinned) {
-
-                _unsortedMeshesOpaqueLightmapSpecular.insertMulti(materialID, i);
-
-            } else {
-                qCDebug(renderutils) << "unexpected!!! this mesh didn't fall into any or our groups???";
-            }
-        }
     }
     
-    foreach(int i, _unsortedMeshesTranslucent) {
+    for(auto& b : _renderBuckets) {
-        _meshesTranslucent.append(i);
+        foreach(auto i, b.second._unsortedMeshes) {
+            b.second._meshes.append(i);
+            b.second._unsortedMeshes.clear();
+        }
     }
 
-    foreach(int i, _unsortedMeshesTranslucentTangents) {
-        _meshesTranslucentTangents.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentTangentsSpecular) {
-        _meshesTranslucentTangentsSpecular.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentSpecular) {
-        _meshesTranslucentSpecular.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentSkinned) {
-        _meshesTranslucentSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentTangentsSkinned) {
-        _meshesTranslucentTangentsSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentTangentsSpecularSkinned) {
-        _meshesTranslucentTangentsSpecularSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesTranslucentSpecularSkinned) {
-        _meshesTranslucentSpecularSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaque) {
-        _meshesOpaque.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueTangents) {
-        _meshesOpaqueTangents.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueTangentsSpecular) {
-        _meshesOpaqueTangentsSpecular.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueSpecular) {
-        _meshesOpaqueSpecular.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueSkinned) {
-        _meshesOpaqueSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueTangentsSkinned) {
-        _meshesOpaqueTangentsSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueTangentsSpecularSkinned) {
-        _meshesOpaqueTangentsSpecularSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueSpecularSkinned) {
-        _meshesOpaqueSpecularSkinned.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueLightmap) {
-        _meshesOpaqueLightmap.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueLightmapTangents) {
-        _meshesOpaqueLightmapTangents.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueLightmapTangentsSpecular) {
-        _meshesOpaqueLightmapTangentsSpecular.append(i);
-    }
-
-    foreach(int i, _unsortedMeshesOpaqueLightmapSpecular) {
-        _meshesOpaqueLightmapSpecular.append(i);
-    }
-
-    _unsortedMeshesTranslucentTangents.clear();
-    _unsortedMeshesTranslucent.clear();
-    _unsortedMeshesTranslucentTangentsSpecular.clear();
-    _unsortedMeshesTranslucentSpecular.clear();
-
-    _unsortedMeshesTranslucentTangentsSkinned.clear();
-    _unsortedMeshesTranslucentSkinned.clear();
-    _unsortedMeshesTranslucentTangentsSpecularSkinned.clear();
-    _unsortedMeshesTranslucentSpecularSkinned.clear();
-
-    _unsortedMeshesOpaqueTangents.clear();
-    _unsortedMeshesOpaque.clear();
-    _unsortedMeshesOpaqueTangentsSpecular.clear();
-    _unsortedMeshesOpaqueSpecular.clear();
-
-    _unsortedMeshesOpaqueTangentsSkinned.clear();
-    _unsortedMeshesOpaqueSkinned.clear();
-    _unsortedMeshesOpaqueTangentsSpecularSkinned.clear();
-    _unsortedMeshesOpaqueSpecularSkinned.clear();
-
-    _unsortedMeshesOpaqueLightmapTangents.clear();
-    _unsortedMeshesOpaqueLightmap.clear();
-    _unsortedMeshesOpaqueLightmapTangentsSpecular.clear();
-    _unsortedMeshesOpaqueLightmapSpecular.clear();
-
     _meshGroupsKnown = true;
 }
 
@@ -2220,52 +2012,14 @@ QVector<int>* Model::pickMeshList(bool translucent, float alphaThreshold, bool h
 
     // depending on which parameters we were called with, pick the correct mesh group to render
     QVector<int>* whichList = NULL;
-    if (translucent && !hasTangents && !hasSpecular && !isSkinned) {
-        whichList = &_meshesTranslucent;
-    } else if (translucent && hasTangents && !hasSpecular && !isSkinned) {
-        whichList = &_meshesTranslucentTangents;
-    } else if (translucent && hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesTranslucentTangentsSpecular;
-    } else if (translucent && !hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesTranslucentSpecular;
-    } else if (translucent && hasTangents && !hasSpecular && isSkinned) {
-        whichList = &_meshesTranslucentTangentsSkinned;
-    } else if (translucent && !hasTangents && !hasSpecular && isSkinned) {
-        whichList = &_meshesTranslucentSkinned;
-    } else if (translucent && hasTangents && hasSpecular && isSkinned) {
-        whichList = &_meshesTranslucentTangentsSpecularSkinned;
-    } else if (translucent && !hasTangents && hasSpecular && isSkinned) {
-        whichList = &_meshesTranslucentSpecularSkinned;
 
-    } else if (!translucent && !hasLightmap && !hasTangents && !hasSpecular && !isSkinned) {
+    RenderKey key(translucent, hasLightmap, hasTangents, hasSpecular, isSkinned);
-        whichList = &_meshesOpaque;
-    } else if (!translucent && !hasLightmap && hasTangents && !hasSpecular && !isSkinned) {
-        whichList = &_meshesOpaqueTangents;
-    } else if (!translucent && !hasLightmap && hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesOpaqueTangentsSpecular;
-    } else if (!translucent && !hasLightmap && !hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesOpaqueSpecular;
-    } else if (!translucent && !hasLightmap && hasTangents && !hasSpecular && isSkinned) {
-        whichList = &_meshesOpaqueTangentsSkinned;
-    } else if (!translucent && !hasLightmap && !hasTangents && !hasSpecular && isSkinned) {
-        whichList = &_meshesOpaqueSkinned;
-    } else if (!translucent && !hasLightmap && hasTangents && hasSpecular && isSkinned) {
-        whichList = &_meshesOpaqueTangentsSpecularSkinned;
-    } else if (!translucent && !hasLightmap && !hasTangents && hasSpecular && isSkinned) {
-        whichList = &_meshesOpaqueSpecularSkinned;
 
-    } else if (!translucent && hasLightmap && !hasTangents && !hasSpecular && !isSkinned) {
+    auto bucket = _renderBuckets.find(key.getRaw());
-        whichList = &_meshesOpaqueLightmap;
+    if (bucket != _renderBuckets.end()) {
-    } else if (!translucent && hasLightmap && hasTangents && !hasSpecular && !isSkinned) {
+        whichList = &(*bucket).second._meshes;
-        whichList = &_meshesOpaqueLightmapTangents;
-    } else if (!translucent && hasLightmap && hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesOpaqueLightmapTangentsSpecular;
-    } else if (!translucent && hasLightmap && !hasTangents && hasSpecular && !isSkinned) {
-        whichList = &_meshesOpaqueLightmapSpecular;
-
-    } else {
-        qCDebug(renderutils) << "unexpected!!! this mesh didn't fall into any or our groups???";
     }
+
     return whichList;
 }
 
@@ -2277,6 +2031,7 @@ void Model::pickPrograms(gpu::Batch& batch, RenderMode mode, bool translucent, f
     auto pipeline = _renderPipelineLib.find(key.getRaw());
     if (pipeline == _renderPipelineLib.end()) {
         qDebug() << "No good, couldn't find a pipeline from the key ?" << key.getRaw();
+        locations = 0;
         return;
     }
 
@@ -2303,7 +2058,7 @@ int Model::renderMeshesForModelsInScene(gpu::Batch& batch, RenderMode mode, bool
     int meshPartsRendered = 0;
 
     bool pickProgramsNeeded = true;
-    Locations* locations;
+    Locations* locations = nullptr;
     
     foreach(Model* model, _modelsInScene) {
         QVector<int>* whichList = model->pickMeshList(translucent, alphaThreshold, hasLightmap, hasTangents, hasSpecular, isSkinned);
@@ -2331,20 +2086,19 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl
     PROFILE_RANGE(__FUNCTION__);
     int meshPartsRendered = 0;
 
-    QVector<int>* whichList = pickMeshList(translucent, alphaThreshold, hasLightmap, hasTangents, hasSpecular, isSkinned);
+    //Pick the mesh list with the requested render flags
-    
+    QVector<int>* whichList = pickMeshList(translucent, alphaThreshold, hasLightmap, hasTangents, hasSpecular, isSkinned);    
     if (!whichList) {
-        qCDebug(renderutils) << "unexpected!!! we don't know which list of meshes to render...";
         return 0;
     }
     QVector<int>& list = *whichList;
 
     // If this list has nothing to render, then don't bother proceeding. This saves us on binding to programs    
-    if (list.size() == 0) {
+    if (list.empty()) {
         return 0;
     }
 
-    Locations* locations;
+    Locations* locations = nullptr;
     pickPrograms(batch, mode, translucent, alphaThreshold, hasLightmap, hasTangents, hasSpecular, isSkinned, 
                                 args, locations);
     meshPartsRendered = renderMeshesFromList(list, batch, mode, translucent, alphaThreshold, 

libraries/render-utils/src/Model.h

@@ -350,58 +350,6 @@ private:
 
     bool _meshGroupsKnown;
 
-    QMap<QString, int> _unsortedMeshesTranslucent;
-    QMap<QString, int> _unsortedMeshesTranslucentTangents;
-    QMap<QString, int> _unsortedMeshesTranslucentTangentsSpecular;
-    QMap<QString, int> _unsortedMeshesTranslucentSpecular;
-
-    QMap<QString, int> _unsortedMeshesTranslucentSkinned;
-    QMap<QString, int> _unsortedMeshesTranslucentTangentsSkinned;
-    QMap<QString, int> _unsortedMeshesTranslucentTangentsSpecularSkinned;
-    QMap<QString, int> _unsortedMeshesTranslucentSpecularSkinned;
-
-    QMap<QString, int> _unsortedMeshesOpaque;
-    QMap<QString, int> _unsortedMeshesOpaqueTangents;
-    QMap<QString, int> _unsortedMeshesOpaqueTangentsSpecular;
-    QMap<QString, int> _unsortedMeshesOpaqueSpecular;
-
-    QMap<QString, int> _unsortedMeshesOpaqueSkinned;
-    QMap<QString, int> _unsortedMeshesOpaqueTangentsSkinned;
-    QMap<QString, int> _unsortedMeshesOpaqueTangentsSpecularSkinned;
-    QMap<QString, int> _unsortedMeshesOpaqueSpecularSkinned;
-
-    QMap<QString, int> _unsortedMeshesOpaqueLightmap;
-    QMap<QString, int> _unsortedMeshesOpaqueLightmapTangents;
-    QMap<QString, int> _unsortedMeshesOpaqueLightmapTangentsSpecular;
-    QMap<QString, int> _unsortedMeshesOpaqueLightmapSpecular;
-    
-    typedef std::unordered_map<int, QVector<int>> MeshListMap;
-    MeshListMap _sortedMeshes;
-
-    QVector<int> _meshesTranslucent;
-    QVector<int> _meshesTranslucentTangents;
-    QVector<int> _meshesTranslucentTangentsSpecular;
-    QVector<int> _meshesTranslucentSpecular;
-
-    QVector<int> _meshesTranslucentSkinned;
-    QVector<int> _meshesTranslucentTangentsSkinned;
-    QVector<int> _meshesTranslucentTangentsSpecularSkinned;
-    QVector<int> _meshesTranslucentSpecularSkinned;
-
-    QVector<int> _meshesOpaque;
-    QVector<int> _meshesOpaqueTangents;
-    QVector<int> _meshesOpaqueTangentsSpecular;
-    QVector<int> _meshesOpaqueSpecular;
-
-    QVector<int> _meshesOpaqueSkinned;
-    QVector<int> _meshesOpaqueTangentsSkinned;
-    QVector<int> _meshesOpaqueTangentsSpecularSkinned;
-    QVector<int> _meshesOpaqueSpecularSkinned;
-
-    QVector<int> _meshesOpaqueLightmap;
-    QVector<int> _meshesOpaqueLightmapTangents;
-    QVector<int> _meshesOpaqueLightmapTangentsSpecular;
-    QVector<int> _meshesOpaqueLightmapSpecular;
 
     // debug rendering support
     void renderDebugMeshBoxes();
@@ -490,6 +438,17 @@ private:
 
         int getRaw() { return *reinterpret_cast<int*>(this); }
 
+
+        RenderKey(
+            bool translucent, bool hasLightmap,
+            bool hasTangents, bool hasSpecular, bool isSkinned) :
+            RenderKey(  (translucent ? IS_TRANSLUCENT : 0)
+                      | (hasLightmap ? HAS_LIGHTMAP : 0)
+                      | (hasTangents ? HAS_TANGENTS : 0)
+                      | (hasSpecular ? HAS_SPECULAR : 0)
+                      | (isSkinned ? IS_SKINNED : 0)
+                     ) {}
+
         RenderKey(RenderArgs::RenderMode mode,
             bool translucent, float alphaThreshold, bool hasLightmap,
             bool hasTangents, bool hasSpecular, bool isSkinned) :
@@ -527,6 +486,19 @@ private:
     };
     static RenderPipelineLib _renderPipelineLib;
 
+   
+    class RenderBucket {
+    public:
+        QVector<int> _meshes;
+        QMap<QString, int> _unsortedMeshes;
+    };
+    typedef std::unordered_map<int, RenderBucket> BaseRenderBucketMap;
+    class RenderBucketMap : public BaseRenderBucketMap {
+    public:
+        typedef RenderKey Key;
+    };
+    RenderBucketMap _renderBuckets;
+
     bool _renderCollisionHull;
 };
 

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -50,7 +50,7 @@ void SceneScriptingInterface::setSunColor(const glm::vec3& color) {
     _skyStage->setSunColor(color);
 }
 
-const glm::vec3& SceneScriptingInterface::getSunColor() const {
+glm::vec3 SceneScriptingInterface::getSunColor() const {
     return _skyStage->getSunColor();
 }
 
@@ -62,6 +62,30 @@ float SceneScriptingInterface::getSunIntensity() const {
     return _skyStage->getSunIntensity();
 }
 
+void SceneScriptingInterface::setSunAmbientIntensity(float intensity) {
+    _skyStage->setSunAmbientIntensity(intensity);
+}
+
+float SceneScriptingInterface::getSunAmbientIntensity() const {
+    return _skyStage->getSunAmbientIntensity();
+}
+
+void SceneScriptingInterface::setSunDirection(const glm::vec3& direction) {
+    _skyStage->setSunDirection(direction);
+}
+
+glm::vec3 SceneScriptingInterface::getSunDirection() const {
+    return _skyStage->getSunDirection();
+}
+
+void SceneScriptingInterface::setStageEarthSunModelEnable(bool isEnabled) {
+    _skyStage->setEarthSunModelEnable(isEnabled);
+}
+
+bool SceneScriptingInterface::isStageEarthSunModelEnabled() const {
+    return _skyStage->isEarthSunModelEnabled();
+}
+
 model::SunSkyStagePointer SceneScriptingInterface::getSkyStage() const {
     return _skyStage;
 }

libraries/script-engine/src/SceneScriptingInterface.h

@@ -38,10 +38,24 @@ public:
     Q_INVOKABLE void setStageYearTime(int day);
     Q_INVOKABLE int getStageYearTime() const;
 
+    Q_INVOKABLE void setStageEarthSunModelEnable(bool isEnabled);
+    Q_INVOKABLE bool isStageEarthSunModelEnabled() const;
+
+
     Q_INVOKABLE void setSunColor(const glm::vec3& color);
-    Q_INVOKABLE const glm::vec3& getSunColor() const;
+    Q_INVOKABLE glm::vec3 getSunColor() const;
     Q_INVOKABLE void setSunIntensity(float intensity);
     Q_INVOKABLE float getSunIntensity() const;
+    Q_INVOKABLE void setSunAmbientIntensity(float intensity);
+    Q_INVOKABLE float getSunAmbientIntensity() const;
+
+    // Only valid if stage Earth Sun model is disabled
+    Q_INVOKABLE void setSunDirection(const glm::vec3& direction);
+
+    Q_INVOKABLE glm::vec3 getSunDirection() const;
+
+
+
 
     model::SunSkyStagePointer getSkyStage() const;