Merge pull request #6715 from zzmp/refactor/scene-render-js

Clean up interfaces for JS Scene/Render

examples/utilities/tools/renderEngineDebug.js

@@ -22,7 +22,7 @@ Number.prototype.clamp = function(min, max) {
 var panel = new Panel(10, 100);
 
 function CounterWidget(parentPanel, name, feedGetter, drawGetter, capSetter, capGetter) {
-    this.subPanel = panel.newSubPanel(name);
+    this.subPanel = parentPanel.newSubPanel(name);
 
     this.subPanel.newSlider("Num Feed", 0, 1, 
         function(value) { },
@@ -37,12 +37,14 @@ function CounterWidget(parentPanel, name, feedGetter, drawGetter, capSetter, cap
         capGetter,
         function(value) { return (value); });
 
-   this.update = function () {
+    this.update = function () {
         var numFeed = this.subPanel.get("Num Feed");
-        this.subPanel.set("Num Feed", numFeed);
+        var numDrawn = this.subPanel.get("Num Drawn");
-        this.subPanel.set("Num Drawn", this.subPanel.get("Num Drawn"));
-
         var numMax = Math.max(numFeed, 1);
+
+        this.subPanel.set("Num Feed", numFeed);
+        this.subPanel.set("Num Drawn", numDrawn);
+
         this.subPanel.getWidget("Num Feed").setMaxValue(numMax);
         this.subPanel.getWidget("Num Drawn").setMaxValue(numMax);
         this.subPanel.getWidget("Max Drawn").setMaxValue(numMax);
@@ -50,46 +52,46 @@ function CounterWidget(parentPanel, name, feedGetter, drawGetter, capSetter, cap
 };
 
 var opaquesCounter = new CounterWidget(panel, "Opaques",
-    function () { return Render.getEngineNumFeedOpaqueItems(); },
+    function () { return Render.opaque.numFeed; },
-    function () { return Render.getEngineNumDrawnOpaqueItems(); },
+    function () { return Render.opaque.numDrawn; },
-    function(value) {    Render.setEngineMaxDrawnOpaqueItems(value); },
+    function(value) {    Render.opaque.maxDrawn = value; },
-    function () { return Render.getEngineMaxDrawnOpaqueItems(); }
+    function () { return Render.opaque.maxDrawn; }
 );
 
 var transparentsCounter = new CounterWidget(panel, "Transparents",
-    function () { return Render.getEngineNumFeedTransparentItems(); },
+    function () { return Render.transparent.numFeed; },
-    function () { return Render.getEngineNumDrawnTransparentItems(); },
+    function () { return Render.transparent.numDrawn; },
-    function(value) {    Render.setEngineMaxDrawnTransparentItems(value); },
+    function(value) {    Render.transparent.maxDrawn = value; },
-    function () { return Render.getEngineMaxDrawnTransparentItems(); }
+    function () { return Render.transparent.maxDrawn; }
 );
 
 var overlaysCounter = new CounterWidget(panel, "Overlays",
-    function () { return Render.getEngineNumFeedOverlay3DItems(); },
+    function () { return Render.overlay3D.numFeed; },
-    function () { return Render.getEngineNumDrawnOverlay3DItems(); },
+    function () { return Render.overlay3D.numDrawn; },
-    function(value) {    Render.setEngineMaxDrawnOverlay3DItems(value); },
+    function(value) {    Render.overlay3D.maxDrawn = value; },
-    function () { return Render.getEngineMaxDrawnOverlay3DItems(); }
+    function () { return Render.overlay3D.maxDrawn; }
 );
 
 var resizing = false;
 var previousMode = Settings.getValue(SETTINGS_KEY, -1);
 Menu.addActionGroup(MENU, ACTIONS, ACTIONS[previousMode + 1]);
-Render.setEngineDeferredDebugMode(previousMode);
+Render.deferredDebugMode = previousMode;
-Render.setEngineDeferredDebugSize({ x: 0.0, y: -1.0, z: 1.0, w: 1.0 }); // Reset to default size
+Render.deferredDebugSize = { x: 0.0, y: -1.0, z: 1.0, w: 1.0 }; // Reset to default size
 
 function setEngineDeferredDebugSize(eventX) {
     var scaledX = (2.0 * (eventX / Window.innerWidth) - 1.0).clamp(-1.0, 1.0);
-    Render.setEngineDeferredDebugSize({ x: scaledX, y: -1.0, z: 1.0, w: 1.0 });
+    Render.deferredDebugSize = { x: scaledX, y: -1.0, z: 1.0, w: 1.0 };
 }
 function shouldStartResizing(eventX) {
-    var x = Math.abs(eventX - Window.innerWidth * (1.0 + Render.getEngineDeferredDebugSize().x) / 2.0);
+    var x = Math.abs(eventX - Window.innerWidth * (1.0 + Render.deferredDebugSize.x) / 2.0);
-    var mode = Render.getEngineDeferredDebugMode();
+    var mode = Render.deferredDebugMode;
     return mode !== -1 && x < 20;
 }
 
 function menuItemEvent(menuItem) {
     var index = ACTIONS.indexOf(menuItem);
     if (index >= 0) {
-        Render.setEngineDeferredDebugMode(index - 1);
+        Render.deferredDebugMode = (index - 1);
     }
 }
 
@@ -98,24 +100,24 @@ var showDisplayStatusFlag = 1;
 var showNetworkStatusFlag = 2;
 
 panel.newCheckbox("Display status",
-    function(value) { Render.setEngineDisplayItemStatus(value ?
+    function(value) { Render.displayItemStatus = (value ?
-                                                       Render.doEngineDisplayItemStatus() | showDisplayStatusFlag :
+                                                       Render.displayItemStatus | showDisplayStatusFlag :
-                                                       Render.doEngineDisplayItemStatus() & ~showDisplayStatusFlag); },
+                                                       Render.displayItemStatus & ~showDisplayStatusFlag); },
-    function() { return (Render.doEngineDisplayItemStatus() & showDisplayStatusFlag) > 0; },
+    function() { return (Render.displayItemStatus & showDisplayStatusFlag) > 0; },
     function(value) { return (value & showDisplayStatusFlag) > 0; }
 );
 
 panel.newCheckbox("Network/Physics status",
-    function(value) { Render.setEngineDisplayItemStatus(value ?
+    function(value) { Render.displayItemStatus = (value ?
-                                                       Render.doEngineDisplayItemStatus() | showNetworkStatusFlag :
+                                                       Render.displayItemStatus | showNetworkStatusFlag :
-                                                       Render.doEngineDisplayItemStatus() & ~showNetworkStatusFlag); },
+                                                       Render.displayItemStatus & ~showNetworkStatusFlag); },
-    function() { return (Render.doEngineDisplayItemStatus() & showNetworkStatusFlag) > 0; },
+    function() { return (Render.displayItemStatus & showNetworkStatusFlag) > 0; },
     function(value) { return (value & showNetworkStatusFlag) > 0; }
 );
 
 panel.newSlider("Tone Mapping Exposure", -10, 10,
-    function (value) { Render.setEngineToneMappingExposure(value); },
+    function (value) { Render.tone.exposure = value; },
-    function() { return Render.getEngineToneMappingExposure(); },
+    function() { return Render.tone.exposure; },
     function (value) { return (value); });
 
 var tickTackPeriod = 500;
@@ -160,9 +162,9 @@ Menu.menuItemEvent.connect(menuItemEvent);
 function scriptEnding() {
     panel.destroy();
     Menu.removeActionGroup(MENU);
-    Settings.setValue(SETTINGS_KEY, Render.getEngineDeferredDebugMode());
+    Settings.setValue(SETTINGS_KEY, Render.deferredDebugMode);
-    Render.setEngineDeferredDebugMode(-1);
+    Render.deferredDebugMode = -1;
-    Render.setEngineDeferredDebugSize({ x: 0.0, y: -1.0, z: 1.0, w: 1.0 }); // Reset to default size
+    Render.deferredDebugSize = { x: 0.0, y: -1.0, z: 1.0, w: 1.0 }; // Reset to default size
 }
 Script.scriptEnding.connect(scriptEnding);
 

interface/src/Application.cpp

@@ -3721,21 +3721,18 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
     {
         PerformanceTimer perfTimer("EngineRun");
 
+        auto renderInterface = DependencyManager::get<RenderScriptingInterface>();
+        auto renderContext = renderInterface->getRenderContext();
+
         renderArgs->_shouldRender = LODManager::shouldRender;
         renderArgs->_viewFrustum = getDisplayViewFrustum();
-
+        renderContext.setArgs(renderArgs);
-        auto renderInterface = DependencyManager::get<RenderScriptingInterface>();
-        auto renderItemsConfig = renderInterface->getItemsConfig();
-        auto renderTone = renderInterface->getTone();
-        int drawStatus = renderInterface->getDrawStatus();
-        bool drawHitEffect = renderInterface->getDrawHitEffect();
 
         bool occlusionStatus = Menu::getInstance()->isOptionChecked(MenuOption::DebugAmbientOcclusion);
         bool antialiasingStatus = Menu::getInstance()->isOptionChecked(MenuOption::Antialiasing);
         bool showOwnedStatus = Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowOwned);
+        renderContext.setOptions(occlusionStatus, antialiasingStatus, showOwnedStatus);
 
-        render::RenderContext renderContext{renderArgs, renderItemsConfig, renderTone};
-        renderContext.setOptions(drawStatus, drawHitEffect, occlusionStatus, antialiasingStatus, showOwnedStatus);
         _renderEngine->setRenderContext(renderContext);
 
         // Before the deferred pass, let's try to use the render engine

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -256,33 +256,38 @@ void EntityTreeRenderer::forceRecheckEntities() {
 
 void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityItem> zone) {
     QSharedPointer<SceneScriptingInterface> scene = DependencyManager::get<SceneScriptingInterface>();
+    auto sceneStage = scene->getStage();
+    auto sceneKeyLight = sceneStage->getKeyLight();
+    auto sceneLocation = sceneStage->getLocation();
+    auto sceneTime = sceneStage->getTime();
+
     if (zone) {
         if (!_hasPreviousZone) {
-            _previousKeyLightColor = scene->getKeyLightColor();
+            _previousKeyLightColor = sceneKeyLight->getColor();
-            _previousKeyLightIntensity = scene->getKeyLightIntensity();
+            _previousKeyLightIntensity = sceneKeyLight->getIntensity();
-            _previousKeyLightAmbientIntensity = scene->getKeyLightAmbientIntensity();
+            _previousKeyLightAmbientIntensity = sceneKeyLight->getAmbientIntensity();
-            _previousKeyLightDirection = scene->getKeyLightDirection();
+            _previousKeyLightDirection = sceneKeyLight->getDirection();
-            _previousStageSunModelEnabled = scene->isStageSunModelEnabled();
+            _previousStageSunModelEnabled = sceneStage->isSunModelEnabled();
-            _previousStageLongitude = scene->getStageLocationLongitude();
+            _previousStageLongitude = sceneLocation->getLongitude();
-            _previousStageLatitude = scene->getStageLocationLatitude();
+            _previousStageLatitude = sceneLocation->getLatitude();
-            _previousStageAltitude = scene->getStageLocationAltitude();
+            _previousStageAltitude = sceneLocation->getAltitude();
-            _previousStageHour = scene->getStageDayTime();
+            _previousStageHour = sceneTime->getHour();
-            _previousStageDay = scene->getStageYearTime();
+            _previousStageDay = sceneTime->getDay();
             _hasPreviousZone = true;
         }
-        scene->setKeyLightColor(ColorUtils::toVec3(zone->getKeyLightProperties().getColor()));
+        sceneKeyLight->setColor(ColorUtils::toVec3(zone->getKeyLightProperties().getColor()));
-        scene->setKeyLightIntensity(zone->getKeyLightProperties().getIntensity());
+        sceneKeyLight->setIntensity(zone->getKeyLightProperties().getIntensity());
-        scene->setKeyLightAmbientIntensity(zone->getKeyLightProperties().getAmbientIntensity());
+        sceneKeyLight->setAmbientIntensity(zone->getKeyLightProperties().getAmbientIntensity());
-        scene->setKeyLightDirection(zone->getKeyLightProperties().getDirection());
+        sceneKeyLight->setDirection(zone->getKeyLightProperties().getDirection());
-        scene->setStageSunModelEnable(zone->getStageProperties().getSunModelEnabled());
+        sceneStage->setSunModelEnable(zone->getStageProperties().getSunModelEnabled());
-        scene->setStageLocation(zone->getStageProperties().getLongitude(), zone->getStageProperties().getLatitude(),
+        sceneStage->setLocation(zone->getStageProperties().getLongitude(), zone->getStageProperties().getLatitude(),
                                 zone->getStageProperties().getAltitude());
-        scene->setStageDayTime(zone->getStageProperties().calculateHour());
+        sceneTime->setHour(zone->getStageProperties().calculateHour());
-        scene->setStageYearTime(zone->getStageProperties().calculateDay());
+        sceneTime->setDay(zone->getStageProperties().calculateDay());
         
         if (zone->getBackgroundMode() == BACKGROUND_MODE_ATMOSPHERE) {
             EnvironmentData data = zone->getEnvironmentData();
-            glm::vec3 keyLightDirection = scene->getKeyLightDirection();
+            glm::vec3 keyLightDirection = sceneKeyLight->getDirection();
             glm::vec3 inverseKeyLightDirection = keyLightDirection * -1.0f;
             
             // NOTE: is this right? It seems like the "sun" should be based on the center of the
@@ -293,7 +298,7 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
             data.setSunLocation(keyLightLocation);
             
             const float KEY_LIGHT_INTENSITY_TO_SUN_BRIGHTNESS_RATIO = 20.0f;
-            float sunBrightness = scene->getKeyLightIntensity() * KEY_LIGHT_INTENSITY_TO_SUN_BRIGHTNESS_RATIO;
+            float sunBrightness = sceneKeyLight->getIntensity() * KEY_LIGHT_INTENSITY_TO_SUN_BRIGHTNESS_RATIO;
             data.setSunBrightness(sunBrightness);
             
             _viewState->overrideEnvironmentData(data);
@@ -339,15 +344,15 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
     } else {
         _pendingSkyboxTextureDownload = false;
         if (_hasPreviousZone) {
-            scene->setKeyLightColor(_previousKeyLightColor);
+            sceneKeyLight->setColor(_previousKeyLightColor);
-            scene->setKeyLightIntensity(_previousKeyLightIntensity);
+            sceneKeyLight->setIntensity(_previousKeyLightIntensity);
-            scene->setKeyLightAmbientIntensity(_previousKeyLightAmbientIntensity);
+            sceneKeyLight->setAmbientIntensity(_previousKeyLightAmbientIntensity);
-            scene->setKeyLightDirection(_previousKeyLightDirection);
+            sceneKeyLight->setDirection(_previousKeyLightDirection);
-            scene->setStageSunModelEnable(_previousStageSunModelEnabled);
+            sceneStage->setSunModelEnable(_previousStageSunModelEnabled);
-            scene->setStageLocation(_previousStageLongitude, _previousStageLatitude,
+            sceneStage->setLocation(_previousStageLongitude, _previousStageLatitude,
                                     _previousStageAltitude);
-            scene->setStageDayTime(_previousStageHour);
+            sceneTime->setHour(_previousStageHour);
-            scene->setStageYearTime(_previousStageDay);
+            sceneTime->setDay(_previousStageDay);
             _hasPreviousZone = false;
         }
         _viewState->endOverrideEnvironmentData();

libraries/model/src/model/Stage.cpp

@@ -225,6 +225,21 @@ void SunSkyStage::setOriginOrientation(const Quat& orientation) {
     invalidate();
 }
 
+void SunSkyStage::setOriginLongitude(float longitude) {
+    _earthSunModel.setLongitude(longitude);
+    invalidate();
+}
+
+void SunSkyStage::setOriginLatitude(float latitude) {
+    _earthSunModel.setLatitude(latitude);
+    invalidate();
+}
+
+void SunSkyStage::setOriginSurfaceAltitude(float altitude) {
+    _earthSunModel.setAltitude(altitude);
+    invalidate();
+}
+
 void SunSkyStage::setOriginLocation(float longitude, float latitude, float altitude) {
     _earthSunModel.setLongitude(longitude);
     _earthSunModel.setLatitude(latitude);

libraries/model/src/model/Stage.h

@@ -184,6 +184,9 @@ public:
     const Quat& getOriginOrientation() const { return _earthSunModel.getSurfaceOrientation(); }
 
     // Location  used to define the sun & sky is a longitude and latitude [rad] and a earth surface altitude [km]
+    void setOriginLatitude(float latitude);
+    void setOriginLongitude(float longitude);
+    void setOriginSurfaceAltitude(float surfaceAltitude);
     void setOriginLocation(float longitude, float latitude, float surfaceAltitude);
     float getOriginLatitude() const { return _earthSunModel.getLatitude(); }
     float getOriginLongitude() const { return _earthSunModel.getLongitude(); }

libraries/render-utils/src/RenderScriptingInterface.cpp

@@ -13,20 +13,20 @@
 
 RenderScriptingInterface::RenderScriptingInterface() {};
 
-void RenderScriptingInterface::setEngineToneMappingToneCurve(const QString& toneCurve) {
+void RenderScripting::Tone::setCurve(const QString& curve) {
-    if (toneCurve == QString("None")) {
+    if (curve == QString("None")) {
-        _tone.toneCurve = 0;
+        toneCurve = 0;
-    } else if (toneCurve == QString("Gamma22")) {
+    } else if (curve == QString("Gamma22")) {
-        _tone.toneCurve = 1;
+        toneCurve = 1;
-    } else if (toneCurve == QString("Reinhard")) {
+    } else if (curve == QString("Reinhard")) {
-        _tone.toneCurve = 2;
+        toneCurve = 2;
-    } else if (toneCurve == QString("Filmic")) {
+    } else if (curve == QString("Filmic")) {
-        _tone.toneCurve = 3;
+        toneCurve = 3;
     }
 }
 
-QString RenderScriptingInterface::getEngineToneMappingToneCurve() const {
+QString RenderScripting::Tone::getCurve() const {
-    switch (_tone.toneCurve) {
+    switch (toneCurve) {
     case 0:
         return QString("None");
     case 1:
@@ -38,4 +38,15 @@ QString RenderScriptingInterface::getEngineToneMappingToneCurve() const {
     default:
         return QString("Filmic");
     };
+}
+
+render::RenderContext RenderScriptingInterface::getRenderContext() {
+    render::RenderContext::ItemsConfig items{ *_opaque, *_transparent, *_overlay3D };
+    return render::RenderContext{ items, *_tone, _drawStatus, _drawHitEffect, _deferredDebugSize, _deferredDebugMode };
+}
+
+void RenderScriptingInterface::setItemCounts(const render::RenderContext::ItemsConfig& items) {
+    _opaque->setCounts(items.opaque);
+    _transparent->setCounts(items.transparent);
+    _overlay3D->setCounts(items.overlay3D);
 }

libraries/render-utils/src/RenderScriptingInterface.h

@@ -17,71 +17,91 @@
 
 #include "render/Engine.h"
 
+namespace RenderScripting {
+    using State = render::RenderContext::ItemsConfig::State;
+    using Counter = render::RenderContext::ItemsConfig::Counter;
+        
+    class ItemCounter : public QObject, public Counter {
+        Q_OBJECT
+
+    public:
+        Q_PROPERTY(int numFeed READ getNumFeed)
+        Q_PROPERTY(int numDrawn READ getNumDrawn)
+        Q_PROPERTY(int maxDrawn MEMBER maxDrawn)
+
+    protected:
+        int getNumFeed() const { return numFeed; }
+        int getNumDrawn() const { return numDrawn; }
+    };
+    using ItemCounterPointer = std::unique_ptr<ItemCounter>;
+
+    class ItemState : public QObject, public State {
+        Q_OBJECT
+
+    public:
+        Q_PROPERTY(bool render MEMBER render)
+        Q_PROPERTY(bool cull MEMBER cull)
+        Q_PROPERTY(bool sort MEMBER sort)
+
+        Q_PROPERTY(int numFeed READ getNumFeed)
+        Q_PROPERTY(int numDrawn READ getNumDrawn)
+        Q_PROPERTY(int maxDrawn MEMBER maxDrawn)
+
+    protected:
+        int getNumFeed() const { return numFeed; }
+        int getNumDrawn() const { return numDrawn; }
+    };
+    using ItemStatePointer = std::unique_ptr<ItemState>;
+
+    class Tone : public QObject, public render::RenderContext::Tone {
+        Q_OBJECT
+
+    public:
+        Q_PROPERTY(float exposure MEMBER exposure)
+        Q_PROPERTY(QString curve READ getCurve WRITE setCurve)
+
+        QString getCurve() const;
+        int getCurveValue() const { return toneCurve; }
+        void setCurve(const QString& curve);
+    };
+    using TonePointer = std::unique_ptr<Tone>;
+};
+
 class RenderScriptingInterface : public QObject, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
     
  public:
-     Q_INVOKABLE void setEngineRenderOpaque(bool renderOpaque) { _items.opaque.render = renderOpaque; };
+    Q_PROPERTY(RenderScripting::ItemState* opaque READ getOpaque)
-    Q_INVOKABLE bool doEngineRenderOpaque() const { return _items.opaque.render; }
+    Q_PROPERTY(RenderScripting::ItemState* transparent READ getTransparent)
-    Q_INVOKABLE void setEngineRenderTransparent(bool renderTransparent) { _items.transparent.render = renderTransparent; };
+    Q_PROPERTY(RenderScripting::ItemCounter* overlay3D READ getOverlay3D)
-    Q_INVOKABLE bool doEngineRenderTransparent() const { return _items.transparent.render; }
-    
-    Q_INVOKABLE void setEngineCullOpaque(bool cullOpaque) { _items.opaque.cull = cullOpaque; };
-    Q_INVOKABLE bool doEngineCullOpaque() const { return _items.opaque.cull; }
-    Q_INVOKABLE void setEngineCullTransparent(bool cullTransparent) { _items.transparent.cull = cullTransparent; };
-    Q_INVOKABLE bool doEngineCullTransparent() const { return _items.transparent.cull; }
 
-    Q_INVOKABLE void setEngineSortOpaque(bool sortOpaque) { _items.opaque.sort = sortOpaque; };
+    Q_PROPERTY(RenderScripting::Tone* tone READ getTone)
-    Q_INVOKABLE bool doEngineSortOpaque() const { return _items.opaque.sort; }
-    Q_INVOKABLE void setEngineSortTransparent(bool sortTransparent) { _items.transparent.sort = sortTransparent; };
-    Q_INVOKABLE bool doEngineSortTransparent() const { return _items.transparent.sort; }
 
-    Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _items.opaque.numDrawn; }
+    Q_PROPERTY(int displayItemStatus MEMBER _drawStatus)
-    Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _items.transparent.numDrawn; }
+    Q_PROPERTY(bool displayHitEffect MEMBER _drawHitEffect)
-    Q_INVOKABLE int getEngineNumDrawnOverlay3DItems() { return _items.overlay3D.numDrawn; }
 
-    Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _items.opaque.numFeed; }
+    Q_PROPERTY(int deferredDebugMode MEMBER _deferredDebugMode)
-    Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _items.transparent.numFeed; }
+    Q_PROPERTY(glm::vec4 deferredDebugSize MEMBER _deferredDebugSize)
-    Q_INVOKABLE int getEngineNumFeedOverlay3DItems() { return _items.overlay3D.numFeed; }
 
-    Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _items.opaque.maxDrawn = count; }
+    render::RenderContext getRenderContext();
-    Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _items.opaque.maxDrawn; }
+    void setItemCounts(const render::RenderContext::ItemsConfig& items);
-    Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _items.transparent.maxDrawn = count; }
-    Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _items.transparent.maxDrawn; }
-    Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _items.overlay3D.maxDrawn = count; }
-    Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _items.overlay3D.maxDrawn; }
-    
-    Q_INVOKABLE void setEngineDeferredDebugMode(int mode) { _deferredDebugMode = mode; }
-    Q_INVOKABLE int getEngineDeferredDebugMode() { return _deferredDebugMode; }
-    Q_INVOKABLE void setEngineDeferredDebugSize(glm::vec4 size) { _deferredDebugSize = size; }
-    Q_INVOKABLE glm::vec4 getEngineDeferredDebugSize() { return _deferredDebugSize; }
-    
-    Q_INVOKABLE void setEngineDisplayItemStatus(int display) { _drawStatus = display; }
-    Q_INVOKABLE int doEngineDisplayItemStatus() { return _drawStatus; }
-
-    Q_INVOKABLE void setEngineDisplayHitEffect(bool display) { _drawHitEffect = display; }
-    Q_INVOKABLE bool doEngineDisplayHitEffect() { return _drawHitEffect; }
-
-    Q_INVOKABLE void setEngineToneMappingExposure(float exposure) { _tone.exposure = exposure; }
-    Q_INVOKABLE float getEngineToneMappingExposure() const { return _tone.exposure; }
-
-    Q_INVOKABLE void setEngineToneMappingToneCurve(const QString& curve);
-    Q_INVOKABLE QString getEngineToneMappingToneCurve() const;
-    int getEngineToneMappingToneCurveValue() const { return _tone.toneCurve; }
-
-    inline int getDrawStatus() { return _drawStatus; }
-    inline bool getDrawHitEffect() { return _drawHitEffect; }
-    inline const render::RenderContext::ItemsConfig& getItemsConfig() { return _items; }
-    inline const render::RenderContext::Tone& getTone() { return _tone;  }
-    void setItemCounts(const render::RenderContext::ItemsConfig& items) { _items.setCounts(items); };
 
 protected:
     RenderScriptingInterface();
     ~RenderScriptingInterface() {};
 
-    render::RenderContext::ItemsConfig _items;
+    RenderScripting::ItemState* getOpaque() const { return _opaque.get(); }
-    render::RenderContext::Tone _tone;
+    RenderScripting::ItemState* getTransparent() const { return _transparent.get(); }
+    RenderScripting::ItemCounter* getOverlay3D() const { return _overlay3D.get(); }
+
+    RenderScripting::Tone* getTone() const { return _tone.get(); }
+
+    RenderScripting::ItemStatePointer _opaque = RenderScripting::ItemStatePointer{new RenderScripting::ItemState{}};
+    RenderScripting::ItemStatePointer _transparent = RenderScripting::ItemStatePointer{new RenderScripting::ItemState{}};
+    RenderScripting::ItemCounterPointer _overlay3D = RenderScripting::ItemCounterPointer{new RenderScripting::ItemCounter{}};
+
+    RenderScripting::TonePointer _tone = RenderScripting::TonePointer{ new RenderScripting::Tone{} };
 
     // Options
     int _drawStatus = 0;

libraries/render/src/render/Engine.cpp

@@ -13,11 +13,14 @@
 #include "DrawTask.h"
 using namespace render;
 
-void RenderContext::setOptions(int drawStatus, bool drawHitEffect, bool occlusion, bool fxaa, bool showOwned) {
+RenderContext::RenderContext(ItemsConfig items, Tone tone, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode)
-    _drawStatus = drawStatus;
+        : _args{ nullptr }, _items{ items }, _tone{ tone },
+        _drawStatus{ drawStatus }, _drawHitEffect{ drawHitEffect },
+        _deferredDebugSize{ deferredDebugSize }, _deferredDebugMode{ deferredDebugMode } {};
+
+void RenderContext::setOptions(bool occlusion, bool fxaa, bool showOwned) {
     _occlusionStatus = occlusion;
     _fxaaStatus = fxaa;
-    _drawHitEffect = drawHitEffect;
 
     if (showOwned) {
         _drawStatus |= render::showNetworkStatusFlag;

libraries/render/src/render/Engine.h

@@ -34,12 +34,6 @@ class RenderContext {
 public:
     class ItemsConfig {
     public:
-        inline void setCounts(const ItemsConfig& items) {
-            opaque.setCounts(items.opaque);
-            transparent.setCounts(items.transparent);
-            overlay3D.setCounts(items.overlay3D);
-        };
-
         class Counter {
         public:
             Counter() {};
@@ -48,7 +42,7 @@ public:
                 maxDrawn = counter.maxDrawn;
             };
 
-            inline void setCounts(const Counter& counter) {
+            void setCounts(const Counter& counter) {
                 numFeed = counter.numFeed;
                 numDrawn = counter.numDrawn;
             };
@@ -67,6 +61,10 @@ public:
             Counter counter{};
         };
 
+        ItemsConfig(State opaqueState, State transparentState, Counter overlay3DCounter)
+            : opaque{ opaqueState }, transparent{ transparentState }, overlay3D{ overlay3DCounter } {}
+        ItemsConfig() : ItemsConfig{ {}, {}, {} } {}
+
         // TODO: If member count increases, store counters in a map instead of multiple members
         State opaque{};
         State transparent{};
@@ -79,9 +77,10 @@ public:
         float exposure = 0.0;
     };
     
-    RenderContext(RenderArgs* args, ItemsConfig items, Tone tone) : _args{args}, _items{items}, _tone{tone} {};
+    RenderContext(ItemsConfig items, Tone tone, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode);
-    RenderContext() : RenderContext(nullptr, {}, {}) {};
+    RenderContext() : RenderContext({}, {}, {}, {}, {}, {}) {};
 
+    void setArgs(RenderArgs* args) { _args = args; }
     inline RenderArgs* getArgs() { return _args; }
     inline ItemsConfig& getItemsConfig() { return _items; }
     inline Tone& getTone() { return _tone; }
@@ -89,7 +88,7 @@ public:
     inline bool getDrawHitEffect() { return _drawHitEffect; }
     inline bool getOcclusionStatus() { return _occlusionStatus; }
     inline bool getFxaaStatus() { return _fxaaStatus; }
-    void setOptions(int drawStatus, bool drawHitEffect, bool occlusion, bool fxaa, bool showOwned);
+    void setOptions(bool occlusion, bool fxaa, bool showOwned);
 
     // Debugging
     int _deferredDebugMode = -1;

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -13,7 +13,118 @@
 
 #include <procedural/ProceduralSkybox.h>
 
-SceneScriptingInterface::SceneScriptingInterface() {
+float SceneScripting::Location::getLongitude() const {
+    return _skyStage->getOriginLongitude();
+}
+
+float SceneScripting::Location::getLatitude() const {
+    return _skyStage->getOriginLatitude();
+}
+
+float SceneScripting::Location::getAltitude() const {
+    return _skyStage->getOriginSurfaceAltitude();
+}
+
+void SceneScripting::Location::setLongitude(float longitude) {
+    _skyStage->setOriginLongitude(longitude);
+}
+
+void SceneScripting::Location::setLatitude(float latitude) {
+    _skyStage->setOriginLatitude(latitude);
+}
+
+void SceneScripting::Location::setAltitude(float altitude) {
+    _skyStage->setOriginSurfaceAltitude(altitude);
+}
+
+void SceneScripting::Time::setHour(float hour) {
+    _skyStage->setDayTime(hour);
+}
+
+float SceneScripting::Time::getHour() const {
+    return _skyStage->getDayTime();
+}
+
+void SceneScripting::Time::setDay(int day) {
+    _skyStage->setYearTime(day);
+}
+
+int SceneScripting::Time::getDay() const {
+    return _skyStage->getYearTime();
+}
+
+glm::vec3 SceneScripting::KeyLight::getColor() const {
+    return _skyStage->getSunColor();
+}
+
+void SceneScripting::KeyLight::setColor(const glm::vec3& color) {
+    _skyStage->setSunColor(color);
+}
+
+float SceneScripting::KeyLight::getIntensity() const {
+    return _skyStage->getSunIntensity();
+}
+
+void SceneScripting::KeyLight::setIntensity(float intensity) {
+    _skyStage->setSunIntensity(intensity);
+}
+
+float SceneScripting::KeyLight::getAmbientIntensity() const {
+    return _skyStage->getSunAmbientIntensity();
+}
+
+void SceneScripting::KeyLight::setAmbientIntensity(float intensity) {
+    _skyStage->setSunAmbientIntensity(intensity);
+}
+
+glm::vec3 SceneScripting::KeyLight::getDirection() const {
+    return _skyStage->getSunDirection();
+}
+
+void SceneScripting::KeyLight::setDirection(const glm::vec3& direction) {
+    _skyStage->setSunDirection(direction);
+}
+
+void SceneScripting::Stage::setOrientation(const glm::quat& orientation) const {
+    _skyStage->setOriginOrientation(orientation);
+}
+
+void SceneScripting::Stage::setLocation(float longitude, float latitude, float altitude) {
+    _skyStage->setOriginLocation(longitude, latitude, altitude);
+}
+
+void SceneScripting::Stage::setSunModelEnable(bool isEnabled) {
+    _skyStage->setSunModelEnable(isEnabled);
+}
+
+bool SceneScripting::Stage::isSunModelEnabled() const {
+    return _skyStage->isSunModelEnabled();
+}
+
+void SceneScripting::Stage::setBackgroundMode(const QString& mode) {
+    if (mode == QString("inherit")) {
+        _skyStage->setBackgroundMode(model::SunSkyStage::NO_BACKGROUND);
+    } else if (mode == QString("atmosphere")) {
+        _skyStage->setBackgroundMode(model::SunSkyStage::SKY_DOME);
+    } else if (mode == QString("skybox")) {
+        _skyStage->setBackgroundMode(model::SunSkyStage::SKY_BOX);
+    }
+}
+
+QString SceneScripting::Stage::getBackgroundMode() const {
+    switch (_skyStage->getBackgroundMode()) {
+    case model::SunSkyStage::NO_BACKGROUND:
+        return QString("inherit");
+    case model::SunSkyStage::SKY_DOME:
+        return QString("atmosphere");
+    case model::SunSkyStage::SKY_BOX:
+        return QString("skybox");
+    default:
+        return QString("inherit");
+    };
+}
+
+SceneScriptingInterface::SceneScriptingInterface() : _stage{ new SceneScripting::Stage{ _skyStage } } {
     // Let's make sure the sunSkyStage is using a proceduralSkybox
     _skyStage->setSkybox(model::SkyboxPointer(new ProceduralSkybox()));
 }
@@ -32,102 +143,6 @@ void SceneScriptingInterface::setShouldRenderEntities(bool shouldRenderEntities)
     }
 }
 
-void SceneScriptingInterface::setStageOrientation(const glm::quat& orientation) {
-    _skyStage->setOriginOrientation(orientation);
-}
-void SceneScriptingInterface::setStageLocation(float longitude, float latitude, float altitude) {
-    _skyStage->setOriginLocation(longitude, latitude, altitude);
-}
-
-float SceneScriptingInterface::getStageLocationLongitude() const {
-    return _skyStage->getOriginLongitude();
-}
-float SceneScriptingInterface::getStageLocationLatitude() const {
-    return _skyStage->getOriginLatitude();
-}
-float SceneScriptingInterface::getStageLocationAltitude() const {
-    return _skyStage->getOriginSurfaceAltitude();
-}
-
-void SceneScriptingInterface::setStageDayTime(float hour) {
-    _skyStage->setDayTime(hour);
-}
-
-float SceneScriptingInterface::getStageDayTime() const {
-    return _skyStage->getDayTime();
-}
-
-void SceneScriptingInterface::setStageYearTime(int day) {
-    _skyStage->setYearTime(day);
-}
-
-int SceneScriptingInterface::getStageYearTime() const {
-    return _skyStage->getYearTime();
-}
-
-void SceneScriptingInterface::setKeyLightColor(const glm::vec3& color) {
-    _skyStage->setSunColor(color);
-}
-
-glm::vec3 SceneScriptingInterface::getKeyLightColor() const {
-    return _skyStage->getSunColor();
-}
-
-void SceneScriptingInterface::setKeyLightIntensity(float intensity) {
-    _skyStage->setSunIntensity(intensity);
-}
-
-float SceneScriptingInterface::getKeyLightIntensity() const {
-    return _skyStage->getSunIntensity();
-}
-
-void SceneScriptingInterface::setKeyLightAmbientIntensity(float intensity) {
-    _skyStage->setSunAmbientIntensity(intensity);
-}
-
-float SceneScriptingInterface::getKeyLightAmbientIntensity() const {
-    return _skyStage->getSunAmbientIntensity();
-}
-
-void SceneScriptingInterface::setKeyLightDirection(const glm::vec3& direction) {
-    _skyStage->setSunDirection(direction);
-}
-
-glm::vec3 SceneScriptingInterface::getKeyLightDirection() const {
-    return _skyStage->getSunDirection();
-}
-
-void SceneScriptingInterface::setStageSunModelEnable(bool isEnabled) {
-    _skyStage->setSunModelEnable(isEnabled);
-}
-
-bool SceneScriptingInterface::isStageSunModelEnabled() const {
-    return _skyStage->isSunModelEnabled();
-}
-
-void SceneScriptingInterface::setBackgroundMode(const QString& mode) {
-    if (mode == QString("inherit")) {
-        _skyStage->setBackgroundMode(model::SunSkyStage::NO_BACKGROUND);
-    } else if (mode == QString("atmosphere")) {
-        _skyStage->setBackgroundMode(model::SunSkyStage::SKY_DOME);
-    } else if (mode == QString("skybox")) {
-        _skyStage->setBackgroundMode(model::SunSkyStage::SKY_BOX);
-    }
-}
-
-QString SceneScriptingInterface::getBackgroundMode() const {
-    switch (_skyStage->getBackgroundMode()) {
-    case model::SunSkyStage::NO_BACKGROUND:
-        return QString("inherit");
-    case model::SunSkyStage::SKY_DOME:
-        return QString("atmosphere");
-    case model::SunSkyStage::SKY_BOX:
-        return QString("skybox");
-    default:
-        return QString("inherit");
-    };
-}
-
 model::SunSkyStagePointer SceneScriptingInterface::getSkyStage() const {
     return _skyStage;
 }

libraries/script-engine/src/SceneScriptingInterface.h

@@ -17,6 +17,114 @@
 
 #include "model/Stage.h"
 
+// TODO: if QT moc ever supports nested classes, subclass these to the interface instead of namespacing
+namespace SceneScripting {
+    class Location : public QObject {
+        Q_OBJECT
+
+    public:
+        Location(model::SunSkyStagePointer skyStage) : _skyStage{ skyStage } {}
+
+        Q_PROPERTY(float longitude READ getLongitude WRITE setLongitude)
+        Q_PROPERTY(float latitude READ getLatitude WRITE setLatitude)
+        Q_PROPERTY(float altitude READ getAltitude WRITE setAltitude)
+
+        float getLongitude() const;
+        float getLatitude() const;
+        float getAltitude() const;
+        void setLongitude(float longitude);
+        void setLatitude(float latitude);
+        void setAltitude(float altitude);
+
+    protected:
+        model::SunSkyStagePointer _skyStage;
+    };
+    using LocationPointer = std::unique_ptr<Location>;
+    
+    class Time : public QObject {
+        Q_OBJECT
+
+    public:
+        Time(model::SunSkyStagePointer skyStage) : _skyStage{ skyStage } {}
+
+        Q_PROPERTY(float hour READ getHour WRITE setHour)
+        Q_PROPERTY(int day READ getDay WRITE setDay)
+
+        float getHour() const;
+        void setHour(float hour);
+        int getDay() const;
+        void setDay(int day);
+
+    protected:
+        model::SunSkyStagePointer _skyStage;
+    };
+    using TimePointer = std::unique_ptr<Time>;
+
+    class KeyLight : public QObject {
+        Q_OBJECT
+
+    public:
+        KeyLight(model::SunSkyStagePointer skyStage) : _skyStage{ skyStage } {}
+
+        Q_PROPERTY(glm::vec3 color READ getColor WRITE setColor)
+        Q_PROPERTY(float intensity READ getIntensity WRITE setIntensity)
+        Q_PROPERTY(float ambientIntensity READ getAmbientIntensity WRITE setAmbientIntensity)
+        Q_PROPERTY(glm::vec3 direction READ getDirection WRITE setDirection)
+
+        glm::vec3 getColor() const;
+        void setColor(const glm::vec3& color);
+        float getIntensity() const;
+        void setIntensity(float intensity);
+        float getAmbientIntensity() const;
+        void setAmbientIntensity(float intensity);
+        glm::vec3 getDirection() const;
+        // setDirection is only effective if stage Sun model is disabled
+        void setDirection(const glm::vec3& direction);
+
+    protected:
+        model::SunSkyStagePointer _skyStage;
+    };
+    using KeyLightPointer = std::unique_ptr<KeyLight>;
+    
+    class Stage : public QObject {
+        Q_OBJECT
+
+    public:
+        Stage(model::SunSkyStagePointer skyStage)
+            : _skyStage{ skyStage },
+            _location{ new Location{ skyStage } }, _time{ new Time{ skyStage } }, _keyLight{ new KeyLight{ skyStage } }{}
+
+        Q_INVOKABLE void setOrientation(const glm::quat& orientation) const;
+
+        Q_PROPERTY(Location* location READ getLocation)
+        Location* getLocation() const { return _location.get(); }
+        Q_INVOKABLE void setLocation(float longitude, float latitude, float altitude);
+
+        Q_PROPERTY(Time* time READ getTime)
+        Time* getTime() const { return _time.get(); }
+
+        Q_PROPERTY(KeyLight* keyLight READ getKeyLight)
+        KeyLight* getKeyLight() const { return _keyLight.get(); }
+
+        // Enable/disable the stage sun model which uses the key light to simulate
+        // the sun light based on the location of the stage relative to earth and the current time 
+        Q_PROPERTY(bool sunModel READ isSunModelEnabled WRITE setSunModelEnable)
+        void setSunModelEnable(bool isEnabled);
+        bool isSunModelEnabled() const;
+
+        Q_PROPERTY(QString backgroundMode READ getBackgroundMode WRITE setBackgroundMode)
+        void setBackgroundMode(const QString& mode);
+        QString getBackgroundMode() const;
+
+    protected:
+        model::SunSkyStagePointer _skyStage;
+        LocationPointer _location;
+        TimePointer _time;
+        KeyLightPointer _keyLight;
+    };
+    using StagePointer = std::unique_ptr<Stage>;
+};
+
 class SceneScriptingInterface : public QObject, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
@@ -24,46 +132,14 @@ class SceneScriptingInterface : public QObject, public Dependency {
 public:
     Q_PROPERTY(bool shouldRenderAvatars READ shouldRenderAvatars WRITE setShouldRenderAvatars)
     Q_PROPERTY(bool shouldRenderEntities READ shouldRenderEntities WRITE setShouldRenderEntities)
+    bool shouldRenderAvatars() const { return _shouldRenderAvatars; }
+    bool shouldRenderEntities() const { return _shouldRenderEntities; }
+    void setShouldRenderAvatars(bool shouldRenderAvatars);
+    void setShouldRenderEntities(bool shouldRenderEntities);
 
-    Q_INVOKABLE void setShouldRenderAvatars(bool shouldRenderAvatars);
+    Q_PROPERTY(SceneScripting::Stage* stage READ getStage)
-    Q_INVOKABLE bool shouldRenderAvatars() const { return _shouldRenderAvatars; }
+    SceneScripting::Stage* getStage() const { return _stage.get(); }
-    
+ 
-    Q_INVOKABLE void setShouldRenderEntities(bool shouldRenderEntities);
-    Q_INVOKABLE bool shouldRenderEntities() const { return _shouldRenderEntities; }
-
-    Q_INVOKABLE void setStageOrientation(const glm::quat& orientation);
-
-    Q_INVOKABLE void setStageLocation(float longitude, float latitude, float altitude);
-    Q_INVOKABLE float getStageLocationLongitude() const;
-    Q_INVOKABLE float getStageLocationLatitude() const;
-    Q_INVOKABLE float getStageLocationAltitude() const;
-
-    Q_INVOKABLE void setStageDayTime(float hour);
-    Q_INVOKABLE float getStageDayTime() const;
-    Q_INVOKABLE void setStageYearTime(int day);
-    Q_INVOKABLE int getStageYearTime() const;
-
-    // Enable/disable the stage sun model which uses the key light to simulate
-    // the sun light based on the location of the stage trelative to earth and the current time 
-    Q_INVOKABLE void setStageSunModelEnable(bool isEnabled);
-    Q_INVOKABLE bool isStageSunModelEnabled() const;
-
-    Q_INVOKABLE void setKeyLightColor(const glm::vec3& color);
-    Q_INVOKABLE glm::vec3 getKeyLightColor() const;
-    Q_INVOKABLE void setKeyLightIntensity(float intensity);
-    Q_INVOKABLE float getKeyLightIntensity() const;
-    Q_INVOKABLE void setKeyLightAmbientIntensity(float intensity);
-    Q_INVOKABLE float getKeyLightAmbientIntensity() const;
-
-    // setKeyLightDIrection is only effective if stage Sun model is disabled
-    Q_INVOKABLE void setKeyLightDirection(const glm::vec3& direction);
-
-    Q_INVOKABLE glm::vec3 getKeyLightDirection() const;
-
-
-    Q_INVOKABLE void setBackgroundMode(const QString& mode);
-    Q_INVOKABLE QString getBackgroundMode() const;
-
     model::SunSkyStagePointer getSkyStage() const;
 
 signals:
@@ -75,9 +151,10 @@ protected:
     ~SceneScriptingInterface() {};
 
     model::SunSkyStagePointer _skyStage = std::make_shared<model::SunSkyStage>();
+    SceneScripting::StagePointer _stage;
 
     bool _shouldRenderAvatars = true;
     bool _shouldRenderEntities = true;
 };
 
-#endif // hifi_SceneScriptingInterface_h
+#endif // hifi_SceneScriptingInterface_h