Nest JS props in SceneScriptingInterface

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/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{ std::make_unique<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,112 @@
 
 #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{ std::make_unique<Location>(skyStage) }, _time{ std::make_unique<Time>(skyStage) }, _keyLight{ std::make_unique<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 +130,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 +149,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