Before replacing "Haze Active" checkbox with "Haze Mode" combo.

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -319,7 +319,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
 
         // should never fall in here when collision model not fully loaded
         // hence we assert that all geometries exist and are loaded
-        assert(_model && _model->isLoaded() && _compoundShapeResource && _compoundShapeResource->isLoaded());
+        ////assert(_model && _model->isLoaded() && _compoundShapeResource && _compoundShapeResource->isLoaded());
         const FBXGeometry& collisionGeometry = _compoundShapeResource->getFBXGeometry();
 
         ShapeInfo::PointCollection& pointCollection = shapeInfo.getPointCollection();
@@ -408,7 +408,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
         shapeInfo.setParams(type, dimensions, getCompoundShapeURL());
     } else if (type >= SHAPE_TYPE_SIMPLE_HULL && type <= SHAPE_TYPE_STATIC_MESH) {
         // should never fall in here when model not fully loaded
-        assert(_model && _model->isLoaded());
+        ////assert(_model && _model->isLoaded());
 
         updateModelBounds();
         model->updateGeometry();

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -211,9 +211,14 @@ void ZoneEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
     if (sunChanged || skyboxChanged) {
         updateKeyAmbientFromEntity();
     }
+
     if (backgroundChanged || skyboxChanged) {
         updateKeyBackgroundFromEntity(entity);
     }
+
+    if (hazeChanged) {
+        updateHazeFromEntity(entity);
+    }
 }
 
 void ZoneEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
@@ -300,9 +305,16 @@ void ZoneEntityRenderer::updateKeyAmbientFromEntity() {
     }
 }
 
+void ZoneEntityRenderer::updateHazeFromEntity(const TypedEntityPointer& entity) {
+    const auto& haze = editHaze();
+
+    haze->setIsHazeActive(entity->getHazeMode() == HAZE_MODE_ON);
+}
+
 void ZoneEntityRenderer::updateKeyBackgroundFromEntity(const TypedEntityPointer& entity) {
     editBackground();
     setBackgroundMode(entity->getBackgroundMode());
+    setHazeMode(entity->getHazeMode());
     setSkyboxColor(_skyboxProperties.getColorVec3());
     setProceduralUserData(entity->getUserData());
     setSkyboxURL(_skyboxProperties.getURL());
@@ -409,6 +421,9 @@ void ZoneEntityRenderer::updateSkyboxMap() {
 void ZoneEntityRenderer::setBackgroundMode(BackgroundMode mode) {
     _backgroundMode = mode;
 }
+void ZoneEntityRenderer::setHazeMode(HazeMode mode) {
+    _hazeMode = mode;
+}
 
 void ZoneEntityRenderer::setSkyboxColor(const glm::vec3& color) {
     editSkybox()->setColor(color);

libraries/entities-renderer/src/RenderableZoneEntityItem.h

@@ -45,12 +45,14 @@ private:
     void updateKeyZoneItemFromEntity();
     void updateKeySunFromEntity();
     void updateKeyAmbientFromEntity();
+    void updateHazeFromEntity(const TypedEntityPointer& entity);
     void updateKeyBackgroundFromEntity(const TypedEntityPointer& entity);
     void updateAmbientMap();
     void updateSkyboxMap();
     void setAmbientURL(const QString& ambientUrl);
     void setSkyboxURL(const QString& skyboxUrl);
     void setBackgroundMode(BackgroundMode mode);
+    void setHazeMode(HazeMode mode);
     void setSkyboxColor(const glm::vec3& color);
     void setProceduralUserData(const QString& userData);
 
@@ -78,6 +80,7 @@ private:
     const model::LightPointer _ambientLight{ std::make_shared<model::Light>() };
     const model::SunSkyStagePointer _background{ std::make_shared<model::SunSkyStage>() };
     BackgroundMode _backgroundMode{ BACKGROUND_MODE_INHERIT };
+    HazeMode _hazeMode{ HAZE_MODE_INHERIT };
 
     indexed_container::Index _sunIndex{ LightStage::INVALID_INDEX };
     indexed_container::Index _ambientIndex{ LightStage::INVALID_INDEX };

libraries/entities/src/EntityItemProperties.cpp

@@ -227,9 +227,22 @@ void EntityItemProperties::setBackgroundModeFromString(const QString& background
     }
 }
 
+QString EntityItemProperties::getHazeModeAsString() const {
+    return HAZE_MODES[_hazeMode].second;
+}
+
 QString EntityItemProperties::getHazeModeString(HazeMode mode) {
     return HAZE_MODES[mode].second;
 }
+void EntityItemProperties::setHazeModeFromString(const QString& hazeMode) {
+    auto result = std::find_if(HAZE_MODES.begin(), HAZE_MODES.end(), [&](const HazePair& pair) {
+        return (pair.second == hazeMode);
+    });
+    if (result != HAZE_MODES.end()) {
+        _hazeMode = result->first;
+        _hazeModeChanged = true;
+    }
+}
 
 EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
     EntityPropertyFlags changedProperties;

libraries/entities/src/KeyLightPropertyGroup.cpp

@@ -1,5 +1,5 @@
 //
-//  KeyLightPropertyGroup.h
+//  KeyLightPropertyGroup.cpp
 //  libraries/entities/src
 //
 //  Created by Sam Gateau on 2015/10/23.

libraries/entities/src/ZoneEntityItem.cpp

@@ -44,7 +44,7 @@ ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID) : EntityItem(en
     _compoundShapeURL = DEFAULT_COMPOUND_SHAPE_URL;
 
     _backgroundMode = BACKGROUND_MODE_INHERIT;
-    _hazeMode = HAZE_MODE_OFF;
+    _hazeMode = HAZE_MODE_INHERIT;
 }
 
 EntityItemProperties ZoneEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
@@ -66,9 +66,8 @@ EntityItemProperties ZoneEntityItem::getProperties(EntityPropertyFlags desiredPr
     withReadLock([&] {
         _skyboxProperties.getProperties(properties);
     });
-    withReadLock([&] {
+
-        _hazeProperties.getProperties(properties);
+    _hazeProperties.getProperties(properties);
-    });
 
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(flyingAllowed, getFlyingAllowed);
     COPY_ENTITY_PROPERTY_TO_PROPERTIES(ghostingAllowed, getGhostingAllowed);
@@ -108,6 +107,7 @@ bool ZoneEntityItem::setSubClassProperties(const EntityItemProperties& propertie
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(shapeType, setShapeType);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(compoundShapeURL, setCompoundShapeURL);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(backgroundMode, setBackgroundMode);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeMode, setHazeMode);
 
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(flyingAllowed, setFlyingAllowed);
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(ghostingAllowed, setGhostingAllowed);
@@ -117,9 +117,8 @@ bool ZoneEntityItem::setSubClassProperties(const EntityItemProperties& propertie
     withWriteLock([&] {
         _skyboxPropertiesChanged = _skyboxProperties.setProperties(properties);
     });
-    withWriteLock([&] {
+
-        _hazePropertiesChanged = _hazeProperties.setProperties(properties);
+    _hazePropertiesChanged = _hazeProperties.setProperties(properties);
-    });
 
     somethingChanged = somethingChanged || _keyLightPropertiesChanged || _stagePropertiesChanged || _skyboxPropertiesChanged || _hazePropertiesChanged;
 
@@ -152,6 +151,7 @@ int ZoneEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
     READ_ENTITY_PROPERTY(PROP_SHAPE_TYPE, ShapeType, setShapeType);
     READ_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);
     READ_ENTITY_PROPERTY(PROP_BACKGROUND_MODE, BackgroundMode, setBackgroundMode);
+    READ_ENTITY_PROPERTY(PROP_BACKGROUND_MODE, HazeMode, setHazeMode);
 
     int bytesFromSkybox;
     withWriteLock([&] {

libraries/model/src/model/Stage.cpp

@@ -139,7 +139,8 @@ const float NUM_HOURS_PER_HALF_DAY = NUM_HOURS_PER_DAY * 0.5f;
 
 SunSkyStage::SunSkyStage() :
     _sunLight(std::make_shared<Light>()),
-    _skybox(std::make_shared<Skybox>())
+    _skybox(std::make_shared<Skybox>()),
+    _haze(std::make_shared<Haze>())
 {
     _sunLight->setType(Light::SUN);
     // Default ambient sphere (for lack of skybox)

libraries/model/src/model/Stage.h

@@ -177,21 +177,21 @@ public:
 
     // Haze
     enum HazeMode {
-        NO_HAZE,
+        HAZE_OFF,
-        YES_HAZE,
+        HAZE_ON,
 
         NUM_HAZE_MODES
     };
 
     void setHazeMode(HazeMode mode);
-    HazeMode gethazeMode() const { return _hazeMode; }
+    HazeMode getHazeMode() const { return _hazeMode; }
 
     void setHaze(const HazePointer& haze);
     const HazePointer& getHaze() const { valid(); return _haze; }
 
 protected:
     BackgroundMode _backgroundMode = SKY_DEFAULT;
-    HazeMode _hazeMode = NO_HAZE;
+    HazeMode _hazeMode = HAZE_OFF;
 
     LightPointer _sunLight;
     mutable SkyboxPointer _skybox;

libraries/octree/src/OctreePacketData.h

@@ -259,6 +259,7 @@ public:
     static int unpackDataFromBytes(const unsigned char* dataBytes, glm::quat& result) { int bytes = unpackOrientationQuatFromBytes(dataBytes, result); return bytes; }
     static int unpackDataFromBytes(const unsigned char* dataBytes, ShapeType& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int unpackDataFromBytes(const unsigned char* dataBytes, BackgroundMode& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
+    static int unpackDataFromBytes(const unsigned char* dataBytes, HazeMode& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
     static int unpackDataFromBytes(const unsigned char* dataBytes, QString& result);
     static int unpackDataFromBytes(const unsigned char* dataBytes, QUuid& result);
     static int unpackDataFromBytes(const unsigned char* dataBytes, xColor& result);

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -113,7 +113,8 @@ bool SceneScripting::Stage::isSunModelEnabled() const {
 void SceneScripting::Stage::setBackgroundMode(const QString& mode) {
     if (mode == QString("inherit")) {
         _skyStage->setBackgroundMode(model::SunSkyStage::NO_BACKGROUND);
-    } else if (mode == QString("skybox")) {
+    }
+    else if (mode == QString("skybox")) {
         _skyStage->setBackgroundMode(model::SunSkyStage::SKY_BOX);
     }
 }
@@ -129,6 +130,26 @@ QString SceneScripting::Stage::getBackgroundMode() const {
     };
 }
 
+void SceneScripting::Stage::setHazeMode(const QString& mode) {
+    if (mode == QString("haze off")) {
+        _skyStage->setHazeMode(model::SunSkyStage::HAZE_OFF);
+    }
+    else if (mode == QString("haze on")) {
+        _skyStage->setHazeMode(model::SunSkyStage::HAZE_ON);
+    }
+}
+
+QString SceneScripting::Stage::getHazeMode() const {
+    switch (_skyStage->getHazeMode()) {
+    case model::SunSkyStage::HAZE_OFF:
+        return QString("haze off");
+    case model::SunSkyStage::HAZE_ON:
+        return QString("haze on");
+    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()));

libraries/script-engine/src/SceneScriptingInterface.h

@@ -121,6 +121,10 @@ namespace SceneScripting {
         void setBackgroundMode(const QString& mode);
         QString getBackgroundMode() const;
 
+        Q_PROPERTY(QString hazeMode READ getHazeMode WRITE setHazeMode)
+        void setHazeMode(const QString& mode);
+        QString getHazeMode() const;
+
     protected:
         model::SunSkyStagePointer _skyStage;
         LocationPointer _location;