diff --git a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp index 6e08a8a230..95c2a9a0df 100644 --- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp @@ -339,6 +339,21 @@ void ZoneEntityRenderer::updateHazeFromEntity(const TypedEntityPointer& entity) const auto& haze = editHaze(); haze->setIsHazeActive(entity->getHazeMode() == HAZE_MODE_ENABLED); + + haze->setHazeRangeFactor(model::convertHazeRangeToHazeRangeFactor(entity->getHazeRange())); + xColor hazeBlendInColor = entity->getHazeBlendInColor(); + haze->setHazeColor(glm::vec3(hazeBlendInColor.red / 255.0, hazeBlendInColor.green / 255.0, hazeBlendInColor.blue / 255.0)); + xColor hazeBlendOutColor = entity->getHazeBlendOutColor(); + haze->setHazeColor(glm::vec3(hazeBlendOutColor.red / 255.0, hazeBlendOutColor.green / 255.0, hazeBlendOutColor.blue / 255.0)); + haze->setDirectionalLightBlend(model::convertDirectionalLightAngleToPower(entity->getHazeLightBlendAngle())); + + haze->setHazeAltitudeFactor(model::convertHazeAltitudeToHazeAltitudeFactor(entity->getHazeAltitude())); + haze->setHazeBaseReference(entity->getHazeBaseRef()); + + haze->setHazeBackgroundBlendValue(entity->getHazeBackgroundBlend()); + + haze->setHazeKeyLightRangeFactor(model::convertHazeRangeToHazeRangeFactor(entity->getHazeRange())); + haze->setHazeAltitudeFactor(model::convertHazeAltitudeToHazeAltitudeFactor(entity->getHazeAltitude())); } void ZoneEntityRenderer::updateKeyBackgroundFromEntity(const TypedEntityPointer& entity) { diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp index 868f5a6dd7..b75809b2f0 100644 --- a/libraries/entities/src/EntityItemProperties.cpp +++ b/libraries/entities/src/EntityItemProperties.cpp @@ -234,10 +234,12 @@ QString EntityItemProperties::getHazeModeAsString() const { 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; @@ -317,7 +319,20 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const { CHECK_PROPERTY_CHANGE(PROP_MARKETPLACE_ID, marketplaceID); CHECK_PROPERTY_CHANGE(PROP_NAME, name); CHECK_PROPERTY_CHANGE(PROP_BACKGROUND_MODE, backgroundMode); - CHECK_PROPERTY_CHANGE(PROP_HAZE_MODE, hazeMode); + + CHECK_PROPERTY_CHANGE(PROP_HAZE_RANGE, hazeRange); + CHECK_PROPERTY_CHANGE(PROP_HAZE_BLEND_IN_COLOR, hazeBlendInColor); + CHECK_PROPERTY_CHANGE(PROP_HAZE_BLEND_OUT_COLOR, hazeBlendOutColor); + CHECK_PROPERTY_CHANGE(PROP_HAZE_LIGHT_BLEND_ANGLE, hazeLightBlendAngle); + + CHECK_PROPERTY_CHANGE(PROP_HAZE_ALTITUDE, hazeAltitude); + CHECK_PROPERTY_CHANGE(PROP_HAZE_BASE_REF, hazeBaseRef); + + CHECK_PROPERTY_CHANGE(PROP_HAZE_BACKGROUND_BLEND, hazeBackgroundBlend); + + CHECK_PROPERTY_CHANGE(PROP_HAZE_KEYLIGHT_RANGE, hazeKeyLightRange); + CHECK_PROPERTY_CHANGE(PROP_HAZE_KEYLIGHT_ALTITUDE, hazeKeyLightAltitude); + CHECK_PROPERTY_CHANGE(PROP_SOURCE_URL, sourceUrl); CHECK_PROPERTY_CHANGE(PROP_VOXEL_VOLUME_SIZE, voxelVolumeSize); CHECK_PROPERTY_CHANGE(PROP_VOXEL_DATA, voxelData); @@ -526,6 +541,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool _keyLight.copyToScriptValue(_desiredProperties, properties, engine, skipDefaults, defaultEntityProperties); COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_BACKGROUND_MODE, backgroundMode, getBackgroundModeAsString()); + COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_HAZE_MODE, hazeMode, getHazeModeAsString()); _skybox.copyToScriptValue(_desiredProperties, properties, engine, skipDefaults, defaultEntityProperties); @@ -706,7 +722,22 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool COPY_PROPERTY_FROM_QSCRIPTVALUE(collisionSoundURL, QString, setCollisionSoundURL); COPY_PROPERTY_FROM_QSCRITPTVALUE_ENUM(backgroundMode, BackgroundMode); + COPY_PROPERTY_FROM_QSCRITPTVALUE_ENUM(hazeMode, HazeMode); + + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeRange, float, setHazeRange); + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeBlendInColor, xColor, setHazeBlendInColor); + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeBlendOutColor, xColor, setHazeBlendOutColor); + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeLightBlendAngle, float, setHazeLightBlendAngle); + + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeAltitude, float, setHazeAltitude); + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeBaseRef, float, setHazeBaseRef); + + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeBackgroundBlend, float, setHazeBackgroundBlend); + + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeKeyLightRange, float, setHazeKeyLightRange); + COPY_PROPERTY_FROM_QSCRIPTVALUE(hazeKeyLightAltitude, float, setHazeKeyLightAltitude); + COPY_PROPERTY_FROM_QSCRIPTVALUE(sourceUrl, QString, setSourceUrl); COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelVolumeSize, glmVec3, setVoxelVolumeSize); COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelData, QByteArray, setVoxelData); @@ -846,7 +877,22 @@ void EntityItemProperties::merge(const EntityItemProperties& other) { COPY_PROPERTY_IF_CHANGED(collisionSoundURL); COPY_PROPERTY_IF_CHANGED(backgroundMode); + COPY_PROPERTY_IF_CHANGED(hazeMode); + + COPY_PROPERTY_IF_CHANGED(hazeRange); + COPY_PROPERTY_IF_CHANGED(hazeBlendInColor); + COPY_PROPERTY_IF_CHANGED(hazeBlendOutColor); + COPY_PROPERTY_IF_CHANGED(hazeLightBlendAngle); + + COPY_PROPERTY_IF_CHANGED(hazeAltitude); + COPY_PROPERTY_IF_CHANGED(hazeBaseRef); + + COPY_PROPERTY_IF_CHANGED(hazeBackgroundBlend); + + COPY_PROPERTY_IF_CHANGED(hazeKeyLightRange); + COPY_PROPERTY_IF_CHANGED(hazeKeyLightAltitude); + COPY_PROPERTY_IF_CHANGED(sourceUrl); COPY_PROPERTY_IF_CHANGED(voxelVolumeSize); COPY_PROPERTY_IF_CHANGED(voxelData); @@ -1025,7 +1071,6 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue ADD_PROPERTY_TO_MAP(PROP_VOXEL_SURFACE_STYLE, VoxelSurfaceStyle, voxelSurfaceStyle, uint16_t); ADD_PROPERTY_TO_MAP(PROP_NAME, Name, name, QString); ADD_PROPERTY_TO_MAP(PROP_BACKGROUND_MODE, BackgroundMode, backgroundMode, BackgroundMode); - ADD_PROPERTY_TO_MAP(PROP_HAZE_MODE, HazeMode, hazeMode, HazeMode); ADD_PROPERTY_TO_MAP(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString); ADD_PROPERTY_TO_MAP(PROP_LINE_WIDTH, LineWidth, lineWidth, float); ADD_PROPERTY_TO_MAP(PROP_LINE_POINTS, LinePoints, linePoints, QVector); @@ -1073,8 +1118,20 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue ADD_GROUP_PROPERTY_TO_MAP(PROP_SKYBOX_COLOR, Skybox, skybox, Color, color); ADD_GROUP_PROPERTY_TO_MAP(PROP_SKYBOX_URL, Skybox, skybox, URL, url); - ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_RANGE, Haze, haze, HazeRange, hazeRange); + ADD_PROPERTY_TO_MAP(PROP_HAZE_MODE, HazeMode, hazeMode, HazeMode); + + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_ALTITUDE, Haze, haze, HazeRange, HazeRange, hazeRange); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_BLEND_IN_COLOR, Haze, haze, HazeBlendInColor, hazeBlendInColor); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_BLEND_OUT_COLOR, Haze, haze, HazeBlendOutColor, hazeBlendOutColor); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_LIGHT_BLEND_ANGLE, Haze, haze, HazeLightBlendAngle, hazeLightBlendAngle); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_ALTITUDE, Haze, haze, HazeAltitude, hazeAltitude); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_BASE_REF, Haze, haze, HazeBaseRef, hazeBaseRef); + + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_BACKGROUND_BLEND, Haze, haze, HazeBackgroundBlend, hazeBackgroundBlend); + + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_KEYLIGHT_RANGE, Haze, haze, HazeKeyLightRange, hazeKeyLightRange); + ADD_GROUP_PROPERTY_TO_MAP(PROP_HAZE_KEYLIGHT_ALTITUDE, Haze, haze, HazeKeyLightAltitude, hazeKeyLightAltitude); ADD_GROUP_PROPERTY_TO_MAP(PROP_STAGE_SUN_MODEL_ENABLED, Stage, stage, SunModelEnabled, sunModelEnabled); ADD_GROUP_PROPERTY_TO_MAP(PROP_STAGE_LATITUDE, Stage, stage, Latitude, latitude); @@ -2105,9 +2162,42 @@ QList EntityItemProperties::listChangedProperties() { if (backgroundModeChanged()) { out += "backgroundMode"; } + if (hazeModeChanged()) { out += "hazeMode"; } + + if (hazeRangeChanged()) { + out += "hazeRange"; + } + if (hazeBlendInColorChanged()) { + out += "hazeBlendInColor"; + } + if (hazeBlendOutColorChanged()) { + out += "hazeBlendOutColor"; + } + if (hazeLightBlendAngleChanged()) { + out += "hazehazeLightBlendAngle"; + } + + if (hazeAltitudeChanged()) { + out += "hazeAltitude"; + } + if (hazeBaseRefChanged()) { + out += "hazeBaseRef"; + } + + if (hazeBackgroundBlendChanged()) { + out += "hazeBackgroundBlend"; + } + + if (hazeKeyLightRangeChanged()) { + out += "hazeKeyLightRange"; + } + if (hazeKeyLightAltitudeChanged()) { + out += "hazeKeyLightAltitude"; + } + if (voxelVolumeSizeChanged()) { out += "voxelVolumeSize"; } diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h index 25799fcc0c..cdbed6e4d7 100644 --- a/libraries/entities/src/EntityItemProperties.h +++ b/libraries/entities/src/EntityItemProperties.h @@ -180,8 +180,20 @@ public: DEFINE_PROPERTY_REF_ENUM(PROP_BACKGROUND_MODE, BackgroundMode, backgroundMode, BackgroundMode, BACKGROUND_MODE_INHERIT); DEFINE_PROPERTY_REF_ENUM(PROP_HAZE_MODE, HazeMode, hazeMode, HazeMode, HAZE_MODE_INHERIT); + DEFINE_PROPERTY(PROP_HAZE_RANGE, HazeRange, hazeRange, float, HazePropertyGroup::DEFAULT_HAZE_RANGE); + DEFINE_PROPERTY(PROP_HAZE_BLEND_IN_COLOR, HazeBlendInColor, hazeBlendInColor, xColor, HazePropertyGroup::DEFAULT_HAZE_BLEND_IN_COLOR); + DEFINE_PROPERTY(PROP_HAZE_BLEND_OUT_COLOR, HazeBlendOutColor, hazeBlendOutColor, xColor, HazePropertyGroup::DEFAULT_HAZE_BLEND_OUT_COLOR); + DEFINE_PROPERTY(PROP_HAZE_LIGHT_BLEND_ANGLE, HazeLightBlendAngle, hazeLightBlendAngle, float, HazePropertyGroup::DEFAULT_HAZE_ALTITUDE); + DEFINE_PROPERTY(PROP_HAZE_ALTITUDE, HazeAltitude, hazeAltitude, float, HazePropertyGroup::DEFAULT_HAZE_ALTITUDE); + DEFINE_PROPERTY(PROP_HAZE_BASE_REF, HazeBaseRef, hazeBaseRef, float, HazePropertyGroup::DEFAULT_HAZE_ALTITUDE); + + DEFINE_PROPERTY(PROP_HAZE_BACKGROUND_BLEND, HazeBackgroundBlend, hazeBackgroundBlend, float, HazePropertyGroup::DEFAULT_HAZE_ALTITUDE); + + DEFINE_PROPERTY(PROP_HAZE_KEYLIGHT_RANGE, HazeKeyLightRange, hazeKeyLightRange, float, HazePropertyGroup::DEFAULT_HAZE_RANGE); + DEFINE_PROPERTY(PROP_HAZE_KEYLIGHT_ALTITUDE, HazeKeyLightAltitude, hazeKeyLightAltitude, float, HazePropertyGroup::DEFAULT_HAZE_ALTITUDE); + DEFINE_PROPERTY_GROUP(Skybox, skybox, SkyboxPropertyGroup); DEFINE_PROPERTY_GROUP(Haze, haze, HazePropertyGroup); diff --git a/libraries/entities/src/HazePropertyGroup.cpp b/libraries/entities/src/HazePropertyGroup.cpp index 6b26a55481..3bad0cfda3 100644 --- a/libraries/entities/src/HazePropertyGroup.cpp +++ b/libraries/entities/src/HazePropertyGroup.cpp @@ -20,7 +20,7 @@ const uint8_t HazePropertyGroup::DEFAULT_HAZE_MODE{ 0 }; const float HazePropertyGroup::DEFAULT_HAZE_RANGE{ 1000.0f }; const xColor HazePropertyGroup::DEFAULT_HAZE_BLEND_IN_COLOR{ 128, 154, 179 }; // Bluish const xColor HazePropertyGroup::DEFAULT_HAZE_BLEND_OUT_COLOR{ 255, 229, 179 }; // Yellowish -const float HazePropertyGroup::DEFAULT_LIGHT_BLEND_ANGLE{ 20.0 }; +const float HazePropertyGroup::DEFAULT_HAZE_LIGHT_BLEND_ANGLE{ 20.0 }; const float HazePropertyGroup::DEFAULT_HAZE_ALTITUDE{ 200.0f }; const float HazePropertyGroup::DEFAULT_HAZE_BASE_REF{ 0.0f }; diff --git a/libraries/entities/src/HazePropertyGroup.h b/libraries/entities/src/HazePropertyGroup.h index 78cf1d6e46..355dc3b808 100644 --- a/libraries/entities/src/HazePropertyGroup.h +++ b/libraries/entities/src/HazePropertyGroup.h @@ -79,7 +79,7 @@ public: static const float DEFAULT_HAZE_RANGE; static const xColor DEFAULT_HAZE_BLEND_IN_COLOR; static const xColor DEFAULT_HAZE_BLEND_OUT_COLOR; - static const float DEFAULT_LIGHT_BLEND_ANGLE; + static const float DEFAULT_HAZE_LIGHT_BLEND_ANGLE; static const float DEFAULT_HAZE_ALTITUDE; static const float DEFAULT_HAZE_BASE_REF; @@ -96,7 +96,7 @@ public: DEFINE_PROPERTY(PROP_HAZE_RANGE, HazeRange, hazeRange, float, DEFAULT_HAZE_RANGE); DEFINE_PROPERTY_REF(PROP_HAZE_BLEND_IN_COLOR, HazeBlendInColor, hazeBlendInColor, xColor, DEFAULT_HAZE_BLEND_IN_COLOR); DEFINE_PROPERTY_REF(PROP_HAZE_BLEND_OUT_COLOR, HazeBlendOutColor, hazeBlendOutColor, xColor, DEFAULT_HAZE_BLEND_OUT_COLOR); - DEFINE_PROPERTY(PROP_HAZE_LIGHT_BLEND_ANGLE, HazeLightBlendAngle, hazeLightBlendAngle, float, DEFAULT_LIGHT_BLEND_ANGLE); + DEFINE_PROPERTY(PROP_HAZE_LIGHT_BLEND_ANGLE, HazeLightBlendAngle, hazeLightBlendAngle, float, DEFAULT_HAZE_LIGHT_BLEND_ANGLE); // Range & Altitude parameters DEFINE_PROPERTY(PROP_HAZE_ALTITUDE, HazeAltitude, hazeAltitude, float, DEFAULT_HAZE_ALTITUDE); diff --git a/libraries/entities/src/ZoneEntityItem.cpp b/libraries/entities/src/ZoneEntityItem.cpp index 2d2f3c9051..e6af326e46 100644 --- a/libraries/entities/src/ZoneEntityItem.cpp +++ b/libraries/entities/src/ZoneEntityItem.cpp @@ -110,6 +110,19 @@ bool ZoneEntityItem::setSubClassProperties(const EntityItemProperties& propertie SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeMode, setHazeMode); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeRange, setHazeRange); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeBlendInColor, setHazeBlendInColor); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeBlendInColor, setHazeBlendInColor); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeLightBlendAngle, setHazeLightBlendAngle); + + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeAltitude, setHazeAltitude); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeBaseRef, setHazeBaseRef); + + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeBackgroundBlend, setHazeBackgroundBlend); + + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeKeyLightRange, setHazeKeyLightRange); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeKeyLightAltitude, setHazeKeyLightAltitude); + SET_ENTITY_PROPERTY_FROM_PROPERTIES(flyingAllowed, setFlyingAllowed); SET_ENTITY_PROPERTY_FROM_PROPERTIES(ghostingAllowed, setGhostingAllowed); SET_ENTITY_PROPERTY_FROM_PROPERTIES(filterURL, setFilterURL); @@ -321,12 +334,93 @@ void ZoneEntityItem::resetRenderingPropertiesChanged() { }); } -void ZoneEntityItem::setHazeMode(HazeMode value) { +void ZoneEntityItem::setHazeMode(const HazeMode value) { _hazeMode = value; _hazePropertiesChanged = true; } HazeMode ZoneEntityItem::getHazeMode() const { - return _hazeMode; + return _hazeMode; +} + +void ZoneEntityItem::setHazeRange(const float hazeRange) { + _hazeRange = hazeRange; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeRange() const { + return _hazeRange; +} + +void ZoneEntityItem::setHazeBlendInColor(const xColor hazeBlendInColor){ + _hazeBlendInColor = hazeBlendInColor; + _hazePropertiesChanged = true; +} + +xColor ZoneEntityItem::getHazeBlendInColor()const{ + return _hazeBlendInColor; +} + +void ZoneEntityItem::setHazeBlendOutColor(const xColor hazeBlendOutColor){ + _hazeBlendOutColor = hazeBlendOutColor; + _hazePropertiesChanged = true; +} + +xColor ZoneEntityItem::getHazeBlendOutColor()const{ + return _hazeBlendOutColor; +} + +void ZoneEntityItem::setHazeLightBlendAngle(const float hazeLightBlendAngle){ + _hazeLightBlendAngle = hazeLightBlendAngle; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeLightBlendAngle()const{ + return _hazeLightBlendAngle; +} + +void ZoneEntityItem::setHazeAltitude(const float hazeAltitude){ + _hazeAltitude = hazeAltitude; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeAltitude()const{ + return _hazeAltitude; +} + +void ZoneEntityItem::setHazeBaseRef(const float hazeBaseRef){ + _hazeBaseRef = hazeBaseRef; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeBaseRef()const{ + return _hazeBaseRef; +} + +void ZoneEntityItem::setHazeBackgroundBlend(const float hazeBackgroundBlend){ + _hazeBackgroundBlend = hazeBackgroundBlend; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeBackgroundBlend()const{ + return _hazeBackgroundBlend; +} + +void ZoneEntityItem::setHazeKeyLightRange(const float hazeKeyLightRange){ + _hazeKeyLightRange = hazeKeyLightRange; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeKeyLightRange()const { + return _hazeKeyLightRange; +} + +void ZoneEntityItem::setHazeKeyLightAltitude(const float hazeKeyLightAltitude){ + _hazeKeyLightAltitude = hazeKeyLightAltitude; + _hazePropertiesChanged = true; +} + +float ZoneEntityItem::getHazeKeyLightAltitude()const{ + return _hazeKeyLightAltitude; } diff --git a/libraries/entities/src/ZoneEntityItem.h b/libraries/entities/src/ZoneEntityItem.h index 344c9df553..630c9fb83e 100644 --- a/libraries/entities/src/ZoneEntityItem.h +++ b/libraries/entities/src/ZoneEntityItem.h @@ -69,9 +69,31 @@ public: void setBackgroundMode(BackgroundMode value) { _backgroundMode = value; _backgroundPropertiesChanged = true; } BackgroundMode getBackgroundMode() const { return _backgroundMode; } - void setHazeMode(HazeMode value); + void setHazeMode(const HazeMode value); HazeMode getHazeMode() const; + void setHazeRange(const float hazeRange); + float getHazeRange()const; + void setHazeBlendInColor(const xColor hazeBlendInColor); + xColor getHazeBlendInColor()const; + void setHazeBlendOutColor(const xColor hazeBlendOutColor); + xColor getHazeBlendOutColor()const; + void setHazeLightBlendAngle(const float hazeLightBlendAngle); + float getHazeLightBlendAngle()const; + + void setHazeAltitude(const float hazeAltitude); + float getHazeAltitude()const; + void setHazeBaseRef(const float hazeBaseRef); + float getHazeBaseRef()const; + + void setHazeBackgroundBlend(const float hazeBackgroundBlend); + float getHazeBackgroundBlend()const; + + void setHazeKeyLightRange(const float hazeKeyLightRange); + float getHazeKeyLightRange()const; + void setHazeKeyLightAltitude(const float hazeKeyLightAltitude); + float getHazeKeyLightAltitude()const; + SkyboxPropertyGroup getSkyboxProperties() const { return resultWithReadLock([&] { return _skyboxProperties; }); } const HazePropertyGroup& getHazeProperties() const { return _hazeProperties; } @@ -121,6 +143,19 @@ protected: HazeMode _hazeMode{ HAZE_MODE_INHERIT }; + float _hazeRange{ HazePropertyGroup::DEFAULT_HAZE_RANGE }; + xColor _hazeBlendInColor{ HazePropertyGroup::DEFAULT_HAZE_BLEND_IN_COLOR }; + xColor _hazeBlendOutColor{ HazePropertyGroup::DEFAULT_HAZE_BLEND_OUT_COLOR }; + float _hazeLightBlendAngle{ HazePropertyGroup::DEFAULT_HAZE_LIGHT_BLEND_ANGLE }; + + float _hazeAltitude{ HazePropertyGroup::DEFAULT_HAZE_ALTITUDE }; + float _hazeBaseRef{ HazePropertyGroup::DEFAULT_HAZE_BASE_REF }; + + float _hazeBackgroundBlend{ HazePropertyGroup::DEFAULT_HAZE_BACKGROUND_BLEND }; + + float _hazeKeyLightRange{ HazePropertyGroup::DEFAULT_HAZE_KEYLIGHT_RANGE }; + float _hazeKeyLightAltitude{ HazePropertyGroup::DEFAULT_HAZE_KEYLIGHT_ALTITUDE }; + SkyboxPropertyGroup _skyboxProperties; HazePropertyGroup _hazeProperties; StagePropertyGroup _stageProperties; diff --git a/libraries/gl/src/gl/GLShaders.cpp b/libraries/gl/src/gl/GLShaders.cpp index 4b82803d2c..a05b923fb3 100644 --- a/libraries/gl/src/gl/GLShaders.cpp +++ b/libraries/gl/src/gl/GLShaders.cpp @@ -45,9 +45,9 @@ namespace gl { std::ofstream filestream; filestream.open("D:\\debugshader.glsl"); if (filestream.is_open()) { - filestream << srcstr[0]; - filestream << srcstr[1]; - filestream.close(); + filestream << srcstr[0]; + filestream << srcstr[1]; + filestream.close(); } @@ -61,8 +61,8 @@ namespace gl { filestream.open("D:\\debugshader.glsl.info.txt"); if (filestream.is_open()) { - filestream << std::string(temp); - filestream.close(); + filestream << std::string(temp); + filestream.close(); } diff --git a/libraries/model/src/model/Haze.cpp b/libraries/model/src/model/Haze.cpp index 9844579af2..7daca3c77c 100644 --- a/libraries/model/src/model/Haze.cpp +++ b/libraries/model/src/model/Haze.cpp @@ -27,7 +27,6 @@ enum HazeModes { HAZE_MODE_IS_MODULATE_COLOR = 1 << 3 }; - // For color modulated mode, the colour values are used as range values, which are then converted to range factors // This is separate for each colour. // The colour value is converted from [0.0 .. 1.0] to [5.0 .. 3000.0] @@ -139,21 +138,30 @@ void Haze::setHazeAltitudeFactor(const float hazeAltitudeFactor) { } } -void Haze::setHazeRangeFactorKeyLight(const float hazeRangeFactorKeyLight) { +void Haze::setHazeKeyLightRangeFactor(const float hazeKeyLightRangeFactor) { auto& params = _parametersBuffer.get(); - if (params.hazeRangeFactorKeyLight != hazeRangeFactorKeyLight) { - _parametersBuffer.edit().hazeRangeFactorKeyLight = hazeRangeFactorKeyLight; + if (params.hazeKeyLightRangeFactor != hazeKeyLightRangeFactor) { + _parametersBuffer.edit().hazeKeyLightRangeFactor = hazeKeyLightRangeFactor; } } -void Haze::setHazeAltitudeFactorKeyLight(const float hazeAltitudeFactorKeyLight) { +void Haze::setHazeKeyLightAltitudeFactor(const float hazeKeyLightAltitudeFactor) { auto& params = _parametersBuffer.get(); - if (params.hazeAltitudeFactorKeyLight != hazeAltitudeFactorKeyLight) { - _parametersBuffer.edit().hazeAltitudeFactorKeyLight = hazeAltitudeFactorKeyLight; + if (params.hazeKeyLightAltitudeFactor != hazeKeyLightAltitudeFactor) { + _parametersBuffer.edit().hazeKeyLightAltitudeFactor = hazeKeyLightAltitudeFactor; } } + +void Haze::setHazeBackgroundBlendValue(const float hazeBackgroundBlendValue) { + auto& params = _parametersBuffer.get(); + + if (params.hazeBackgroundBlendValue != hazeBackgroundBlendValue) { + _parametersBuffer.edit().hazeBackgroundBlendValue = hazeBackgroundBlendValue; + } +} + void Haze::setHazeBaseReference(const float hazeBaseReference) { auto& params = _parametersBuffer.get(); diff --git a/libraries/model/src/model/Haze.h b/libraries/model/src/model/Haze.h index fee387cd0d..7ba09c86e7 100644 --- a/libraries/model/src/model/Haze.h +++ b/libraries/model/src/model/Haze.h @@ -14,50 +14,49 @@ #include #include "NumericalConstants.h" -const double p_005 = 0.05; - -// Derivation (d is distance, b is haze coefficient, f is attenuation, solve for f = 0.05 -// f = exp(-d * b) -// ln(f) = -d * b -// b = -ln(f)/d -inline float convertHazeRangeToHazeRangeFactor(const float hazeRange_m) { return (float)-log(p_005) / hazeRange_m; } - -inline float convertHazeAltitudeToHazeAltitudeFactor(const float hazeAltitude_m) { - return (float)-log(p_005) / hazeAltitude_m; -} - -// Derivation (s is th proportion of sun blend, a is the angle at which the blend is 50%, solve for m = 0.5 -// s = dot(lookAngle, sunAngle) = cos(a) -// m = pow(s, p) -// log(m) = p * log(s) -// p = log(m) / log(s) -inline float convertDirectionalLightAngleToPower(const float directionalLightAngle) { - return log(0.5) / log(cos(RADIANS_PER_DEGREE * directionalLightAngle)); -} - -const glm::vec3 initialHazeColor{ 0.5, 0.6, 0.7 }; -const float initialDirectionalLightAngle_degs{ 30.0f }; - -const glm::vec3 initialDirectionalLightColor{ 1.0, 0.9, 0.7 }; -const float initialHazeBaseReference{ 0.0f }; - -// Haze range is defined here as the range the visibility is reduced by 95% -// Haze altitude is defined here as the altitude (above 0) that the haze is reduced by 95% -const float initialHazeRange_m{ 150.0f }; -const float initialHazeAltitude_m{ 150.0f }; - -const float initialHazeRangeKeyLight_m{ 150.0f }; -const float initialHazeAltitudeKeyLight_m{ 150.0f }; - -const float initialBackgroundBlendValue{ 0.0f }; - -const glm::vec3 initialColorModulationFactor{ - convertHazeRangeToHazeRangeFactor(initialHazeRange_m), - convertHazeRangeToHazeRangeFactor(initialHazeRange_m), - convertHazeRangeToHazeRangeFactor(initialHazeRange_m) -}; - namespace model { + const double p_005 = 0.05; + + // Derivation (d is distance, b is haze coefficient, f is attenuation, solve for f = 0.05 + // f = exp(-d * b) + // ln(f) = -d * b + // b = -ln(f)/d + inline float convertHazeRangeToHazeRangeFactor(const float hazeRange_m) { return (float)-log(p_005) / hazeRange_m; } + + inline float convertHazeAltitudeToHazeAltitudeFactor(const float hazeAltitude_m) { + return (float)-log(p_005) / hazeAltitude_m; + } + + // Derivation (s is th proportion of sun blend, a is the angle at which the blend is 50%, solve for m = 0.5 + // s = dot(lookAngle, sunAngle) = cos(a) + // m = pow(s, p) + // log(m) = p * log(s) + // p = log(m) / log(s) + inline float convertDirectionalLightAngleToPower(const float directionalLightAngle) { + return log(0.5) / log(cos(RADIANS_PER_DEGREE * directionalLightAngle)); + } + + const glm::vec3 initialHazeColor{ 0.5, 0.6, 0.7 }; + const float initialDirectionalLightAngle_degs{ 30.0f }; + + const glm::vec3 initialDirectionalLightColor{ 1.0, 0.9, 0.7 }; + const float initialHazeBaseReference{ 0.0f }; + + // Haze range is defined here as the range the visibility is reduced by 95% + // Haze altitude is defined here as the altitude (above 0) that the haze is reduced by 95% + const float initialHazeRange_m{ 150.0f }; + const float initialHazeAltitude_m{ 150.0f }; + + const float initialHazeKeyLightRange_m{ 150.0f }; + const float initialHazeKeyLightAltitude_m{ 150.0f }; + + const float initialBackgroundBlendValue{ 0.0f }; + + const glm::vec3 initialColorModulationFactor{ + convertHazeRangeToHazeRangeFactor(initialHazeRange_m), + convertHazeRangeToHazeRangeFactor(initialHazeRange_m), + convertHazeRangeToHazeRangeFactor(initialHazeRange_m) + }; class Haze { public: @@ -79,10 +78,10 @@ namespace model { void setHazeRangeFactor(const float hazeRange); void setHazeAltitudeFactor(const float hazeAltitude); - void setHazeRangeFactorKeyLight(const float hazeRangeKeyLight); - void setHazeAltitudeFactorKeyLight(const float hazeAltitudeKeyLight); + void setHazeKeyLightRangeFactor(const float hazeKeyLightRange); + void setHazeKeyLightAltitudeFactor(const float hazeKeyLightAltitude); - void setBackgroundBlendValue(const float backgroundBlendValue); + void setHazeBackgroundBlendValue(const float hazeBackgroundBlendValue); UniformBufferView getParametersBuffer() const { return _parametersBuffer; } @@ -101,14 +100,15 @@ namespace model { // bit 1 - set to add the effect of altitude to the haze attenuation // bit 2 - set to activate directional light attenuation mode - // The haze attenuation exponents used by both fragment and directional light attenuation + // The haze attenuation exponents used by both fragment and directional light attenuation float hazeRangeFactor{ convertHazeRangeToHazeRangeFactor(initialHazeRange_m) }; float hazeAltitudeFactor{ convertHazeAltitudeToHazeAltitudeFactor(initialHazeAltitude_m) }; - float hazeRangeFactorKeyLight{ convertHazeRangeToHazeRangeFactor(initialHazeRangeKeyLight_m) }; - float hazeAltitudeFactorKeyLight{ convertHazeAltitudeToHazeAltitudeFactor(initialHazeAltitudeKeyLight_m) }; + float hazeKeyLightRangeFactor{ convertHazeRangeToHazeRangeFactor(initialHazeKeyLightRange_m) }; + float hazeKeyLightAltitudeFactor{ convertHazeAltitudeToHazeAltitudeFactor(initialHazeKeyLightAltitude_m) }; - float backgroundBlendValue{ initialBackgroundBlendValue }; + // Amount of background (skybox) to display, overriding the haze effect for the background + float hazeBackgroundBlendValue{ initialBackgroundBlendValue }; Parameters() {} }; diff --git a/libraries/model/src/model/Stage.h b/libraries/model/src/model/Stage.h index fe5e9e2a78..49eedaccbb 100644 --- a/libraries/model/src/model/Stage.h +++ b/libraries/model/src/model/Stage.h @@ -188,16 +188,43 @@ public: void setHazeRange(float hazeRange) { _hazeRange = hazeRange; } float getHazeRange() const { return _hazeRange; } + void setHazeBlendInColor(const xColor hazeBlendInColor) { _hazeBlendInColor = hazeBlendInColor; } + xColor getHazeBlendInColor() { return _hazeBlendInColor; } + void setHazeBlendOutColor(const xColor hazeBlendOutColor) { _hazeBlendInColor = hazeBlendOutColor; } + xColor getHazeBlendOutColor() const { return _hazeBlendOutColor; } + void setHazeLightBlendAngle(float hazeLightBlendAngle) { _hazeLightBlendAngle = hazeLightBlendAngle; } + float getHazeLightBlendAngle() const { return _hazeLightBlendAngle; } void setHazeAltitude(float hazeAltitude) { _hazeAltitude = hazeAltitude; } float getHazeAltitude() const { return _hazeAltitude; } + void setHazeBaseRef(float hazeBaseRef) { _hazeBaseRef = hazeBaseRef; } + float getHazeBaseRef() const { return _hazeBaseRef; } + + void setHazeBackgroundBlend(float hazeBackgroundBlend) { _hazeBackgroundBlend = hazeBackgroundBlend; } + float getHazeBackgroundBlend() const { return _hazeBackgroundBlend; } + + void setHazeKeyLightRange(float hazeKeyLightRange) { _hazeKeyLightRange = hazeKeyLightRange; } + float getHazeKeyLightRange() const { return _hazeKeyLightRange; } + void setHazeKeyLightAltitude(float hazeKeyLightAltitude) { _hazeKeyLightAltitude = hazeKeyLightAltitude; } + float getHazeKeyLightAltitude() const { return _hazeKeyLightAltitude; } protected: BackgroundMode _backgroundMode = SKY_DEFAULT; HazeMode _hazeMode = HAZE_OFF; + float _hazeRange; + xColor _hazeBlendInColor; + xColor _hazeBlendOutColor; + float _hazeLightBlendAngle; + float _hazeAltitude; + float _hazeBaseRef; + + float _hazeBackgroundBlend; + + float _hazeKeyLightRange; + float _hazeKeyLightAltitude; LightPointer _sunLight; mutable SkyboxPointer _skybox; diff --git a/libraries/render-utils/src/DrawHaze.h b/libraries/render-utils/src/DrawHaze.h index fc8a9144b3..a246c3ca87 100644 --- a/libraries/render-utils/src/DrawHaze.h +++ b/libraries/render-utils/src/DrawHaze.h @@ -31,28 +31,28 @@ public: HazeConfig() : render::Job::Config(true) {} // attributes - float hazeColorR{ initialHazeColor.r }; - float hazeColorG{ initialHazeColor.g }; - float hazeColorB{ initialHazeColor.b }; - float directionalLightAngle_degs{ initialDirectionalLightAngle_degs }; + float hazeColorR{ model::initialHazeColor.r }; + float hazeColorG{ model::initialHazeColor.g }; + float hazeColorB{ model::initialHazeColor.b }; + float directionalLightAngle_degs{ model::initialDirectionalLightAngle_degs }; - float directionalLightColorR{ initialDirectionalLightColor.r }; - float directionalLightColorG{ initialDirectionalLightColor.g }; - float directionalLightColorB{ initialDirectionalLightColor.b }; - float hazeBaseReference{ initialHazeBaseReference }; + float directionalLightColorR{ model::initialDirectionalLightColor.r }; + float directionalLightColorG{ model::initialDirectionalLightColor.g }; + float directionalLightColorB{ model::initialDirectionalLightColor.b }; + float hazeBaseReference{ model::initialHazeBaseReference }; bool isHazeActive{ false }; // Setting this to true will set haze to on bool isAltitudeBased{ false }; bool isDirectionalLightAttenuationActive{ false }; bool isModulateColorActive{ false }; - float hazeRange_m{ initialHazeRange_m }; - float hazeAltitude_m{ initialHazeAltitude_m }; + float hazeRange_m{ model::initialHazeRange_m }; + float hazeAltitude_m{ model::initialHazeAltitude_m }; - float hazeRangeKeyLight_m{ initialHazeRangeKeyLight_m }; - float hazeAltitudeKeyLight_m{ initialHazeAltitudeKeyLight_m }; + float hazeRangeKeyLight_m{ model::initialHazeKeyLightRange_m }; + float hazeAltitudeKeyLight_m{ model::initialHazeKeyLightAltitude_m }; - float backgroundBlendValue{ initialBackgroundBlendValue }; + float backgroundBlendValue{ model::initialBackgroundBlendValue }; // methods void setHazeColorR(const float value); diff --git a/libraries/script-engine/src/SceneScriptingInterface.cpp b/libraries/script-engine/src/SceneScriptingInterface.cpp index 953fafcd23..7f788f11e3 100644 --- a/libraries/script-engine/src/SceneScriptingInterface.cpp +++ b/libraries/script-engine/src/SceneScriptingInterface.cpp @@ -153,18 +153,60 @@ QString SceneScripting::Stage::getHazeMode() const { void SceneScripting::Stage::setHazeRange(const float hazeRange) { _skyStage->setHazeRange(hazeRange); } - float SceneScripting::Stage::getHazeRange() const { return _skyStage->getHazeRange(); } +void SceneScripting::Stage::setHazeBlendInColor(const xColor hazeBlendInColor) { + _skyStage->setHazeBlendInColor(hazeBlendInColor); +} +xColor SceneScripting::Stage::getHazeBlendInColor() const { + return _skyStage->getHazeBlendInColor(); +} +void SceneScripting::Stage::setHazeBlendOutColor(const xColor hazeBlendOutColor) { + _skyStage->setHazeBlendOutColor(hazeBlendOutColor); +} +xColor SceneScripting::Stage::getHazeBlendOutColor() const { + return _skyStage->getHazeBlendOutColor(); +} +void SceneScripting::Stage::setHazeLightBlendAngle(const float hazeLightBlendAngle) { + _skyStage->setHazeLightBlendAngle(hazeLightBlendAngle); +} +float SceneScripting::Stage::getHazeLightBlendAngle() const { + return _skyStage->getHazeLightBlendAngle(); +} void SceneScripting::Stage::setHazeAltitude(const float hazeAltitude) { _skyStage->setHazeAltitude(hazeAltitude); } - float SceneScripting::Stage::getHazeAltitude() const { return _skyStage->getHazeAltitude(); } +void SceneScripting::Stage::setHazeBaseRef(const float hazeBaseRef) { + _skyStage->setHazeBaseRef(hazeBaseRef); +} +float SceneScripting::Stage::getHazeBaseRef() const { + return _skyStage->getHazeBaseRef(); +} + +void SceneScripting::Stage::setHazeBackgroundBlend(const float hazeBackgroundBlend) { + _skyStage->setHazeBackgroundBlend(hazeBackgroundBlend); +} +float SceneScripting::Stage::getHazeBackgroundBlend() const { + return _skyStage->getHazeBackgroundBlend(); +} + +void SceneScripting::Stage::setHazeKeyLightRange(const float hazeKeyLightRange) { + _skyStage->setHazeKeyLightRange(hazeKeyLightRange); +} +float SceneScripting::Stage::getHazeKeyLightRange() const { + return _skyStage->getHazeKeyLightRange(); +} +void SceneScripting::Stage::setHazeKeyLightAltitude(const float hazeKeyLightAltitude) { + _skyStage->setHazeKeyLightAltitude(hazeKeyLightAltitude); +} +float SceneScripting::Stage::getHazeKeyLightAltitude() const { + return _skyStage->getHazeKeyLightAltitude(); +} SceneScriptingInterface::SceneScriptingInterface() : _stage{ new SceneScripting::Stage{ _skyStage } } { // Let's make sure the sunSkyStage is using a proceduralSkybox diff --git a/libraries/script-engine/src/SceneScriptingInterface.h b/libraries/script-engine/src/SceneScriptingInterface.h index 342f2c548c..d0ff6b32b9 100644 --- a/libraries/script-engine/src/SceneScriptingInterface.h +++ b/libraries/script-engine/src/SceneScriptingInterface.h @@ -128,10 +128,33 @@ namespace SceneScripting { Q_PROPERTY(float hazeRange READ getHazeRange WRITE setHazeRange) void setHazeRange(float value); float getHazeRange() const; + Q_PROPERTY(xColor hazeBlendInColor READ getHazeBlendInColor WRITE setHazeBlendInColor) + void setHazeBlendInColor(xColor value); + xColor getHazeBlendInColor() const; + Q_PROPERTY(xColor hazeBlendOutColor READ getHazeBlendOutColor WRITE setHazeBlendOutColor) + void setHazeBlendOutColor(xColor value); + xColor getHazeBlendOutColor() const; + Q_PROPERTY(float hazeLightBlendAngle READ getHazeLightBlendAngle WRITE setHazeLightBlendAngle) + void setHazeLightBlendAngle(float value); + float getHazeLightBlendAngle() const; Q_PROPERTY(float hazeAltitude READ getHazeAltitude WRITE setHazeAltitude) void setHazeAltitude(float value); float getHazeAltitude() const; + Q_PROPERTY(float hazeBaseRef READ getHazeBaseRef WRITE setHazeBaseRef) + void setHazeBaseRef(float value); + float getHazeBaseRef() const; + + Q_PROPERTY(float hazeBackgroundBlend READ getHazeBackgroundBlend WRITE setHazeBackgroundBlend) + void setHazeBackgroundBlend(float value); + float getHazeBackgroundBlend() const; + + Q_PROPERTY(float hazeKeyLightRange READ getHazeKeyLightRange WRITE setHazeKeyLightRange) + void setHazeKeyLightRange(float value); + float getHazeKeyLightRange() const; + Q_PROPERTY(float hazeKeyLightAltitude READ getHazeKeyLightAltitude WRITE setHazeKeyLightAltitude) + void setHazeKeyLightAltitude(float value); + float getHazeKeyLightAltitude() const; protected: model::SunSkyStagePointer _skyStage;