Merge pull request #13778 from SamGondelman/bloom

Enable bloom in zone properties
2025-04-09 09:12:50 +02:00 · 2018-08-24 14:46:31 -07:00 · 2018-08-24 14:46:31 -07:00 · fcdbc6c6d2
commit fcdbc6c6d2
parent 477fba4b15 bba806f78c
27 changed files with 922 additions and 285 deletions
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
@ -64,6 +64,13 @@ void ZoneEntityRenderer::onRemoveFromSceneTyped(const TypedEntityPointer& entity
            _hazeIndex = INVALID_INDEX;
        }
    }
+
+    if (_bloomStage) {
+        if (!BloomStage::isIndexInvalid(_bloomIndex)) {
+            _bloomStage->removeBloom(_bloomIndex);
+            _bloomIndex = INVALID_INDEX;
+        }
+    }
 }

 void ZoneEntityRenderer::doRender(RenderArgs* args) {
@ -112,6 +119,11 @@ void ZoneEntityRenderer::doRender(RenderArgs* args) {
        assert(_hazeStage);
    }

+    if (!_bloomStage) {
+        _bloomStage = args->_scene->getStage<BloomStage>();
+        assert(_bloomStage);
+    }
+
    { // Sun 
      // Need an update ?
        if (_needSunUpdate) {
@ -161,6 +173,15 @@ void ZoneEntityRenderer::doRender(RenderArgs* args) {
        }
    }

+    {
+        if (_needBloomUpdate) {
+            if (BloomStage::isIndexInvalid(_bloomIndex)) {
+                _bloomIndex = _bloomStage->addBloom(_bloom);
+            }
+            _needBloomUpdate = false;
+        }
+    }
+
    if (_visible) {
        // Finally, push the lights visible in the frame
        //
@ -190,6 +211,12 @@ void ZoneEntityRenderer::doRender(RenderArgs* args) {
        if (_hazeMode != COMPONENT_MODE_INHERIT) {
            _hazeStage->_currentFrame.pushHaze(_hazeIndex);
        }
+
+        if (_bloomMode == COMPONENT_MODE_DISABLED) {
+            _bloomStage->_currentFrame.pushBloom(INVALID_INDEX);
+        } else if (_bloomMode == COMPONENT_MODE_ENABLED) {
+            _bloomStage->_currentFrame.pushBloom(_bloomIndex);
+        }
    }
 }

@ -211,6 +238,7 @@ void ZoneEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
    bool ambientLightChanged = entity->ambientLightPropertiesChanged();
    bool skyboxChanged = entity->skyboxPropertiesChanged();
    bool hazeChanged = entity->hazePropertiesChanged();
+    bool bloomChanged = entity->bloomPropertiesChanged();

    entity->resetRenderingPropertiesChanged();
    _lastPosition = entity->getWorldPosition();
@ -221,6 +249,7 @@ void ZoneEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
    _ambientLightProperties = entity->getAmbientLightProperties();
    _skyboxProperties = entity->getSkyboxProperties();
    _hazeProperties = entity->getHazeProperties();
+    _bloomProperties = entity->getBloomProperties();

 #if 0
    if (_lastShapeURL != _typedEntity->getCompoundShapeURL()) {
@ -258,6 +287,10 @@ void ZoneEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scen
    if (hazeChanged) {
        updateHazeFromEntity(entity);
    }
+
+    if (bloomChanged) {
+        updateBloomFromEntity(entity);
+    }
 }

 void ZoneEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
@ -276,6 +309,7 @@ bool ZoneEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoint
    if (entity->keyLightPropertiesChanged() ||
        entity->ambientLightPropertiesChanged() ||
        entity->hazePropertiesChanged() ||
+        entity->bloomPropertiesChanged() ||
        entity->skyboxPropertiesChanged()) {

        return true;
@ -388,6 +422,16 @@ void ZoneEntityRenderer::updateHazeFromEntity(const TypedEntityPointer& entity)
    haze->setTransform(entity->getTransform().getMatrix());
 }

+void ZoneEntityRenderer::updateBloomFromEntity(const TypedEntityPointer& entity) {
+    setBloomMode((ComponentMode)entity->getBloomMode());
+
+    const auto& bloom = editBloom();
+
+    bloom->setBloomIntensity(_bloomProperties.getBloomIntensity());
+    bloom->setBloomThreshold(_bloomProperties.getBloomThreshold());
+    bloom->setBloomSize(_bloomProperties.getBloomSize());
+}
+
 void ZoneEntityRenderer::updateKeyBackgroundFromEntity(const TypedEntityPointer& entity) {
    setSkyboxMode((ComponentMode)entity->getSkyboxMode());

@ -510,6 +554,10 @@ void ZoneEntityRenderer::setSkyboxMode(ComponentMode mode) {
    _skyboxMode = mode;
 }

+void ZoneEntityRenderer::setBloomMode(ComponentMode mode) {
+    _bloomMode = mode;
+}
+
 void ZoneEntityRenderer::setSkyboxColor(const glm::vec3& color) {
    editSkybox()->setColor(color);
 }
--- a/libraries/entities-renderer/src/RenderableZoneEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableZoneEntityItem.h
@ -1,7 +1,6 @@
 //
 //  RenderableZoneEntityItem.h
 //
-//
 //  Created by Clement on 4/22/15.
 //  Copyright 2015 High Fidelity, Inc.
 //
@ -15,10 +14,12 @@
 #include <ZoneEntityItem.h>
 #include <graphics/Skybox.h>
 #include <graphics/Haze.h>
+#include <graphics/Bloom.h>
 #include <graphics/Stage.h>
 #include <LightStage.h>
 #include <BackgroundStage.h>
 #include <HazeStage.h>
+#include <BloomStage.h>
 #include <TextureCache.h>
 #include "RenderableEntityItem.h"
 #include <ComponentMode.h>
@ -50,6 +51,7 @@ private:
    void updateAmbientLightFromEntity(const TypedEntityPointer& entity);
    void updateHazeFromEntity(const TypedEntityPointer& entity);
    void updateKeyBackgroundFromEntity(const TypedEntityPointer& entity);
+    void updateBloomFromEntity(const TypedEntityPointer& entity);
    void updateAmbientMap();
    void updateSkyboxMap();
    void setAmbientURL(const QString& ambientUrl);
@ -59,6 +61,7 @@ private:
    void setKeyLightMode(ComponentMode mode);
    void setAmbientLightMode(ComponentMode mode);
    void setSkyboxMode(ComponentMode mode);
+    void setBloomMode(ComponentMode mode);

    void setSkyboxColor(const glm::vec3& color);
    void setProceduralUserData(const QString& userData);
@ -68,6 +71,7 @@ private:
    graphics::SunSkyStagePointer editBackground() { _needBackgroundUpdate = true; return _background; }
    graphics::SkyboxPointer editSkybox() { return editBackground()->getSkybox(); }
    graphics::HazePointer editHaze() { _needHazeUpdate = true; return _haze; }
+    graphics::BloomPointer editBloom() { _needBloomUpdate = true; return _bloom; }

    glm::vec3 _lastPosition;
    glm::vec3 _lastDimensions;
@ -82,36 +86,43 @@ private:
 #endif

    LightStagePointer _stage;
-    const graphics::LightPointer _sunLight{ std::make_shared<graphics::Light>() };
-    const graphics::LightPointer _ambientLight{ std::make_shared<graphics::Light>() };
-    const graphics::SunSkyStagePointer _background{ std::make_shared<graphics::SunSkyStage>() };
-    const graphics::HazePointer _haze{ std::make_shared<graphics::Haze>() };
+    const graphics::LightPointer _sunLight { std::make_shared<graphics::Light>() };
+    const graphics::LightPointer _ambientLight { std::make_shared<graphics::Light>() };
+    const graphics::SunSkyStagePointer _background { std::make_shared<graphics::SunSkyStage>() };
+    const graphics::HazePointer _haze { std::make_shared<graphics::Haze>() };
+    const graphics::BloomPointer _bloom { std::make_shared<graphics::Bloom>() };

    ComponentMode _keyLightMode { COMPONENT_MODE_INHERIT };
    ComponentMode _ambientLightMode { COMPONENT_MODE_INHERIT };
    ComponentMode _skyboxMode { COMPONENT_MODE_INHERIT };
    ComponentMode _hazeMode { COMPONENT_MODE_INHERIT };
+    ComponentMode _bloomMode { COMPONENT_MODE_INHERIT };

-    indexed_container::Index _sunIndex{ LightStage::INVALID_INDEX };
-    indexed_container::Index _shadowIndex{ LightStage::INVALID_INDEX };
-    indexed_container::Index _ambientIndex{ LightStage::INVALID_INDEX };
+    indexed_container::Index _sunIndex { LightStage::INVALID_INDEX };
+    indexed_container::Index _shadowIndex { LightStage::INVALID_INDEX };
+    indexed_container::Index _ambientIndex { LightStage::INVALID_INDEX };

    BackgroundStagePointer _backgroundStage;
-    BackgroundStage::Index _backgroundIndex{ BackgroundStage::INVALID_INDEX };
+    BackgroundStage::Index _backgroundIndex { BackgroundStage::INVALID_INDEX };

    HazeStagePointer _hazeStage;
-    HazeStage::Index _hazeIndex{ HazeStage::INVALID_INDEX };
+    HazeStage::Index _hazeIndex { HazeStage::INVALID_INDEX };
+
+    BloomStagePointer _bloomStage;
+    BloomStage::Index _bloomIndex { BloomStage::INVALID_INDEX };

    bool _needUpdate{ true };
    bool _needSunUpdate{ true };
    bool _needAmbientUpdate{ true };
    bool _needBackgroundUpdate{ true };
    bool _needHazeUpdate{ true };
+    bool _needBloomUpdate { true };

    KeyLightPropertyGroup _keyLightProperties;
    AmbientLightPropertyGroup _ambientLightProperties;
    HazePropertyGroup _hazeProperties;
    SkyboxPropertyGroup _skyboxProperties;
+    BloomPropertyGroup _bloomProperties;

    // More attributes used for rendering:
    QString _ambientTextureURL;
--- a/libraries/entities/src/BloomPropertyGroup.cpp
+++ b/libraries/entities/src/BloomPropertyGroup.cpp
@ -0,0 +1,159 @@
+//
+//  BloomPropertyGroup.cpp
+//  libraries/entities/src
+//
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "BloomPropertyGroup.h"
+
+#include <OctreePacketData.h>
+
+#include "EntityItemProperties.h"
+#include "EntityItemPropertiesMacros.h"
+
+void BloomPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties, QScriptEngine* engine, bool skipDefaults, EntityItemProperties& defaultEntityProperties) const {
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_BLOOM_INTENSITY, Bloom, bloom, BloomIntensity, bloomIntensity);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_BLOOM_THRESHOLD, Bloom, bloom, BloomThreshold, bloomThreshold);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_BLOOM_SIZE, Bloom, bloom, BloomSize, bloomSize);
+}
+
+void BloomPropertyGroup::copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) {
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(bloom, bloomIntensity, float, setBloomIntensity);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(bloom, bloomThreshold, float, setBloomThreshold);
+    COPY_GROUP_PROPERTY_FROM_QSCRIPTVALUE(bloom, bloomSize, float, setBloomSize);
+}
+
+void BloomPropertyGroup::merge(const BloomPropertyGroup& other) {
+    COPY_PROPERTY_IF_CHANGED(bloomIntensity);
+    COPY_PROPERTY_IF_CHANGED(bloomThreshold);
+    COPY_PROPERTY_IF_CHANGED(bloomSize);
+}
+
+void BloomPropertyGroup::debugDump() const {
+    qCDebug(entities) << "   BloomPropertyGroup: ---------------------------------------------";
+    qCDebug(entities) << "      _bloomIntensity:" << _bloomIntensity;
+    qCDebug(entities) << "      _bloomThreshold:" << _bloomThreshold;
+    qCDebug(entities) << "           _bloomSize:" << _bloomSize;
+}
+
+void BloomPropertyGroup::listChangedProperties(QList<QString>& out) {
+    if (bloomIntensityChanged()) {
+        out << "bloom-bloomIntensity";
+    }
+    if (bloomThresholdChanged()) {
+        out << "bloom-bloomThreshold";
+    }
+    if (bloomSizeChanged()) {
+        out << "bloom-bloomSize";
+    }
+}
+
+bool BloomPropertyGroup::appendToEditPacket(OctreePacketData* packetData,
+                                            EntityPropertyFlags& requestedProperties,
+                                            EntityPropertyFlags& propertyFlags,
+                                            EntityPropertyFlags& propertiesDidntFit,
+                                            int& propertyCount, 
+                                            OctreeElement::AppendState& appendState) const {
+    bool successPropertyFits = true;
+
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_INTENSITY, getBloomIntensity());
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_THRESHOLD, getBloomThreshold());
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_SIZE, getBloomSize());
+
+    return true;
+}
+
+bool BloomPropertyGroup::decodeFromEditPacket(EntityPropertyFlags& propertyFlags, const unsigned char*& dataAt , int& processedBytes) {
+    int bytesRead = 0;
+    bool overwriteLocalData = true;
+    bool somethingChanged = false;
+
+    READ_ENTITY_PROPERTY(PROP_BLOOM_INTENSITY, float, setBloomIntensity);
+    READ_ENTITY_PROPERTY(PROP_BLOOM_THRESHOLD, float, setBloomThreshold);
+    READ_ENTITY_PROPERTY(PROP_BLOOM_SIZE, float, setBloomSize);
+
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_BLOOM_INTENSITY, BloomIntensity);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_BLOOM_THRESHOLD, BloomThreshold);
+    DECODE_GROUP_PROPERTY_HAS_CHANGED(PROP_BLOOM_SIZE, BloomSize);
+
+    processedBytes += bytesRead;
+
+    Q_UNUSED(somethingChanged);
+
+    return true;
+}
+
+void BloomPropertyGroup::markAllChanged() {
+    _bloomIntensityChanged = true;
+    _bloomThresholdChanged = true;
+    _bloomSizeChanged = true;
+}
+
+EntityPropertyFlags BloomPropertyGroup::getChangedProperties() const {
+    EntityPropertyFlags changedProperties;
+
+    CHECK_PROPERTY_CHANGE(PROP_BLOOM_INTENSITY, bloomIntensity);
+    CHECK_PROPERTY_CHANGE(PROP_BLOOM_THRESHOLD, bloomThreshold);
+    CHECK_PROPERTY_CHANGE(PROP_BLOOM_SIZE, bloomSize);
+
+    return changedProperties;
+}
+
+void BloomPropertyGroup::getProperties(EntityItemProperties& properties) const {
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Bloom, BloomIntensity, getBloomIntensity);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Bloom, BloomThreshold, getBloomThreshold);
+    COPY_ENTITY_GROUP_PROPERTY_TO_PROPERTIES(Bloom, BloomSize, getBloomSize);
+}
+
+bool BloomPropertyGroup::setProperties(const EntityItemProperties& properties) {
+    bool somethingChanged = false;
+
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Bloom, BloomIntensity, bloomIntensity, setBloomIntensity);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Bloom, BloomThreshold, bloomThreshold, setBloomThreshold);
+    SET_ENTITY_GROUP_PROPERTY_FROM_PROPERTIES(Bloom, BloomSize, bloomSize, setBloomSize);
+
+    return somethingChanged;
+}
+
+EntityPropertyFlags BloomPropertyGroup::getEntityProperties(EncodeBitstreamParams& params) const {
+    EntityPropertyFlags requestedProperties;
+
+    requestedProperties += PROP_BLOOM_INTENSITY;
+    requestedProperties += PROP_BLOOM_THRESHOLD;
+    requestedProperties += PROP_BLOOM_SIZE;
+
+    return requestedProperties;
+}
+    
+void BloomPropertyGroup::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                            EntityTreeElementExtraEncodeDataPointer entityTreeElementExtraEncodeData,
+                                            EntityPropertyFlags& requestedProperties,
+                                            EntityPropertyFlags& propertyFlags,
+                                            EntityPropertyFlags& propertiesDidntFit,
+                                            int& propertyCount, 
+                                            OctreeElement::AppendState& appendState) const {
+    bool successPropertyFits = true;
+
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_INTENSITY, getBloomIntensity());
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_THRESHOLD, getBloomThreshold());
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_SIZE, getBloomSize());
+}
+
+int BloomPropertyGroup::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                         ReadBitstreamToTreeParams& args,
+                                                         EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                         bool& somethingChanged) {
+    int bytesRead = 0;
+    const unsigned char* dataAt = data;
+
+    READ_ENTITY_PROPERTY(PROP_BLOOM_INTENSITY, float, setBloomIntensity);
+    READ_ENTITY_PROPERTY(PROP_BLOOM_THRESHOLD, float, setBloomThreshold);
+    READ_ENTITY_PROPERTY(PROP_BLOOM_SIZE, float, setBloomSize);
+
+    return bytesRead;
+}
--- a/libraries/entities/src/BloomPropertyGroup.h
+++ b/libraries/entities/src/BloomPropertyGroup.h
@ -0,0 +1,94 @@
+//
+//  BloomPropertyGroup.h
+//  libraries/entities/src
+//
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_BloomPropertyGroup_h
+#define hifi_BloomPropertyGroup_h
+
+#include <stdint.h>
+#include <glm/glm.hpp>
+
+#include <QtScript/QScriptEngine>
+
+#include "PropertyGroup.h"
+#include "EntityItemPropertiesMacros.h"
+
+class EntityItemProperties;
+class EncodeBitstreamParams;
+class OctreePacketData;
+class EntityTreeElementExtraEncodeData;
+class ReadBitstreamToTreeParams;
+
+static const float INITIAL_BLOOM_INTENSITY { 0.25f };
+static const float INITIAL_BLOOM_THRESHOLD { 0.7f };
+static const float INITIAL_BLOOM_SIZE { 0.9f };
+
+/**jsdoc
+ * Bloom is defined by the following properties.
+ * @typedef {object} Entities.Bloom
+ *
+ * @property {number} bloomIntensity=0.25 - The intensity of the bloom effect.
+ * @property {number} bloomThreshold=0.7 - The threshold for the bloom effect.
+ * @property {number} bloomSize=0.9 - The size of the bloom effect.
+ */
+class BloomPropertyGroup : public PropertyGroup {
+public:
+    // EntityItemProperty related helpers
+    virtual void copyToScriptValue(const EntityPropertyFlags& desiredProperties, QScriptValue& properties,
+                                   QScriptEngine* engine, bool skipDefaults,
+                                   EntityItemProperties& defaultEntityProperties) const override;
+    virtual void copyFromScriptValue(const QScriptValue& object, bool& _defaultSettings) override;
+
+    void merge(const BloomPropertyGroup& other);
+
+    virtual void debugDump() const override;
+    virtual void listChangedProperties(QList<QString>& out) override;
+
+    virtual bool appendToEditPacket(OctreePacketData* packetData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount,
+                                    OctreeElement::AppendState& appendState) const override;
+
+    virtual bool decodeFromEditPacket(EntityPropertyFlags& propertyFlags,
+                                      const unsigned char*& dataAt, int& processedBytes) override;
+    virtual void markAllChanged() override;
+    virtual EntityPropertyFlags getChangedProperties() const override;
+
+    // EntityItem related helpers
+    // methods for getting/setting all properties of an entity
+    virtual void getProperties(EntityItemProperties& propertiesOut) const override;
+
+    /// returns true if something changed
+    virtual bool setProperties(const EntityItemProperties& properties) override;
+
+    virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const override;
+
+    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                    EntityTreeElementExtraEncodeDataPointer entityTreeElementExtraEncodeData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount,
+                                    OctreeElement::AppendState& appendState) const override;
+
+    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                ReadBitstreamToTreeParams& args,
+                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                bool& somethingChanged) override;
+
+    DEFINE_PROPERTY(PROP_BLOOM_INTENSITY, BloomIntensity, bloomIntensity, float, INITIAL_BLOOM_INTENSITY);
+    DEFINE_PROPERTY(PROP_BLOOM_THRESHOLD, BloomThreshold, bloomThreshold, float, INITIAL_BLOOM_THRESHOLD);
+    DEFINE_PROPERTY(PROP_BLOOM_SIZE, BloomSize, bloomSize, float, INITIAL_BLOOM_SIZE);
+
+};
+
+#endif // hifi_BloomPropertyGroup_h
--- a/libraries/entities/src/EntityItemProperties.cpp
+++ b/libraries/entities/src/EntityItemProperties.cpp
@ -37,6 +37,7 @@
 AnimationPropertyGroup EntityItemProperties::_staticAnimation;
 SkyboxPropertyGroup EntityItemProperties::_staticSkybox;
 HazePropertyGroup EntityItemProperties::_staticHaze;
+BloomPropertyGroup EntityItemProperties::_staticBloom;
 KeyLightPropertyGroup EntityItemProperties::_staticKeyLight;
 AmbientLightPropertyGroup EntityItemProperties::_staticAmbientLight;

@ -84,6 +85,7 @@ void EntityItemProperties::debugDump() const {
    getHaze().debugDump();
    getKeyLight().debugDump();
    getAmbientLight().debugDump();
+    getBloom().debugDump();

    qCDebug(entities) << "   changed properties...";
    EntityPropertyFlags props = getChangedProperties();
@ -211,6 +213,10 @@ QString EntityItemProperties::getHazeModeAsString() const {
    return getComponentModeAsString(_hazeMode);
 }

+QString EntityItemProperties::getBloomModeAsString() const {
+    return getComponentModeAsString(_bloomMode);
+}
+
 QString EntityItemProperties::getComponentModeString(uint32_t mode) {
    // return "inherit" if mode is not valid
    if (mode < COMPONENT_MODE_ITEM_COUNT) {
@ -235,6 +241,15 @@ void EntityItemProperties::setHazeModeFromString(const QString& hazeMode) {
    }
 }

+void EntityItemProperties::setBloomModeFromString(const QString& bloomMode) {
+    auto result = findComponent(bloomMode);
+
+    if (result != COMPONENT_MODES.end()) {
+        _bloomMode = result->first;
+        _bloomModeChanged = true;
+    }
+}
+
 QString EntityItemProperties::getKeyLightModeAsString() const {
    return getComponentModeAsString(_keyLightMode);
 }
@ -394,6 +409,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
    CHECK_PROPERTY_CHANGE(PROP_KEY_LIGHT_MODE, keyLightMode);
    CHECK_PROPERTY_CHANGE(PROP_AMBIENT_LIGHT_MODE, ambientLightMode);
    CHECK_PROPERTY_CHANGE(PROP_SKYBOX_MODE, skyboxMode);
+    CHECK_PROPERTY_CHANGE(PROP_BLOOM_MODE, bloomMode);

    CHECK_PROPERTY_CHANGE(PROP_SOURCE_URL, sourceUrl);
    CHECK_PROPERTY_CHANGE(PROP_VOXEL_VOLUME_SIZE, voxelVolumeSize);
@ -454,6 +470,7 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
    changedProperties += _ambientLight.getChangedProperties();
    changedProperties += _skybox.getChangedProperties();
    changedProperties += _haze.getChangedProperties();
+    changedProperties += _bloom.getChangedProperties();

    return changedProperties;
 }
@ -1164,6 +1181,12 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
 *     <code>"enabled"</code>: The haze properties of this zone are enabled, overriding the haze from any enclosing zone.
 * @property {Entities.Haze} haze - The haze properties of the zone.
 *
+ * @property {string} bloomMode="inherit" - Configures the bloom in the zone. Possible values:<br />
+ *     <code>"inherit"</code>: The bloom from any enclosing zone continues into this zone.<br />
+ *     <code>"disabled"</code>: The bloom from any enclosing zone and the bloom of this zone are disabled in this zone.<br />
+ *     <code>"enabled"</code>: The bloom properties of this zone are enabled, overriding the bloom from any enclosing zone.
+ * @property {Entities.Bloom} bloom - The bloom properties of the zone.
+ *
 * @property {boolean} flyingAllowed=true - If <code>true</code> then visitors can fly in the zone; otherwise they cannot.
 * @property {boolean} ghostingAllowed=true - If <code>true</code> then visitors with avatar collisions turned off will not 
 *     collide with content in the zone; otherwise visitors will always collide with content in the zone.
@ -1382,6 +1405,9 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_HAZE_MODE, hazeMode, getHazeModeAsString());
        _haze.copyToScriptValue(_desiredProperties, properties, engine, skipDefaults, defaultEntityProperties);

+        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_BLOOM_MODE, bloomMode, getBloomModeAsString());
+        _bloom.copyToScriptValue(_desiredProperties, properties, engine, skipDefaults, defaultEntityProperties);
+
        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_KEY_LIGHT_MODE, keyLightMode, getKeyLightModeAsString());
        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_AMBIENT_LIGHT_MODE, ambientLightMode, getAmbientLightModeAsString());
        COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_SKYBOX_MODE, skyboxMode, getSkyboxModeAsString());
@ -1630,6 +1656,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
    COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(keyLightMode, KeyLightMode);
    COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(ambientLightMode, AmbientLightMode);
    COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(skyboxMode, SkyboxMode);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(bloomMode, BloomMode);

    COPY_PROPERTY_FROM_QSCRIPTVALUE(sourceUrl, QString, setSourceUrl);
    COPY_PROPERTY_FROM_QSCRIPTVALUE(voxelVolumeSize, vec3, setVoxelVolumeSize);
@ -1662,6 +1689,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
    _ambientLight.copyFromScriptValue(object, _defaultSettings);
    _skybox.copyFromScriptValue(object, _defaultSettings);
    _haze.copyFromScriptValue(object, _defaultSettings);
+    _bloom.copyFromScriptValue(object, _defaultSettings);

    COPY_PROPERTY_FROM_QSCRIPTVALUE(xTextureURL, QString, setXTextureURL);
    COPY_PROPERTY_FROM_QSCRIPTVALUE(yTextureURL, QString, setYTextureURL);
@ -1803,6 +1831,7 @@ void EntityItemProperties::merge(const EntityItemProperties& other) {
    COPY_PROPERTY_IF_CHANGED(keyLightMode);
    COPY_PROPERTY_IF_CHANGED(ambientLightMode);
    COPY_PROPERTY_IF_CHANGED(skyboxMode);
+    COPY_PROPERTY_IF_CHANGED(bloomMode);

    COPY_PROPERTY_IF_CHANGED(sourceUrl);
    COPY_PROPERTY_IF_CHANGED(voxelVolumeSize);
@ -1825,6 +1854,7 @@ void EntityItemProperties::merge(const EntityItemProperties& other) {
    _ambientLight.merge(other._ambientLight);
    _skybox.merge(other._skybox);
    _haze.merge(other._haze);
+    _bloom.merge(other._bloom);

    COPY_PROPERTY_IF_CHANGED(xTextureURL);
    COPY_PROPERTY_IF_CHANGED(yTextureURL);
@ -2096,6 +2126,11 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
        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_PROPERTY_TO_MAP(PROP_BLOOM_MODE, BloomMode, bloomMode, uint32_t);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_BLOOM_INTENSITY, Bloom, bloom, BloomIntensity, bloomIntensity);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_BLOOM_THRESHOLD, Bloom, bloom, BloomThreshold, bloomThreshold);
+        ADD_GROUP_PROPERTY_TO_MAP(PROP_BLOOM_SIZE, Bloom, bloom, BloomSize, bloomSize);
+
        ADD_PROPERTY_TO_MAP(PROP_KEY_LIGHT_MODE, KeyLightMode, keyLightMode, uint32_t);
        ADD_PROPERTY_TO_MAP(PROP_AMBIENT_LIGHT_MODE, AmbientLightMode, ambientLightMode, uint32_t);
        ADD_PROPERTY_TO_MAP(PROP_SKYBOX_MODE, SkyboxMode, skyboxMode, uint32_t);
@ -2357,6 +2392,10 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
                _staticHaze.setProperties(properties);
                _staticHaze.appendToEditPacket(packetData, requestedProperties, propertyFlags, propertiesDidntFit, propertyCount, appendState);

+                APPEND_ENTITY_PROPERTY(PROP_BLOOM_MODE, (uint32_t)properties.getBloomMode());
+                _staticBloom.setProperties(properties);
+                _staticBloom.appendToEditPacket(packetData, requestedProperties, propertyFlags, propertiesDidntFit, propertyCount, appendState);
+
                APPEND_ENTITY_PROPERTY(PROP_KEY_LIGHT_MODE, (uint32_t)properties.getKeyLightMode());
                APPEND_ENTITY_PROPERTY(PROP_AMBIENT_LIGHT_MODE, (uint32_t)properties.getAmbientLightMode());
                APPEND_ENTITY_PROPERTY(PROP_SKYBOX_MODE, (uint32_t)properties.getSkyboxMode());
@ -2731,6 +2770,9 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_HAZE_MODE, uint32_t, setHazeMode);
        properties.getHaze().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);

+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_BLOOM_MODE, uint32_t, setBloomMode);
+        properties.getBloom().decodeFromEditPacket(propertyFlags, dataAt, processedBytes);
+
        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_KEY_LIGHT_MODE, uint32_t, setKeyLightMode);
        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_AMBIENT_LIGHT_MODE, uint32_t, setAmbientLightMode);
        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SKYBOX_MODE, uint32_t, setSkyboxMode);
@ -3044,10 +3086,12 @@ void EntityItemProperties::markAllChanged() {
    _skyboxModeChanged = true;
    _ambientLightModeChanged = true;
    _hazeModeChanged = true;
+    _bloomModeChanged = true;

    _animation.markAllChanged();
    _skybox.markAllChanged();
    _haze.markAllChanged();
+    _bloom.markAllChanged();

    _sourceUrlChanged = true;
    _voxelVolumeSizeChanged = true;
@ -3442,15 +3486,15 @@ QList<QString> EntityItemProperties::listChangedProperties() {
    if (hazeModeChanged()) {
        out += "hazeMode";
    }
-
+    if (bloomModeChanged()) {
+        out += "bloomMode";
+    }
    if (keyLightModeChanged()) {
        out += "keyLightMode";
    }
-
    if (ambientLightModeChanged()) {
        out += "ambientLightMode";
    }
-
    if (skyboxModeChanged()) {
        out += "skyboxMode";
    }
@ -3581,6 +3625,7 @@ QList<QString> EntityItemProperties::listChangedProperties() {
    getAmbientLight().listChangedProperties(out);
    getSkybox().listChangedProperties(out);
    getHaze().listChangedProperties(out);
+    getBloom().listChangedProperties(out);

    return out;
 }
--- a/libraries/entities/src/EntityItemProperties.h
+++ b/libraries/entities/src/EntityItemProperties.h
@ -42,6 +42,7 @@
 #include "SimulationOwner.h"
 #include "SkyboxPropertyGroup.h"
 #include "HazePropertyGroup.h"
+#include "BloomPropertyGroup.h"
 #include "TextEntityItem.h"
 #include "ZoneEntityItem.h"

@ -195,9 +196,11 @@ public:
    DEFINE_PROPERTY_REF_ENUM(PROP_SKYBOX_MODE, SkyboxMode, skyboxMode, uint32_t, (uint32_t)COMPONENT_MODE_INHERIT);
    DEFINE_PROPERTY_REF_ENUM(PROP_AMBIENT_LIGHT_MODE, AmbientLightMode, ambientLightMode, uint32_t, (uint32_t)COMPONENT_MODE_INHERIT);
    DEFINE_PROPERTY_REF_ENUM(PROP_HAZE_MODE, HazeMode, hazeMode, uint32_t, (uint32_t)COMPONENT_MODE_INHERIT);
+    DEFINE_PROPERTY_REF_ENUM(PROP_BLOOM_MODE, BloomMode, bloomMode, uint32_t, (uint32_t)COMPONENT_MODE_INHERIT);

    DEFINE_PROPERTY_GROUP(Skybox, skybox, SkyboxPropertyGroup);
    DEFINE_PROPERTY_GROUP(Haze, haze, HazePropertyGroup);
+    DEFINE_PROPERTY_GROUP(Bloom, bloom, BloomPropertyGroup);
    DEFINE_PROPERTY_GROUP(Animation, animation, AnimationPropertyGroup);
    DEFINE_PROPERTY_REF(PROP_SOURCE_URL, SourceUrl, sourceUrl, QString, "");
    DEFINE_PROPERTY(PROP_LINE_WIDTH, LineWidth, lineWidth, float, LineEntityItem::DEFAULT_LINE_WIDTH);
@ -533,6 +536,7 @@ inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) {
    DEBUG_PROPERTY_IF_CHANGED(debug, properties, KeyLightMode, keyLightMode, "");
    DEBUG_PROPERTY_IF_CHANGED(debug, properties, AmbientLightMode, ambientLightMode, "");
    DEBUG_PROPERTY_IF_CHANGED(debug, properties, SkyboxMode, skyboxMode, "");
+    DEBUG_PROPERTY_IF_CHANGED(debug, properties, BloomMode, bloomMode, "");

    DEBUG_PROPERTY_IF_CHANGED(debug, properties, Cloneable, cloneable, "");
    DEBUG_PROPERTY_IF_CHANGED(debug, properties, CloneLifetime, cloneLifetime, "");
--- a/libraries/entities/src/EntityPropertyFlags.h
+++ b/libraries/entities/src/EntityPropertyFlags.h
@ -257,6 +257,11 @@ enum EntityPropertyList {
    PROP_SPIN_SPREAD,
    PROP_PARTICLE_ROTATE_WITH_ENTITY,

+    PROP_BLOOM_MODE,
+    PROP_BLOOM_INTENSITY,
+    PROP_BLOOM_THRESHOLD,
+    PROP_BLOOM_SIZE,
+
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    // ATTENTION: add new properties to end of list just ABOVE this line
    PROP_AFTER_LAST_ITEM,
--- a/libraries/entities/src/ZoneEntityItem.cpp
+++ b/libraries/entities/src/ZoneEntityItem.cpp
@ -47,33 +47,27 @@ ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID) : EntityItem(en
 EntityItemProperties ZoneEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
    EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class

-    // Contains a QString property, must be synchronized
+    // Contain QString properties, must be synchronized
    withReadLock([&] {
        _keyLightProperties.getProperties(properties);
-    });
-
-    withReadLock([&] {
        _ambientLightProperties.getProperties(properties);
+        _skyboxProperties.getProperties(properties);
    });
+    _hazeProperties.getProperties(properties);
+    _bloomProperties.getProperties(properties);

    COPY_ENTITY_PROPERTY_TO_PROPERTIES(shapeType, getShapeType);
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(compoundShapeURL, getCompoundShapeURL);

-    // Contains a QString property, must be synchronized
-    withReadLock([&] {
-        _skyboxProperties.getProperties(properties);
-    });
-
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(flyingAllowed, getFlyingAllowed);
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(ghostingAllowed, getGhostingAllowed);
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(filterURL, getFilterURL);

    COPY_ENTITY_PROPERTY_TO_PROPERTIES(hazeMode, getHazeMode);
-    _hazeProperties.getProperties(properties);
-
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(keyLightMode, getKeyLightMode);
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(ambientLightMode, getAmbientLightMode);
    COPY_ENTITY_PROPERTY_TO_PROPERTIES(skyboxMode, getSkyboxMode);
+    COPY_ENTITY_PROPERTY_TO_PROPERTIES(bloomMode, getBloomMode);

    return properties;
 }
@ -102,32 +96,27 @@ bool ZoneEntityItem::setSubClassProperties(const EntityItemProperties& propertie
    // Contains a QString property, must be synchronized
    withWriteLock([&] {
        _keyLightPropertiesChanged = _keyLightProperties.setProperties(properties);
-    });
-    withWriteLock([&] {
        _ambientLightPropertiesChanged = _ambientLightProperties.setProperties(properties);
+        _skyboxPropertiesChanged = _skyboxProperties.setProperties(properties);
    });
+    _hazePropertiesChanged = _hazeProperties.setProperties(properties);
+    _bloomPropertiesChanged = _bloomProperties.setProperties(properties);

    SET_ENTITY_PROPERTY_FROM_PROPERTIES(shapeType, setShapeType);
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(compoundShapeURL, setCompoundShapeURL);

-    // Contains a QString property, must be synchronized
-    withWriteLock([&] {
-        _skyboxPropertiesChanged = _skyboxProperties.setProperties(properties);
-    });
-
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(flyingAllowed, setFlyingAllowed);
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(ghostingAllowed, setGhostingAllowed);
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(filterURL, setFilterURL);

    SET_ENTITY_PROPERTY_FROM_PROPERTIES(hazeMode, setHazeMode);
-    _hazePropertiesChanged = _hazeProperties.setProperties(properties);
-
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(keyLightMode, setKeyLightMode);
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(ambientLightMode, setAmbientLightMode);
    SET_ENTITY_PROPERTY_FROM_PROPERTIES(skyboxMode, setSkyboxMode);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(bloomMode, setBloomMode);

    somethingChanged = somethingChanged || _keyLightPropertiesChanged || _ambientLightPropertiesChanged ||
-        _stagePropertiesChanged || _skyboxPropertiesChanged || _hazePropertiesChanged;
+        _stagePropertiesChanged || _skyboxPropertiesChanged || _hazePropertiesChanged || _bloomPropertiesChanged;

    return somethingChanged;
 }
@ -139,54 +128,67 @@ int ZoneEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data,
    int bytesRead = 0;
    const unsigned char* dataAt = data;

-    int bytesFromKeylight;
-    withWriteLock([&] {
-        bytesFromKeylight = _keyLightProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
-            propertyFlags, overwriteLocalData, _keyLightPropertiesChanged);
-    });
+    {
+        int bytesFromKeylight;
+        withWriteLock([&] {
+            bytesFromKeylight = _keyLightProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+                propertyFlags, overwriteLocalData, _keyLightPropertiesChanged);
+        });
+        somethingChanged = somethingChanged || _keyLightPropertiesChanged;
+        bytesRead += bytesFromKeylight;
+        dataAt += bytesFromKeylight;
+    }

-    somethingChanged = somethingChanged || _keyLightPropertiesChanged;
-    bytesRead += bytesFromKeylight;
-    dataAt += bytesFromKeylight;
+    {
+        int bytesFromAmbientlight;
+        withWriteLock([&] {
+            bytesFromAmbientlight = _ambientLightProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+                propertyFlags, overwriteLocalData, _ambientLightPropertiesChanged);
+        });
+        somethingChanged = somethingChanged || _ambientLightPropertiesChanged;
+        bytesRead += bytesFromAmbientlight;
+        dataAt += bytesFromAmbientlight;
+    }

-    int bytesFromAmbientlight;
-    withWriteLock([&] {
-        bytesFromAmbientlight = _ambientLightProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
-            propertyFlags, overwriteLocalData, _ambientLightPropertiesChanged);
-    });
+    {
+        int bytesFromSkybox;
+        withWriteLock([&] {
+            bytesFromSkybox = _skyboxProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+                propertyFlags, overwriteLocalData, _skyboxPropertiesChanged);
+        });
+        somethingChanged = somethingChanged || _skyboxPropertiesChanged;
+        bytesRead += bytesFromSkybox;
+        dataAt += bytesFromSkybox;
+    }

-    somethingChanged = somethingChanged || _ambientLightPropertiesChanged;
-    bytesRead += bytesFromAmbientlight;
-    dataAt += bytesFromAmbientlight;
+    {
+        int bytesFromHaze = _hazeProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+            propertyFlags, overwriteLocalData, _hazePropertiesChanged);
+        somethingChanged = somethingChanged || _hazePropertiesChanged;
+        bytesRead += bytesFromHaze;
+        dataAt += bytesFromHaze;
+    }
+
+    {
+        int bytesFromBloom = _bloomProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
+            propertyFlags, overwriteLocalData, _bloomPropertiesChanged);
+        somethingChanged = somethingChanged || _bloomPropertiesChanged;
+        bytesRead += bytesFromBloom;
+        dataAt += bytesFromBloom;
+    }

    READ_ENTITY_PROPERTY(PROP_SHAPE_TYPE, ShapeType, setShapeType);
    READ_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, QString, setCompoundShapeURL);

-    int bytesFromSkybox;
-    withWriteLock([&] {
-        bytesFromSkybox = _skyboxProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
-            propertyFlags, overwriteLocalData, _skyboxPropertiesChanged);
-    });
-    somethingChanged = somethingChanged || _skyboxPropertiesChanged;
-    bytesRead += bytesFromSkybox;
-    dataAt += bytesFromSkybox;
-
    READ_ENTITY_PROPERTY(PROP_FLYING_ALLOWED, bool, setFlyingAllowed);
    READ_ENTITY_PROPERTY(PROP_GHOSTING_ALLOWED, bool, setGhostingAllowed);
    READ_ENTITY_PROPERTY(PROP_FILTER_URL, QString, setFilterURL);

    READ_ENTITY_PROPERTY(PROP_HAZE_MODE, uint32_t, setHazeMode);
-
-    int bytesFromHaze = _hazeProperties.readEntitySubclassDataFromBuffer(dataAt, (bytesLeftToRead - bytesRead), args,
-        propertyFlags, overwriteLocalData, _hazePropertiesChanged);
-
-    somethingChanged = somethingChanged || _hazePropertiesChanged;
-    bytesRead += bytesFromHaze;
-    dataAt += bytesFromHaze;
-
    READ_ENTITY_PROPERTY(PROP_KEY_LIGHT_MODE, uint32_t, setKeyLightMode);
    READ_ENTITY_PROPERTY(PROP_AMBIENT_LIGHT_MODE, uint32_t, setAmbientLightMode);
    READ_ENTITY_PROPERTY(PROP_SKYBOX_MODE, uint32_t, setSkyboxMode);
+    READ_ENTITY_PROPERTY(PROP_BLOOM_MODE, uint32_t, setBloomMode);

    return bytesRead;
 }
@ -196,29 +198,24 @@ EntityPropertyFlags ZoneEntityItem::getEntityProperties(EncodeBitstreamParams& p

    withReadLock([&] {
        requestedProperties += _keyLightProperties.getEntityProperties(params);
-    });
-
-    withReadLock([&] {
        requestedProperties += _ambientLightProperties.getEntityProperties(params);
+        requestedProperties += _skyboxProperties.getEntityProperties(params);
    });
+    requestedProperties += _hazeProperties.getEntityProperties(params);
+    requestedProperties += _bloomProperties.getEntityProperties(params);

    requestedProperties += PROP_SHAPE_TYPE;
    requestedProperties += PROP_COMPOUND_SHAPE_URL;

-    withReadLock([&] {
-        requestedProperties += _skyboxProperties.getEntityProperties(params);
-    });
-
    requestedProperties += PROP_FLYING_ALLOWED;
    requestedProperties += PROP_GHOSTING_ALLOWED;
    requestedProperties += PROP_FILTER_URL;

    requestedProperties += PROP_HAZE_MODE;
-    requestedProperties += _hazeProperties.getEntityProperties(params);
-
    requestedProperties += PROP_KEY_LIGHT_MODE;
    requestedProperties += PROP_AMBIENT_LIGHT_MODE;
    requestedProperties += PROP_SKYBOX_MODE;
+    requestedProperties += PROP_BLOOM_MODE;

    return requestedProperties;
 }
@ -235,44 +232,46 @@ void ZoneEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits

    _keyLightProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
        propertyFlags, propertiesDidntFit, propertyCount, appendState);
-
    _ambientLightProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
        propertyFlags, propertiesDidntFit, propertyCount, appendState);
+    _skyboxProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
+        propertyFlags, propertiesDidntFit, propertyCount, appendState);
+    _hazeProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
+        propertyFlags, propertiesDidntFit, propertyCount, appendState);
+    _bloomProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
+        propertyFlags, propertiesDidntFit, propertyCount, appendState);

    APPEND_ENTITY_PROPERTY(PROP_SHAPE_TYPE, (uint32_t)getShapeType());
    APPEND_ENTITY_PROPERTY(PROP_COMPOUND_SHAPE_URL, getCompoundShapeURL());

-    _skyboxProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
-        propertyFlags, propertiesDidntFit, propertyCount, appendState);
-
    APPEND_ENTITY_PROPERTY(PROP_FLYING_ALLOWED, getFlyingAllowed());
    APPEND_ENTITY_PROPERTY(PROP_GHOSTING_ALLOWED, getGhostingAllowed());
    APPEND_ENTITY_PROPERTY(PROP_FILTER_URL, getFilterURL());

    APPEND_ENTITY_PROPERTY(PROP_HAZE_MODE, (uint32_t)getHazeMode());
-    _hazeProperties.appendSubclassData(packetData, params, modelTreeElementExtraEncodeData, requestedProperties,
-        propertyFlags, propertiesDidntFit, propertyCount, appendState);
-
    APPEND_ENTITY_PROPERTY(PROP_KEY_LIGHT_MODE, (uint32_t)getKeyLightMode());
    APPEND_ENTITY_PROPERTY(PROP_AMBIENT_LIGHT_MODE, (uint32_t)getAmbientLightMode());
    APPEND_ENTITY_PROPERTY(PROP_SKYBOX_MODE, (uint32_t)getSkyboxMode());
+    APPEND_ENTITY_PROPERTY(PROP_BLOOM_MODE, (uint32_t)getBloomMode());
 }

 void ZoneEntityItem::debugDump() const {
    quint64 now = usecTimestampNow();
    qCDebug(entities) << "   ZoneEntityItem id:" << getEntityItemID() << "---------------------------------------------";
-    qCDebug(entities) << "                  position:" << debugTreeVector(getWorldPosition());
-    qCDebug(entities) << "                dimensions:" << debugTreeVector(getScaledDimensions());
-    qCDebug(entities) << "             getLastEdited:" << debugTime(getLastEdited(), now);
-    qCDebug(entities) << "               _hazeMode:" << EntityItemProperties::getComponentModeString(_hazeMode);
-    qCDebug(entities) << "               _keyLightMode:" << EntityItemProperties::getComponentModeString(_keyLightMode);
-    qCDebug(entities) << "               _ambientLightMode:" << EntityItemProperties::getComponentModeString(_ambientLightMode);
-    qCDebug(entities) << "               _skyboxMode:" << EntityItemProperties::getComponentModeString(_skyboxMode);
+    qCDebug(entities) << "            position:" << debugTreeVector(getWorldPosition());
+    qCDebug(entities) << "          dimensions:" << debugTreeVector(getScaledDimensions());
+    qCDebug(entities) << "       getLastEdited:" << debugTime(getLastEdited(), now);
+    qCDebug(entities) << "           _hazeMode:" << EntityItemProperties::getComponentModeString(_hazeMode);
+    qCDebug(entities) << "       _keyLightMode:" << EntityItemProperties::getComponentModeString(_keyLightMode);
+    qCDebug(entities) << "   _ambientLightMode:" << EntityItemProperties::getComponentModeString(_ambientLightMode);
+    qCDebug(entities) << "         _skyboxMode:" << EntityItemProperties::getComponentModeString(_skyboxMode);
+    qCDebug(entities) << "          _bloomMode:" << EntityItemProperties::getComponentModeString(_bloomMode);

    _keyLightProperties.debugDump();
    _ambientLightProperties.debugDump();
    _skyboxProperties.debugDump();
    _hazeProperties.debugDump();
+    _bloomProperties.debugDump();
 }

 ShapeType ZoneEntityItem::getShapeType() const {
@ -344,6 +343,7 @@ void ZoneEntityItem::resetRenderingPropertiesChanged() {
        _ambientLightPropertiesChanged = false;
        _skyboxPropertiesChanged = false;
        _hazePropertiesChanged = false;
+        _bloomPropertiesChanged = false;
        _stagePropertiesChanged = false;
    });
 }
@ -359,6 +359,17 @@ uint32_t ZoneEntityItem::getHazeMode() const {
    return _hazeMode;
 }

+void ZoneEntityItem::setBloomMode(const uint32_t value) {
+    if (value < COMPONENT_MODE_ITEM_COUNT && value != _bloomMode) {
+        _bloomMode = value;
+        _bloomPropertiesChanged = true;
+    }
+}
+
+uint32_t ZoneEntityItem::getBloomMode() const {
+    return _bloomMode;
+}
+
 void ZoneEntityItem::setKeyLightMode(const uint32_t value) {
    if (value < COMPONENT_MODE_ITEM_COUNT && value != _keyLightMode) {
        _keyLightMode = value;
--- a/libraries/entities/src/ZoneEntityItem.h
+++ b/libraries/entities/src/ZoneEntityItem.h
@ -18,6 +18,7 @@
 #include "EntityTree.h"
 #include "SkyboxPropertyGroup.h"
 #include "HazePropertyGroup.h"
+#include "BloomPropertyGroup.h"
 #include <ComponentMode.h>

 class ZoneEntityItem : public EntityItem {
@ -79,9 +80,13 @@ public:
    void setSkyboxMode(uint32_t value);
    uint32_t getSkyboxMode() const;

+    void setBloomMode(const uint32_t value);
+    uint32_t getBloomMode() const;
+
    SkyboxPropertyGroup getSkyboxProperties() const { return resultWithReadLock<SkyboxPropertyGroup>([&] { return _skyboxProperties; }); }
    
    const HazePropertyGroup& getHazeProperties() const { return _hazeProperties; }
+    const BloomPropertyGroup& getBloomProperties() const { return _bloomProperties; }

    bool getFlyingAllowed() const { return _flyingAllowed; }
    void setFlyingAllowed(bool value) { _flyingAllowed = value; }
@ -93,10 +98,8 @@ public:
    bool keyLightPropertiesChanged() const { return _keyLightPropertiesChanged; }
    bool ambientLightPropertiesChanged() const { return _ambientLightPropertiesChanged; }
    bool skyboxPropertiesChanged() const { return _skyboxPropertiesChanged; }
-
-    bool hazePropertiesChanged() const { 
-        return _hazePropertiesChanged; 
-    }
+    bool hazePropertiesChanged() const { return _hazePropertiesChanged; }
+    bool bloomPropertiesChanged() const { return _bloomPropertiesChanged; }

    bool stagePropertiesChanged() const { return _stagePropertiesChanged; }

@ -133,9 +136,11 @@ protected:
    uint32_t _ambientLightMode { COMPONENT_MODE_INHERIT };

    uint32_t _hazeMode { COMPONENT_MODE_INHERIT };
+    uint32_t _bloomMode { COMPONENT_MODE_INHERIT };

    SkyboxPropertyGroup _skyboxProperties;
    HazePropertyGroup _hazeProperties;
+    BloomPropertyGroup _bloomProperties;

    bool _flyingAllowed { DEFAULT_FLYING_ALLOWED };
    bool _ghostingAllowed { DEFAULT_GHOSTING_ALLOWED };
@ -146,6 +151,7 @@ protected:
    bool _ambientLightPropertiesChanged { false };
    bool _skyboxPropertiesChanged { false };
    bool _hazePropertiesChanged{ false };
+    bool _bloomPropertiesChanged { false };
    bool _stagePropertiesChanged { false };

    static bool _drawZoneBoundaries;
--- a/libraries/graphics/src/graphics/Bloom.cpp
+++ b/libraries/graphics/src/graphics/Bloom.cpp
@ -0,0 +1,18 @@
+//
+//  Bloom.cpp
+//  libraries/graphics/src/graphics
+//
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "Bloom.h"
+
+using namespace graphics;
+
+const float Bloom::INITIAL_BLOOM_INTENSITY { 0.25f };
+const float Bloom::INITIAL_BLOOM_THRESHOLD { 0.7f };
+const float Bloom::INITIAL_BLOOM_SIZE { 0.9f };
--- a/libraries/graphics/src/graphics/Bloom.h
+++ b/libraries/graphics/src/graphics/Bloom.h
@ -0,0 +1,41 @@
+//
+//  Bloom.h
+//  libraries/graphics/src/graphics
+//
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#ifndef hifi_model_Bloom_h
+#define hifi_model_Bloom_h
+
+#include <memory>
+
+namespace graphics {
+    class Bloom {
+    public:
+        // Initial values
+        static const float INITIAL_BLOOM_INTENSITY;
+        static const float INITIAL_BLOOM_THRESHOLD;
+        static const float INITIAL_BLOOM_SIZE;
+
+        Bloom() {}
+
+        void setBloomIntensity(const float bloomIntensity) { _bloomIntensity = bloomIntensity; }
+        void setBloomThreshold(const float bloomThreshold) { _bloomThreshold = bloomThreshold; }
+        void setBloomSize(const float bloomSize) { _bloomSize = bloomSize; }
+
+        float getBloomIntensity() { return _bloomIntensity; }
+        float getBloomThreshold() { return _bloomThreshold; }
+        float getBloomSize() { return _bloomSize; }
+
+    private:
+        float _bloomIntensity { INITIAL_BLOOM_INTENSITY };
+        float _bloomThreshold {INITIAL_BLOOM_THRESHOLD };
+        float _bloomSize { INITIAL_BLOOM_SIZE };
+    };
+    using BloomPointer = std::shared_ptr<Bloom>;
+}
+#endif // hifi_model_Bloom_h
--- a/libraries/networking/src/udt/PacketHeaders.cpp
+++ b/libraries/networking/src/udt/PacketHeaders.cpp
@ -33,7 +33,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
        case PacketType::EntityEdit:
        case PacketType::EntityData:
        case PacketType::EntityPhysics:
-            return static_cast<PacketVersion>(EntityVersion::ParticleSpin);
+            return static_cast<PacketVersion>(EntityVersion::BloomEffect);
        case PacketType::EntityQuery:
            return static_cast<PacketVersion>(EntityQueryPacketVersion::ConicalFrustums);
        case PacketType::AvatarIdentity:
--- a/libraries/networking/src/udt/PacketHeaders.h
+++ b/libraries/networking/src/udt/PacketHeaders.h
@ -241,7 +241,8 @@ enum class EntityVersion : PacketVersion {
    CollisionMask16Bytes,
    YieldSimulationOwnership,
    ParticleEntityFix,
-    ParticleSpin
+    ParticleSpin,
+    BloomEffect
 };

 enum class EntityScriptCallMethodVersion : PacketVersion {
--- a/libraries/render-utils/src/BloomEffect.cpp
+++ b/libraries/render-utils/src/BloomEffect.cpp
@ -25,11 +25,7 @@ BloomThreshold::BloomThreshold(unsigned int downsamplingFactor) {
    _parameters.edit()._sampleCount = downsamplingFactor;
 }

-void BloomThreshold::configure(const Config& config) {
-    if (_parameters.get()._threshold != config.threshold) {
-        _parameters.edit()._threshold = config.threshold;
-    }
-}
+void BloomThreshold::configure(const Config& config) {}

 void BloomThreshold::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) {
    assert(renderContext->args);
@ -39,6 +35,7 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons

    const auto frameTransform = inputs.get0();
    const auto inputFrameBuffer = inputs.get1();
+    const auto bloom = inputs.get2();

    assert(inputFrameBuffer->hasColor());

@ -68,6 +65,13 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons

    glm::ivec4 viewport{ 0, 0, bufferSize.x, bufferSize.y };

+    if (!bloom) {
+        renderContext->taskFlow.abortTask();
+        return;
+    }
+
+    _parameters.edit()._threshold = bloom->getBloomThreshold();
+
    gpu::doInBatch("BloomThreshold::run", args->_context, [&](gpu::Batch& batch) {
        batch.enableStereo(false);

@ -83,23 +87,15 @@ void BloomThreshold::run(const render::RenderContextPointer& renderContext, cons
        batch.draw(gpu::TRIANGLE_STRIP, 4);
    });

-    outputs = _outputBuffer;
+    outputs.edit0() = _outputBuffer;
+    outputs.edit1() = 0.5f + bloom->getBloomSize() * 3.5f;
 }

 BloomApply::BloomApply() {

 }

-void BloomApply::configure(const Config& config) {
-    const auto newIntensity = config.intensity / 3.0f;
-
-    if (_parameters.get()._intensities.x != newIntensity) {
-        auto& parameters = _parameters.edit();
-        parameters._intensities.x = newIntensity;
-        parameters._intensities.y = newIntensity;
-        parameters._intensities.z = newIntensity;
-    }
-}
+void BloomApply::configure(const Config& config) {}

 void BloomApply::run(const render::RenderContextPointer& renderContext, const Inputs& inputs) {
    assert(renderContext->args);
@ -109,7 +105,6 @@ void BloomApply::run(const render::RenderContextPointer& renderContext, const In
    static const auto BLUR0_SLOT = 0;
    static const auto BLUR1_SLOT = 1;
    static const auto BLUR2_SLOT = 2;
-    static const auto PARAMETERS_SLOT = 0;

    if (!_pipeline) {
        gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::bloomApply);
@ -123,8 +118,15 @@ void BloomApply::run(const render::RenderContextPointer& renderContext, const In
    const auto blur0FB = inputs.get1();
    const auto blur1FB = inputs.get2();
    const auto blur2FB = inputs.get3();
+    const auto bloom = inputs.get4();
    const glm::ivec4 viewport{ 0, 0, framebufferSize.x, framebufferSize.y };

+    const auto newIntensity = bloom->getBloomIntensity() / 3.0f;
+    auto& parameters = _parameters.edit();
+    parameters._intensities.x = newIntensity;
+    parameters._intensities.y = newIntensity;
+    parameters._intensities.z = newIntensity;
+
    gpu::doInBatch("BloomApply::run", args->_context, [&](gpu::Batch& batch) {
        batch.enableStereo(false);

@ -139,7 +141,7 @@ void BloomApply::run(const render::RenderContextPointer& renderContext, const In
        batch.setResourceTexture(BLUR0_SLOT, blur0FB->getRenderBuffer(0));
        batch.setResourceTexture(BLUR1_SLOT, blur1FB->getRenderBuffer(0));
        batch.setResourceTexture(BLUR2_SLOT, blur2FB->getRenderBuffer(0));
-        batch.setUniformBuffer(PARAMETERS_SLOT, _parameters);
+        batch.setUniformBuffer(render_utils::slot::buffer::BloomParams, _parameters);
        batch.draw(gpu::TRIANGLE_STRIP, 4);
    });
 }
@ -206,8 +208,6 @@ void DebugBloom::run(const render::RenderContextPointer& renderContext, const In
        level2FB->getRenderBuffer(0)
    };

-    static auto TEXCOORD_RECT_SLOT = 1;
-
    if (!_pipeline) {
        gpu::ShaderPointer program = gpu::Shader::createProgram(shader::gpu::program::drawTextureOpaqueTexcoordRect);
        gpu::StatePointer state = gpu::StatePointer(new gpu::State());
@ -227,7 +227,7 @@ void DebugBloom::run(const render::RenderContextPointer& renderContext, const In

        Transform modelTransform;
        if (_mode == DebugBloomConfig::MODE_ALL_LEVELS) {
-            batch._glUniform4f(TEXCOORD_RECT_SLOT, 0.0f, 0.0f, 1.f, 1.f);
+            batch._glUniform4f(gpu::slot::uniform::TexCoordRect, 0.0f, 0.0f, 1.f, 1.f);

            modelTransform = gpu::Framebuffer::evalSubregionTexcoordTransform(framebufferSize, args->_viewport / 2);
            modelTransform.postTranslate(glm::vec3(-1.0f, 1.0f, 0.0f));
@ -255,7 +255,7 @@ void DebugBloom::run(const render::RenderContextPointer& renderContext, const In

            viewport.z /= 2;

-            batch._glUniform4f(TEXCOORD_RECT_SLOT, 0.5f, 0.0f, 0.5f, 1.f);
+            batch._glUniform4f(gpu::slot::uniform::TexCoordRect, 0.5f, 0.0f, 0.5f, 1.f);

            modelTransform = gpu::Framebuffer::evalSubregionTexcoordTransform(framebufferSize, viewport);
            modelTransform.postTranslate(glm::vec3(-1.0f, 0.0f, 0.0f));
@ -266,44 +266,10 @@ void DebugBloom::run(const render::RenderContextPointer& renderContext, const In
    });
 }

-void BloomConfig::setIntensity(float value) {
-    auto task = static_cast<render::Task::TaskConcept*>(_task);
-    auto blurJobIt = task->editJob("BloomApply");
-    assert(blurJobIt != task->_jobs.end());
-    blurJobIt->getConfiguration()->setProperty("intensity", value);
-}
+BloomEffect::BloomEffect() {}

-float BloomConfig::getIntensity() const {
-    auto task = static_cast<render::Task::TaskConcept*>(_task);
-    auto blurJobIt = task->getJob("BloomApply");
-    assert(blurJobIt != task->_jobs.end());
-    return blurJobIt->getConfiguration()->property("intensity").toFloat();
-}
-
-void BloomConfig::setSize(float value) {
-    std::string blurName{ "BloomBlurN" };
-    auto sigma = 0.5f+value*3.5f;
-    auto task = static_cast<render::Task::TaskConcept*>(_task);
-
-    for (auto i = 0; i < BLOOM_BLUR_LEVEL_COUNT; i++) {
-        blurName.back() = '0' + i;
-        auto blurJobIt = task->editJob(blurName);
-        assert(blurJobIt != task->_jobs.end());
-        auto& gaussianBlur = blurJobIt->edit<render::BlurGaussian>();
-        auto gaussianBlurParams = gaussianBlur.getParameters();
-        gaussianBlurParams->setFilterGaussianTaps(9, sigma);
-    }
-    auto blurJobIt = task->getJob("BloomApply");
-    assert(blurJobIt != task->_jobs.end());
-    blurJobIt->getConfiguration()->setProperty("sigma", sigma);
-}
-
-Bloom::Bloom() {
-
-}
-
-void Bloom::configure(const Config& config) {
-    std::string blurName{ "BloomBlurN" };
+void BloomEffect::configure(const Config& config) {
+    std::string blurName { "BloomBlurN" };

    for (auto i = 0; i < BLOOM_BLUR_LEVEL_COUNT; i++) {
        blurName.back() = '0' + i;
@ -312,25 +278,30 @@ void Bloom::configure(const Config& config) {
    }
 }

-void Bloom::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs) {
+void BloomEffect::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs) {
    // Start by computing threshold of color buffer input at quarter resolution
-    const auto bloomInputBuffer = task.addJob<BloomThreshold>("BloomThreshold", inputs, 4U);
+    const auto bloomOutputs = task.addJob<BloomThreshold>("BloomThreshold", inputs, 4U);

    // Multi-scale blur, each new blur is half resolution of the previous pass
-    const auto blurFB0 = task.addJob<render::BlurGaussian>("BloomBlur0", bloomInputBuffer, true);
-    const auto blurFB1 = task.addJob<render::BlurGaussian>("BloomBlur1", blurFB0, true, 2U);
-    const auto blurFB2 = task.addJob<render::BlurGaussian>("BloomBlur2", blurFB1, true, 2U);
+    const auto blurInputBuffer = bloomOutputs.getN<BloomThreshold::Outputs>(0);
+    const auto sigma = bloomOutputs.getN<BloomThreshold::Outputs>(1);
+    const auto blurInput0 = render::BlurGaussian::Inputs(blurInputBuffer, true, 1U, 9, sigma).asVarying();
+    const auto blurFB0 = task.addJob<render::BlurGaussian>("BloomBlur0", blurInput0);
+    const auto blurInput1 = render::BlurGaussian::Inputs(blurFB0, true, 2U, 9, sigma).asVarying();
+    const auto blurFB1 = task.addJob<render::BlurGaussian>("BloomBlur1", blurInput1);
+    const auto blurInput2 = render::BlurGaussian::Inputs(blurFB1, true, 2U, 9, sigma).asVarying();
+    const auto blurFB2 = task.addJob<render::BlurGaussian>("BloomBlur2", blurInput2);

-    const auto& input = inputs.get<Inputs>();
-    const auto& frameBuffer = input[1];
+    const auto& frameBuffer = inputs.getN<Inputs>(1);
+    const auto& bloom = inputs.getN<Inputs>(2);

    // Mix all blur levels at quarter resolution
-    const auto applyInput = BloomApply::Inputs(bloomInputBuffer, blurFB0, blurFB1, blurFB2).asVarying();
+    const auto applyInput = BloomApply::Inputs(blurInputBuffer, blurFB0, blurFB1, blurFB2, bloom).asVarying();
    task.addJob<BloomApply>("BloomApply", applyInput);
    // And then blend result in additive manner on top of final color buffer
-    const auto drawInput = BloomDraw::Inputs(frameBuffer, bloomInputBuffer).asVarying();
+    const auto drawInput = BloomDraw::Inputs(frameBuffer, blurInputBuffer).asVarying();
    task.addJob<BloomDraw>("BloomDraw", drawInput);

-    const auto debugInput = DebugBloom::Inputs(frameBuffer, blurFB0, blurFB1, blurFB2, bloomInputBuffer).asVarying();
+    const auto debugInput = DebugBloom::Inputs(frameBuffer, blurFB0, blurFB1, blurFB2, blurInputBuffer).asVarying();
    task.addJob<DebugBloom>("DebugBloom", debugInput);
 }
--- a/libraries/render-utils/src/BloomEffect.h
+++ b/libraries/render-utils/src/BloomEffect.h
@ -14,43 +14,22 @@

 #include <render/Engine.h>

+#include "graphics/Bloom.h"
+
 #include "DeferredFrameTransform.h"

 class BloomConfig : public render::Task::Config {
    Q_OBJECT
-        Q_PROPERTY(float intensity READ getIntensity WRITE setIntensity NOTIFY dirty)
-        Q_PROPERTY(float size MEMBER size WRITE setSize NOTIFY dirty)
-
-public:
-
-    BloomConfig() : render::Task::Config(false) {}
-
-    float size{ 0.7f };
-
-    void setIntensity(float value);
-    float getIntensity() const;
-    void setSize(float value);
-
-signals:
-    void dirty();
 };

 class BloomThresholdConfig : public render::Job::Config {
    Q_OBJECT
-        Q_PROPERTY(float threshold MEMBER threshold NOTIFY dirty)
-
-public:
-
-    float threshold{ 0.9f };
-
-signals:
-    void dirty();
 };

 class BloomThreshold {
 public:
-    using Inputs = render::VaryingSet2<DeferredFrameTransformPointer, gpu::FramebufferPointer>;
-    using Outputs = gpu::FramebufferPointer;
+    using Inputs = render::VaryingSet3<DeferredFrameTransformPointer, gpu::FramebufferPointer, graphics::BloomPointer>;
+    using Outputs = render::VaryingSet2<gpu::FramebufferPointer, float>;
    using Config = BloomThresholdConfig;
    using JobModel = render::Job::ModelIO<BloomThreshold, Inputs, Outputs, Config>;

@ -71,21 +50,11 @@ private:

 class BloomApplyConfig : public render::Job::Config {
    Q_OBJECT
-        Q_PROPERTY(float intensity MEMBER intensity NOTIFY dirty)
-		Q_PROPERTY(float sigma MEMBER sigma NOTIFY dirty)
-
-public:
-
-    float intensity{ 0.25f };
-	float sigma{ 1.0f };
-
-signals:
-    void dirty();
 };

 class BloomApply {
 public:
-    using Inputs = render::VaryingSet4<gpu::FramebufferPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, gpu::FramebufferPointer>;
+    using Inputs = render::VaryingSet5<gpu::FramebufferPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, gpu::FramebufferPointer, graphics::BloomPointer>;
    using Config = BloomApplyConfig;
    using JobModel = render::Job::ModelI<BloomApply, Inputs, Config>;

@ -118,7 +87,7 @@ private:

 class DebugBloomConfig : public render::Job::Config {
    Q_OBJECT
-        Q_PROPERTY(int mode MEMBER mode NOTIFY dirty)
+    Q_PROPERTY(int mode MEMBER mode NOTIFY dirty)

 public:

@ -155,13 +124,13 @@ private:
    DebugBloomConfig::Mode _mode;
 };

-class Bloom {
+class BloomEffect {
 public:
-    using Inputs = render::VaryingSet2<DeferredFrameTransformPointer, gpu::FramebufferPointer>;
+    using Inputs = render::VaryingSet3<DeferredFrameTransformPointer, gpu::FramebufferPointer, graphics::BloomPointer>;
    using Config = BloomConfig;
-	using JobModel = render::Task::ModelI<Bloom, Inputs, Config>;
+	using JobModel = render::Task::ModelI<BloomEffect, Inputs, Config>;

-	Bloom();
+	BloomEffect();

 	void configure(const Config& config);
 	void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs);
--- a/libraries/render-utils/src/BloomStage.cpp
+++ b/libraries/render-utils/src/BloomStage.cpp
@ -0,0 +1,79 @@
+//
+//  BloomStage.cpp
+//
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#include "BloomStage.h"
+
+#include "DeferredLightingEffect.h"
+
+#include <gpu/Context.h>
+
+std::string BloomStage::_stageName { "BLOOM_STAGE"};
+const BloomStage::Index BloomStage::INVALID_INDEX { render::indexed_container::INVALID_INDEX };
+
+FetchBloomStage::FetchBloomStage() {
+    _bloom = std::make_shared<graphics::Bloom>();
+}
+
+void FetchBloomStage::configure(const Config& config) {
+    _bloom->setBloomIntensity(config.bloomIntensity);
+    _bloom->setBloomThreshold(config.bloomThreshold);
+    _bloom->setBloomSize(config.bloomSize);
+}
+
+BloomStage::Index BloomStage::findBloom(const BloomPointer& bloom) const {
+    auto found = _bloomMap.find(bloom);
+    if (found != _bloomMap.end()) {
+        return INVALID_INDEX;
+    } else {
+        return (*found).second;
+    }
+}
+
+BloomStage::Index BloomStage::addBloom(const BloomPointer& bloom) {
+    auto found = _bloomMap.find(bloom);
+    if (found == _bloomMap.end()) {
+        auto bloomId = _blooms.newElement(bloom);
+        // Avoid failing to allocate a bloom, just pass
+        if (bloomId != INVALID_INDEX) {
+            // Insert the bloom and its index in the reverse map
+            _bloomMap.insert(BloomMap::value_type(bloom, bloomId));
+        }
+        return bloomId;
+    } else {
+        return (*found).second;
+    }
+}
+
+BloomStage::BloomPointer BloomStage::removeBloom(Index index) {
+    BloomPointer removed = _blooms.freeElement(index);
+    if (removed) {
+        _bloomMap.erase(removed);
+    }
+    return removed;
+}
+
+BloomStageSetup::BloomStageSetup() {}
+
+void BloomStageSetup::run(const render::RenderContextPointer& renderContext) {
+    auto stage = renderContext->_scene->getStage(BloomStage::getName());
+    if (!stage) {
+        renderContext->_scene->resetStage(BloomStage::getName(), std::make_shared<BloomStage>());
+    }
+}
+
+void FetchBloomStage::run(const render::RenderContextPointer& renderContext, graphics::BloomPointer& bloom) {
+    auto bloomStage = renderContext->_scene->getStage<BloomStage>();
+    assert(bloomStage);
+
+    bloom = nullptr;
+    if (bloomStage->_currentFrame._blooms.size() != 0) {
+        auto bloomId = bloomStage->_currentFrame._blooms.front();
+        bloom = bloomStage->getBloom(bloomId);
+    }
+}
--- a/libraries/render-utils/src/BloomStage.h
+++ b/libraries/render-utils/src/BloomStage.h
@ -0,0 +1,118 @@
+//
+//  BloomStage.h
+
+//  Created by Sam Gondelman on 8/7/2018
+//  Copyright 2018 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_render_utils_BloomStage_h
+#define hifi_render_utils_BloomStage_h
+
+#include <graphics/Stage.h>
+#include <set>
+#include <unordered_map>
+#include <render/IndexedContainer.h>
+#include <render/Stage.h>
+
+#include <render/Forward.h>
+#include <render/DrawTask.h>
+#include <graphics/Bloom.h>
+
+// Bloom stage to set up bloom-related rendering tasks
+class BloomStage : public render::Stage {
+public:
+    static std::string _stageName;
+    static const std::string& getName() { return _stageName; }
+
+    using Index = render::indexed_container::Index;
+    static const Index INVALID_INDEX;
+    static bool isIndexInvalid(Index index) { return index == INVALID_INDEX; }
+    
+    using BloomPointer = graphics::BloomPointer;
+    using Blooms = render::indexed_container::IndexedPointerVector<graphics::Bloom>;
+    using BloomMap = std::unordered_map<BloomPointer, Index>;
+
+    using BloomIndices = std::vector<Index>;
+
+    Index findBloom(const BloomPointer& bloom) const;
+    Index addBloom(const BloomPointer& bloom);
+
+    BloomPointer removeBloom(Index index);
+    
+    bool checkBloomId(Index index) const { return _blooms.checkIndex(index); }
+
+    Index getNumBlooms() const { return _blooms.getNumElements(); }
+    Index getNumFreeBlooms() const { return _blooms.getNumFreeIndices(); }
+    Index getNumAllocatedBlooms() const { return _blooms.getNumAllocatedIndices(); }
+
+    BloomPointer getBloom(Index bloomId) const {
+        return _blooms.get(bloomId);
+    }
+
+    Blooms _blooms;
+    BloomMap _bloomMap;
+
+    class Frame {
+    public:
+        Frame() {}
+        
+        void clear() { _blooms.clear(); }
+
+        void pushBloom(BloomStage::Index index) { _blooms.emplace_back(index); }
+
+        BloomStage::BloomIndices _blooms;
+    };
+    
+    Frame _currentFrame;
+};
+using BloomStagePointer = std::shared_ptr<BloomStage>;
+
+class BloomStageSetup {
+public:
+    using JobModel = render::Job::Model<BloomStageSetup>;
+
+    BloomStageSetup();
+    void run(const render::RenderContextPointer& renderContext);
+
+protected:
+};
+
+class FetchBloomConfig : public render::Job::Config {
+    Q_OBJECT
+    Q_PROPERTY(float bloomIntensity MEMBER bloomIntensity WRITE setBloomIntensity NOTIFY dirty);
+    Q_PROPERTY(float bloomThreshold MEMBER bloomThreshold WRITE setBloomThreshold NOTIFY dirty);
+    Q_PROPERTY(float bloomSize MEMBER bloomSize WRITE setBloomSize NOTIFY dirty);
+
+public:
+    FetchBloomConfig() : render::Job::Config() {}
+
+    float bloomIntensity { graphics::Bloom::INITIAL_BLOOM_INTENSITY };
+    float bloomThreshold { graphics::Bloom::INITIAL_BLOOM_THRESHOLD };
+    float bloomSize { graphics::Bloom::INITIAL_BLOOM_SIZE };
+
+public slots:
+    void setBloomIntensity(const float value) { bloomIntensity = value; emit dirty(); }
+    void setBloomThreshold(const float value) { bloomThreshold = value; emit dirty(); }
+    void setBloomSize(const float value) { bloomSize = value; emit dirty(); }
+
+signals:
+    void dirty();
+};
+
+class FetchBloomStage {
+public:
+    using Config = FetchBloomConfig;
+    using JobModel = render::Job::ModelO<FetchBloomStage, graphics::BloomPointer, Config>;
+
+    FetchBloomStage();
+
+    void configure(const Config& config);
+    void run(const render::RenderContextPointer& renderContext, graphics::BloomPointer& bloom);
+
+private:
+    graphics::BloomPointer _bloom;
+};
+#endif
--- a/libraries/render-utils/src/HazeStage.h
+++ b/libraries/render-utils/src/HazeStage.h
@ -163,6 +163,5 @@ public:

 private:
    graphics::HazePointer _haze;
-    gpu::PipelinePointer _hazePipeline;
 };
 #endif
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@ -45,6 +45,7 @@
 #include "TextureCache.h"
 #include "ZoneRenderer.h"
 #include "FadeEffect.h"
+#include "BloomStage.h"
 #include "RenderUtilsLogging.h"

 #include "AmbientOcclusionEffect.h"
@ -173,7 +174,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
    const auto velocityBufferOutputs = task.addJob<VelocityBufferPass>("VelocityBuffer", velocityBufferInputs);
    const auto velocityBuffer = velocityBufferOutputs.getN<VelocityBufferPass::Outputs>(0);

-    // Clear Light, Haze and Skybox Stages and render zones from the general metas bucket
+    // Clear Light, Haze, Bloom, and Skybox Stages and render zones from the general metas bucket
    const auto zones = task.addJob<ZoneRendererTask>("ZoneRenderer", metas);

    // Draw Lights just add the lights to the current list of lights to deal with. NOt really gpu job for now.
@ -245,8 +246,9 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
    task.addJob<Antialiasing>("Antialiasing", antialiasingInputs);

    // Add bloom
-    const auto bloomInputs = Bloom::Inputs(deferredFrameTransform, lightingFramebuffer).asVarying();
-    task.addJob<Bloom>("Bloom", bloomInputs);
+    const auto bloomModel = task.addJob<FetchBloomStage>("BloomModel");
+    const auto bloomInputs = BloomEffect::Inputs(deferredFrameTransform, lightingFramebuffer, bloomModel).asVarying();
+    task.addJob<BloomEffect>("Bloom", bloomInputs);

    // Lighting Buffer ready for tone mapping
    const auto toneMappingInputs = ToneMappingDeferred::Inputs(lightingFramebuffer, scaledPrimaryFramebuffer).asVarying();
--- a/libraries/render-utils/src/UpdateSceneTask.cpp
+++ b/libraries/render-utils/src/UpdateSceneTask.cpp
@ -14,6 +14,7 @@
 #include "LightStage.h"
 #include "BackgroundStage.h"
 #include "HazeStage.h"
+#include "BloomStage.h"
 #include <render/TransitionStage.h>
 #include <render/HighlightStage.h>
 #include "DeferredLightingEffect.h"
@ -22,6 +23,7 @@ void UpdateSceneTask::build(JobModel& task, const render::Varying& input, render
    task.addJob<LightStageSetup>("LightStageSetup");
    task.addJob<BackgroundStageSetup>("BackgroundStageSetup");
    task.addJob<HazeStageSetup>("HazeStageSetup");
+    task.addJob<BloomStageSetup>("BloomStageSetup");
    task.addJob<render::TransitionStageSetup>("TransitionStageSetup");
    task.addJob<render::HighlightStageSetup>("HighlightStageSetup");

--- a/libraries/render-utils/src/ZoneRenderer.cpp
+++ b/libraries/render-utils/src/ZoneRenderer.cpp
@ -21,11 +21,12 @@
 #include "StencilMaskPass.h"
 #include "DeferredLightingEffect.h"

-
 #include "render-utils/ShaderConstants.h"
 #include "StencilMaskPass.h"
 #include "DeferredLightingEffect.h"

+#include "BloomStage.h"
+
 namespace ru {
    using render_utils::slot::texture::Texture;
    using render_utils::slot::buffer::Buffer;
@ -63,7 +64,7 @@ void ZoneRendererTask::build(JobModel& task, const Varying& input, Varying& oupu
 }

 void SetupZones::run(const RenderContextPointer& context, const Inputs& inputs) {
-    // Grab light, background and haze stages and clear them
+    // Grab light, background, haze, and bloom stages and clear them
    auto lightStage = context->_scene->getStage<LightStage>();
    assert(lightStage);
    lightStage->_currentFrame.clear();
@ -76,6 +77,10 @@ void SetupZones::run(const RenderContextPointer& context, const Inputs& inputs)
    assert(hazeStage);
    hazeStage->_currentFrame.clear();

+    auto bloomStage = context->_scene->getStage<BloomStage>();
+    assert(bloomStage);
+    bloomStage->_currentFrame.clear();
+
    // call render over the zones to grab their components in the correct order first...
    render::renderItems(context, inputs);

@ -84,6 +89,7 @@ void SetupZones::run(const RenderContextPointer& context, const Inputs& inputs)
    lightStage->_currentFrame.pushAmbientLight(lightStage->getDefaultLight());
    backgroundStage->_currentFrame.pushBackground(0);
    hazeStage->_currentFrame.pushHaze(0);
+    bloomStage->_currentFrame.pushBloom(INVALID_INDEX);
 }

 const gpu::PipelinePointer& DebugZoneLighting::getKeyLightPipeline() {
--- a/libraries/render/src/render/BlurTask.cpp
+++ b/libraries/render/src/render/BlurTask.cpp
@ -195,9 +195,7 @@ bool BlurInOutResource::updateResources(const gpu::FramebufferPointer& sourceFra
    return true;
 }

-BlurGaussian::BlurGaussian(bool generateOutputFramebuffer, unsigned int downsampleFactor) :
-    _inOutResources(generateOutputFramebuffer, downsampleFactor)
-{
+BlurGaussian::BlurGaussian() {
    _parameters = std::make_shared<BlurParams>();
 }

@ -243,12 +241,17 @@ void BlurGaussian::configure(const Config& config) {
 }


-void BlurGaussian::run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& blurredFramebuffer) {
+void BlurGaussian::run(const RenderContextPointer& renderContext, const Inputs& inputs, gpu::FramebufferPointer& blurredFramebuffer) {
    assert(renderContext->args);
    assert(renderContext->args->hasViewFrustum());

    RenderArgs* args = renderContext->args;

+    const auto sourceFramebuffer = inputs.get0();
+    _inOutResources._generateOutputFramebuffer = inputs.get1();
+    _inOutResources._downsampleFactor = inputs.get2();
+    _parameters->setFilterGaussianTaps(inputs.get3(), inputs.get4());
+
    BlurInOutResource::Resources blurringResources;
    if (!_inOutResources.updateResources(sourceFramebuffer, blurringResources)) {
        // early exit if no valid blurring resources
--- a/libraries/render/src/render/BlurTask.h
+++ b/libraries/render/src/render/BlurTask.h
@ -72,6 +72,7 @@ using BlurParamsPointer = std::shared_ptr<BlurParams>;

 class BlurInOutResource {
 public:
+    BlurInOutResource() {}
    BlurInOutResource(bool generateOutputFramebuffer, unsigned int downsampleFactor);

    struct Resources {
@ -113,13 +114,14 @@ protected:

 class BlurGaussian {
 public:
+    using Inputs = VaryingSet5<gpu::FramebufferPointer, bool, unsigned int, int, float>;
    using Config = BlurGaussianConfig;
-    using JobModel = Job::ModelIO<BlurGaussian, gpu::FramebufferPointer, gpu::FramebufferPointer, Config>;
+    using JobModel = Job::ModelIO<BlurGaussian, Inputs, gpu::FramebufferPointer, Config>;

-    BlurGaussian(bool generateOutputFramebuffer = false, unsigned int downsampleFactor = 1U);
+    BlurGaussian();

    void configure(const Config& config);
-    void run(const RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceFramebuffer, gpu::FramebufferPointer& blurredFramebuffer);
+    void run(const RenderContextPointer& renderContext, const Inputs& inputs, gpu::FramebufferPointer& blurredFramebuffer);

    BlurParamsPointer getParameters() const { return _parameters; }

--- a/scripts/developer/utilities/render/bloom.qml
+++ b/scripts/developer/utilities/render/bloom.qml
@ -14,20 +14,11 @@ import "configSlider"

 Item {
    id: root
-    property var config: Render.getConfig("RenderMainView.Bloom")
-    property var configThreshold: Render.getConfig("RenderMainView.BloomThreshold")
    property var configDebug: Render.getConfig("RenderMainView.DebugBloom")

    Column {
        spacing: 8

-        CheckBox {
-            text: "Enable"
-            checked: root.config["enabled"]
-            onCheckedChanged: {
-                root.config["enabled"] = checked;
-            }
-        }
        GroupBox {
            title: "Debug"
            Row {
@ -88,35 +79,5 @@ Item {
                }
            }
        }
-        ConfigSlider {
-            label: "Intensity"
-            integral: false
-            config: root.config
-            property: "intensity"
-            max: 1.0
-            min: 0.0
-            width: 280
-            height:38
-        }  
-        ConfigSlider {
-            label: "Size"
-            integral: false
-            config: root.config
-            property: "size"
-            max: 1.0
-            min: 0.0
-            width: 280
-            height:38
-        }  
-        ConfigSlider {
-            label: "Threshold"
-            integral: false
-            config: root.configThreshold
-            property: "threshold"
-            max: 2.0
-            min: 0.0
-            width: 280
-            height:38
-        }  
    }
 }
--- a/scripts/developer/utilities/render/debugBloom.js
+++ b/scripts/developer/utilities/render/debugBloom.js
@ -15,6 +15,6 @@ var window = new OverlayWindow({
    title: 'Bloom',
    source: qml,
    width: 285, 
-    height: 210,
+    height: 40,
 });
 window.closed.connect(function() { Script.stop(); });
--- a/scripts/system/html/entityProperties.html
+++ b/scripts/system/html/entityProperties.html
@ -678,6 +678,52 @@
                    </div>
                </fieldset-->
            </fieldset>
+            <fieldset class="minor">
+                <legend class="sub-section-header zone-group zone-section">
+                    Bloom
+                </legend>
+                <form>
+                    <input type="radio" name="bloomMode" value="inherit" id="property-zone-bloom-mode-inherit" checked> Inherit
+                    <input type="radio" name="bloomMode" value="disabled" id="property-zone-bloom-mode-disabled"> Off
+                    <input type="radio" name="bloomMode" value="enabled" id="property-zone-bloom-mode-enabled"> On
+                </form>
+                <fieldset class="zone-group zone-section bloom-section property gen fstuple">
+                    <div class="tuple">
+                        <div>
+                            <br>
+                            <table>
+                                <td><label>Bloom Intensity&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0</label></td>
+                                <td><input type="range" class="slider" id="property-zone-bloom-intensity" min="0" max="1" step="0.01"></td>
+                                <td><label>1</label>
+                            </table>
+                        </div>
+                    </div>
+                </fieldset>
+                <fieldset class="zone-group zone-section bloom-section property gen fstuple">
+                    <div class="tuple">
+                        <div>
+                            <br>
+                            <table>
+                                <td><label>Bloom Threshold&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0</label></td>
+                                <td><input type="range" class="slider" id="property-zone-bloom-threshold" min="0" max="1" step="0.01"></td>
+                                <td><label>1</label>
+                            </table>
+                        </div>
+                    </div>
+                </fieldset>
+                <fieldset class="zone-group zone-section bloom-section property gen fstuple">
+                    <div class="tuple">
+                        <div>
+                            <br>
+                            <table>
+                                <td><label>Bloom Size&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0</label></td>
+                                <td><input type="range" class="slider" id="property-zone-bloom-size" min="0" max="2" step="0.01"></td>
+                                <td><label>2</label>
+                            </table>
+                        </div>
+                    </div>
+                </fieldset>
+            </fieldset>
        </fieldset>
        <fieldset id="text" class="major">
            <legend class="section-header text-group text-section">
--- a/scripts/system/html/js/entityProperties.js
+++ b/scripts/system/html/js/entityProperties.js
@ -841,7 +841,7 @@ function loaded() {
        var elZoneHazeModeInherit = document.getElementById("property-zone-haze-mode-inherit");
        var elZoneHazeModeDisabled = document.getElementById("property-zone-haze-mode-disabled");
        var elZoneHazeModeEnabled = document.getElementById("property-zone-haze-mode-enabled");
-        
+
        var elZoneHazeRange = document.getElementById("property-zone-haze-range");
        var elZoneHazeColor = document.getElementById("property-zone-haze-color");
        var elZoneHazeColorRed = document.getElementById("property-zone-haze-color-red");
@ -860,6 +860,15 @@ function loaded() {

        var elZoneHazeBackgroundBlend = document.getElementById("property-zone-haze-background-blend");

+        // Bloom
+        var elZoneBloomModeInherit = document.getElementById("property-zone-bloom-mode-inherit");
+        var elZoneBloomModeDisabled = document.getElementById("property-zone-bloom-mode-disabled");
+        var elZoneBloomModeEnabled = document.getElementById("property-zone-bloom-mode-enabled");
+
+        var elZoneBloomIntensity = document.getElementById("property-zone-bloom-intensity");
+        var elZoneBloomThreshold = document.getElementById("property-zone-bloom-threshold");
+        var elZoneBloomSize = document.getElementById("property-zone-bloom-size");
+
        var elZoneSkyboxColor = document.getElementById("property-zone-skybox-color");
        var elZoneSkyboxColorRed = document.getElementById("property-zone-skybox-color-red");
        var elZoneSkyboxColorGreen = document.getElementById("property-zone-skybox-color-green");
@ -916,19 +925,19 @@ function loaded() {
                                deleteJSONMaterialEditor();
                            }
                        }
-                        
+
                        elTypeIcon.style.display = "none";
                        elType.innerHTML = "<i>No selection</i>";
                        elPropertiesList.className = '';
-                        
+
                        elID.value = "";
                        elName.value = "";
                        elLocked.checked = false;
                        elVisible.checked = false;
-                        
+
                        elParentID.value = "";
                        elParentJointIndex.value = "";
-                        
+
                        elColorRed.value = "";
                        elColorGreen.value = "";
                        elColorBlue.value = "";
@ -937,15 +946,15 @@ function loaded() {
                        elPositionX.value = "";
                        elPositionY.value = "";
                        elPositionZ.value = "";
-                        
+
                        elRotationX.value = "";
                        elRotationY.value = "";
                        elRotationZ.value = "";
-                        
+
                        elDimensionsX.value = "";
                        elDimensionsY.value = "";
                        elDimensionsZ.value = "";   
-                        
+
                        elRegistrationX.value = "";
                        elRegistrationY.value = "";
                        elRegistrationZ.value = "";
@ -967,14 +976,14 @@ function loaded() {
                        elAccelerationX.value = "";
                        elAccelerationY.value = "";
                        elAccelerationZ.value = "";
-                        
+
                        elRestitution.value = "";
                        elFriction.value = "";
                        elDensity.value = "";
-                        
+
                        elCollisionless.checked = false;
                        elDynamic.checked = false;
-                        
+
                        elCollideStatic.checked = false;
                        elCollideKinematic.checked = false;
                        elCollideDynamic.checked = false;
@ -991,27 +1000,27 @@ function loaded() {
                        elCloneableGroup.style.display = "none";
                        elCloneableLimit.value = "";
                        elCloneableLifetime.value = "";
-                                            
-                        showElements(document.getElementsByClassName('can-cast-shadow-section'), true);                                 
+
+                        showElements(document.getElementsByClassName('can-cast-shadow-section'), true);
                        elCanCastShadow.checked = false;
-                        
+
                        elCollisionSoundURL.value = "";
                        elLifetime.value = "";
                        elScriptURL.value = "";
                        elServerScripts.value = "";
                        elHyperlinkHref.value = "";
                        elDescription.value = "";
-                        
+
                        deleteJSONEditor();
                        elUserData.value = "";
                        showUserDataTextArea();
                        showSaveUserDataButton();
                        showNewJSONEditorButton();
-                        
+
                        // Shape Properties
                        elShape.value = "Cube";
                        setDropdownText(elShape);
-                        
+
                        // Light Properties
                        elLightSpotLight.checked = false;
                        elLightColor.style.backgroundColor = "rgb(" + 0 + "," + 0 + "," + 0 + ")";
@ -1022,7 +1031,7 @@ function loaded() {
                        elLightFalloffRadius.value = "";
                        elLightExponent.value = "";
                        elLightCutoff.value = "";
-                        
+
                        // Model Properties
                        elModelURL.value = "";
                        elCompoundShapeURL.value = "";
@ -1039,7 +1048,7 @@ function loaded() {
                        elModelAnimationAllowTranslation.checked = false;
                        elModelTextures.value = "";
                        elModelOriginalTextures.value = "";
-                                                
+
                        // Zone Properties
                        elZoneFlyingAllowed.checked = false;
                        elZoneGhostingAllowed.checked = false;
@ -1069,6 +1078,9 @@ function loaded() {
                        elZoneHazeAltitudeEffect.checked = false;
                        elZoneHazeBaseRef.value = "";
                        elZoneHazeCeiling.value = "";
+                        elZoneBloomIntensity.value = "";
+                        elZoneBloomThreshold.value = "";
+                        elZoneBloomSize.value = "";
                        elZoneSkyboxColor.style.backgroundColor = "rgb(" + 0 + "," + 0 + "," + 0 + ")";
                        elZoneSkyboxColorRed.value = "";
                        elZoneSkyboxColorGreen.value = "";
@ -1078,7 +1090,8 @@ function loaded() {
                        showElements(document.getElementsByClassName('skybox-section'), true);
                        showElements(document.getElementsByClassName('ambient-section'), true);
                        showElements(document.getElementsByClassName('haze-section'), true);
-                        
+                        showElements(document.getElementsByClassName('bloom-section'), true);
+
                        // Text Properties
                        elTextText.value = "";
                        elTextLineHeight.value = "";
@ -1091,14 +1104,14 @@ function loaded() {
                        elTextBackgroundColorRed.value = "";
                        elTextBackgroundColorGreen.value = "";
                        elTextBackgroundColorBlue.value = "";
-                                                
+
                        // Image Properties
                        elImageURL.value = "";
-                        
+
                        // Web Properties
                        elWebSourceURL.value = "";
                        elWebDPI.value = "";
-                        
+
                        // Material Properties
                        elMaterialURL.value = "";
                        elParentMaterialNameNumber.value = "";
@ -1109,13 +1122,13 @@ function loaded() {
                        elMaterialMappingScaleX.value = "";
                        elMaterialMappingScaleY.value = "";
                        elMaterialMappingRot.value = "";
-                        
+
                        deleteJSONMaterialEditor();
                        elMaterialData.value = "";
                        showMaterialDataTextArea();
                        showSaveMaterialDataButton();
                        showNewJSONMaterialEditorButton();
-                        
+
                        disableProperties();
                    } else if (data.selections.length > 1) {
                        deleteJSONEditor();
@ -1252,7 +1265,7 @@ function loaded() {
                        elCloneableGroup.style.display = elCloneable.checked ? "block": "none";
                        elCloneableLimit.value = properties.cloneLimit;
                        elCloneableLifetime.value = properties.cloneLifetime;
-                        
+
                        var grabbablesSet = false;
                        var parsedUserData = {};
                        try {
@ -1478,6 +1491,14 @@ function loaded() {
                            elZoneHazeBaseRef.value = properties.haze.hazeBaseRef.toFixed(0);
                            elZoneHazeCeiling.value = properties.haze.hazeCeiling.toFixed(0);

+                            elZoneBloomModeInherit.checked = (properties.bloomMode === 'inherit');
+                            elZoneBloomModeDisabled.checked = (properties.bloomMode === 'disabled');
+                            elZoneBloomModeEnabled.checked = (properties.bloomMode === 'enabled');
+
+                            elZoneBloomIntensity.value = properties.bloom.bloomIntensity.toFixed(2);
+                            elZoneBloomThreshold.value = properties.bloom.bloomThreshold.toFixed(2);
+                            elZoneBloomSize.value = properties.bloom.bloomSize.toFixed(2);
+
                            elShapeType.value = properties.shapeType;
                            elCompoundShapeURL.value = properties.compoundShapeURL;

@ -1504,6 +1525,9 @@ function loaded() {

                            showElements(document.getElementsByClassName('haze-section'),
                                elZoneHazeModeEnabled.checked);
+
+                            showElements(document.getElementsByClassName('bloom-section'),
+                                elZoneBloomModeEnabled.checked);
                        } else if (properties.type === "PolyVox") {
                            elVoxelVolumeSizeX.value = properties.voxelVolumeSize.x.toFixed(2);
                            elVoxelVolumeSizeY.value = properties.voxelVolumeSize.y.toFixed(2);
@ -2069,6 +2093,18 @@ function loaded() {
        elZoneHazeBackgroundBlend.addEventListener('change', 
            createEmitGroupNumberPropertyUpdateFunction('haze', 'hazeBackgroundBlend'));

+        // Bloom
+        var bloomModeChanged = createZoneComponentModeChangedFunction('bloomMode',
+            elZoneBloomModeInherit, elZoneBloomModeDisabled, elZoneBloomModeEnabled);
+
+        elZoneBloomModeInherit.addEventListener('change', bloomModeChanged);
+        elZoneBloomModeDisabled.addEventListener('change', bloomModeChanged);
+        elZoneBloomModeEnabled.addEventListener('change', bloomModeChanged);
+
+        elZoneBloomIntensity.addEventListener('change', createEmitGroupNumberPropertyUpdateFunction('bloom', 'bloomIntensity'));
+        elZoneBloomThreshold.addEventListener('change', createEmitGroupNumberPropertyUpdateFunction('bloom', 'bloomThreshold'));
+        elZoneBloomSize.addEventListener('change', createEmitGroupNumberPropertyUpdateFunction('bloom', 'bloomSize'));
+
        var zoneSkyboxColorChangeFunction = createEmitGroupColorPropertyUpdateFunction('skybox', 'color',
            elZoneSkyboxColorRed, elZoneSkyboxColorGreen, elZoneSkyboxColorBlue);
        elZoneSkyboxColorRed.addEventListener('change', zoneSkyboxColorChangeFunction);