Merge pull request #16015 from HifiExperiments/renderUpdate

BUGZ-902: Drastically reduce locking and branching necessary for render updates

interface/src/octree/SafeLanding.cpp

@@ -121,9 +121,6 @@ void SafeLanding::updateTracking() {
             if (isEntityPhysicsReady(entity) && isVisuallyReady) {
                 entityMapIter = _trackedEntities.erase(entityMapIter);
             } else {
-                if (!isVisuallyReady) {
-                    entity->requestRenderUpdate();
-                }
                 entityMapIter++;
             }
         }

libraries/entities-renderer/src/RenderableEntityItem.cpp

@@ -128,12 +128,7 @@ std::shared_ptr<T> make_renderer(const EntityItemPointer& entity) {
     return std::shared_ptr<T>(new T(entity), [](T* ptr) { ptr->deleteLater(); });
 }
 
-EntityRenderer::EntityRenderer(const EntityItemPointer& entity) : _created(entity->getCreated()), _entity(entity) {
+EntityRenderer::EntityRenderer(const EntityItemPointer& entity) : _created(entity->getCreated()), _entity(entity) {}
-    connect(entity.get(), &EntityItem::requestRenderUpdate, this, [&] {
-        _needsRenderUpdate = true;
-        emit requestRenderUpdate();
-    });
-}
 
 EntityRenderer::~EntityRenderer() {}
 
@@ -349,10 +344,6 @@ void EntityRenderer::updateInScene(const ScenePointer& scene, Transaction& trans
 // Returns true if the item needs to have updateInscene called because of internal rendering 
 // changes (animation, fading, etc)
 bool EntityRenderer::needsRenderUpdate() const {
-    if (_needsRenderUpdate) {
-        return true;
-    }
-
     if (isFading()) {
         return true;
     }
@@ -365,6 +356,14 @@ bool EntityRenderer::needsRenderUpdate() const {
 
 // Returns true if the item in question needs to have updateInScene called because of changes in the entity
 bool EntityRenderer::needsRenderUpdateFromEntity(const EntityItemPointer& entity) const {
+    if (entity->needsRenderUpdate()) {
+        return true;
+    }
+
+    if (!entity->isVisuallyReady()) {
+        return true;
+    }
+
     bool success = false;
     auto bound = _entity->getAABox(success);
     if (success && _bound != bound) {
@@ -403,7 +402,7 @@ void EntityRenderer::doRenderUpdateSynchronous(const ScenePointer& scene, Transa
     withWriteLock([&] {
         auto transparent = isTransparent();
         auto fading = isFading();
-        if (fading || _prevIsTransparent != transparent) {
+        if (fading || _prevIsTransparent != transparent || !entity->isVisuallyReady()) {
             emit requestRenderUpdate();
         }
         if (fading) {
@@ -421,7 +420,7 @@ void EntityRenderer::doRenderUpdateSynchronous(const ScenePointer& scene, Transa
         setPrimitiveMode(entity->getPrimitiveMode());
         _canCastShadow = entity->getCanCastShadow();
         _cauterized = entity->getCauterized();
-        _needsRenderUpdate = false;
+        entity->setNeedsRenderUpdate(false);
     });
 }
 

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -144,7 +144,6 @@ protected:
     PrimitiveMode _primitiveMode { PrimitiveMode::SOLID };
     bool _cauterized { false };
     bool _moving { false };
-    bool _needsRenderUpdate { false };
     // Only touched on the rendering thread
     bool _renderUpdateQueued{ false };
     Transform _renderTransform;

libraries/entities-renderer/src/RenderableGizmoEntityItem.cpp

@@ -14,9 +14,7 @@
 using namespace render;
 using namespace render::entities;
 
-GizmoEntityRenderer::GizmoEntityRenderer(const EntityItemPointer& entity) : Parent(entity)
+GizmoEntityRenderer::GizmoEntityRenderer(const EntityItemPointer& entity) : Parent(entity) {}
-{
-}
 
 GizmoEntityRenderer::~GizmoEntityRenderer() {
     auto geometryCache = DependencyManager::get<GeometryCache>();
@@ -41,22 +39,6 @@ bool GizmoEntityRenderer::isTransparent() const {
     return Parent::isTransparent() || ringTransparent;
 }
 
-bool GizmoEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    bool needsUpdate = resultWithReadLock<bool>([&] {
-        if (_gizmoType != entity->getGizmoType()) {
-            return true;
-        }
-
-        if (_ringProperties != entity->getRingProperties()) {
-            return true;
-        }
-
-        return false;
-    });
-
-    return needsUpdate;
-}
-
 void GizmoEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
     bool dirty = false;
     RingGizmoPropertyGroup ringProperties = entity->getRingProperties();

libraries/entities-renderer/src/RenderableGizmoEntityItem.h

@@ -29,7 +29,6 @@ protected:
     bool isTransparent() const override;
 
 private:
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
 

libraries/entities-renderer/src/RenderableGridEntityItem.cpp

@@ -29,42 +29,6 @@ bool GridEntityRenderer::isTransparent() const {
     return Parent::isTransparent() || _alpha < 1.0f || _pulseProperties.getAlphaMode() != PulseMode::NONE;
 }
 
-bool GridEntityRenderer::needsRenderUpdate() const {
-    return Parent::needsRenderUpdate();
-}
-
-bool GridEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    bool needsUpdate = resultWithReadLock<bool>([&] {
-        if (_color != entity->getColor()) {
-            return true;
-        }
-
-        if (_alpha != entity->getAlpha()) {
-            return true;
-        }
-
-        if (_followCamera != entity->getFollowCamera()) {
-            return true;
-        }
-
-        if (_majorGridEvery != entity->getMajorGridEvery()) {
-            return true;
-        }
-
-        if (_minorGridEvery != entity->getMinorGridEvery()) {
-            return true;
-        }
-
-        if (_pulseProperties != entity->getPulseProperties()) {
-            return true;
-        }
-
-        return false;
-    });
-
-    return needsUpdate;
-}
-
 void GridEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) {
     withWriteLock([&] {
         _color = entity->getColor();

libraries/entities-renderer/src/RenderableGridEntityItem.h

@@ -29,8 +29,6 @@ protected:
     bool isTransparent() const override;
 
 private:
-    virtual bool needsRenderUpdate() const override;
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
     virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
 

libraries/entities-renderer/src/RenderableImageEntityItem.cpp

@@ -41,46 +41,6 @@ bool ImageEntityRenderer::needsRenderUpdate() const {
     return Parent::needsRenderUpdate();
 }
 
-bool ImageEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    bool needsUpdate = resultWithReadLock<bool>([&] {
-        if (_imageURL != entity->getImageURL()) {
-            return true;
-        }
-
-        if (_emissive != entity->getEmissive()) {
-            return true;
-        }
-
-        if (_keepAspectRatio != entity->getKeepAspectRatio()) {
-            return true;
-        }
-
-        if (_billboardMode != entity->getBillboardMode()) {
-            return true;
-        }
-
-        if (_subImage != entity->getSubImage()) {
-            return true;
-        }
-
-        if (_color != entity->getColor()) {
-            return true;
-        }
-
-        if (_alpha != entity->getAlpha()) {
-            return true;
-        }
-
-        if (_pulseProperties != entity->getPulseProperties()) {
-            return true;
-        }
-
-        return false;
-    });
-
-    return needsUpdate;
-}
-
 void ImageEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) {
     withWriteLock([&] {
         auto imageURL = entity->getImageURL();

libraries/entities-renderer/src/RenderableImageEntityItem.h

@@ -30,7 +30,6 @@ protected:
 
 private:
     virtual bool needsRenderUpdate() const override;
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
     virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
 

libraries/entities-renderer/src/RenderableLightEntityItem.cpp

@@ -18,11 +18,6 @@ using namespace render;
 using namespace render::entities;
 
 void LightEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
-    // Reset the value before reading the data!
-    // otherwise there could be a race condition where the value changes
-    // after we read it but before we reset, and we never see the change
-    entity->resetLightPropertiesChanged();
-
     auto& lightPayload = *_lightPayload;
 
     lightPayload.setVisible(_visible);
@@ -69,10 +64,6 @@ Item::Bound LightEntityRenderer::getBound() {
     return payloadGetBound(_lightPayload);
 }
 
-bool LightEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    return entity->lightPropertiesChanged();
-}
-
 void LightEntityRenderer::doRender(RenderArgs* args) {
     _lightPayload->render(args);
 }

libraries/entities-renderer/src/RenderableLightEntityItem.h

@@ -26,7 +26,6 @@ public:
     LightEntityRenderer(const EntityItemPointer& entity) : Parent(entity) { }
 
 protected:
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
 
     virtual ItemKey getKey() override;

libraries/entities-renderer/src/RenderableLineEntityItem.cpp

@@ -26,12 +26,7 @@ void LineEntityRenderer::onRemoveFromSceneTyped(const TypedEntityPointer& entity
     }
 }
 
-bool LineEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    return entity->pointsChanged();
-}
-
 void LineEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
-    entity->resetPointsChanged();
     _linePoints = entity->getLinePoints();
     auto geometryCache = DependencyManager::get<GeometryCache>();
     if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {

libraries/entities-renderer/src/RenderableLineEntityItem.h

@@ -28,7 +28,6 @@ public:
 
 protected:
     virtual void onRemoveFromSceneTyped(const TypedEntityPointer& entity) override;
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
 

libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp

@@ -26,37 +26,15 @@ bool MaterialEntityRenderer::needsRenderUpdate() const {
 
 bool MaterialEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
     if (resultWithReadLock<bool>([&] {
-        if (entity->getMaterialMappingMode() != _materialMappingMode) {
-            return true;
-        }
-        if (entity->getMaterialRepeat() != _materialRepeat) {
-            return true;
-        }
-        if (entity->getMaterialMappingPos() != _materialMappingPos || entity->getMaterialMappingScale() != _materialMappingScale || entity->getMaterialMappingRot() != _materialMappingRot) {
-            return true;
-        }
         if (entity->getTransform() != _transform) {
             return true;
         }
         if (entity->getUnscaledDimensions() != _dimensions) {
             return true;
         }
-
-        if (entity->getMaterialURL() != _materialURL) {
-            return true;
-        }
-        if (entity->getMaterialData() != _materialData) {
-            return true;
-        }
-        if (entity->getParentMaterialName() != _parentMaterialName) {
-            return true;
-        }
         if (entity->getParentID() != _parentID) {
             return true;
         }
-        if (entity->getPriority() != _priority) {
-            return true;
-        }
 
         return false;
     })) {

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1229,19 +1229,11 @@ bool ModelEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoin
             return true;
         }
 
-        if (_parsedModelURL != entity->getModelURL()) {
-            return true;
-        }
-
         // No model to render, early exit
         if (!_hasModel) {
             return false;
         }
 
-        if (_textures != entity->getTextures()) {
-            return true;
-        }
-
         if (_animating != entity->isAnimatingSomething()) {
             return true;
         }
@@ -1275,10 +1267,6 @@ bool ModelEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoin
             model->getRegistrationPoint() != entity->getRegistrationPoint()) {
             return true;
         }
-
-        if (model->isGroupCulled() != entity->getGroupCulled()) {
-            return true;
-        }
     }
 
     return false;

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp

@@ -64,32 +64,6 @@ ParticleEffectEntityRenderer::ParticleEffectEntityRenderer(const EntityItemPoint
     });
 }
 
-bool ParticleEffectEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    entity->updateQueryAACube();
-
-    if (_emitting != entity->getIsEmitting()) {
-        return true;
-    }
-
-    if (_particleProperties != entity->getParticleProperties()) {
-        return true;
-    }
-
-    if (_pulseProperties != entity->getPulseProperties()) {
-        return true;
-    }
-
-    if (_shapeType != entity->getShapeType()) {
-        return true;
-    }
-
-    if (_compoundShapeURL != entity->getCompoundShapeURL()) {
-        return true;
-    }
-
-    return false;
-}
-
 void ParticleEffectEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) {
     auto newParticleProperties = entity->getParticleProperties();
     if (!newParticleProperties.valid()) {

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h

@@ -25,8 +25,6 @@ public:
     ParticleEffectEntityRenderer(const EntityItemPointer& entity);
 
 protected:
-    virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override;
-
     virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
 

libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp

@@ -77,11 +77,9 @@ ShapeKey PolyLineEntityRenderer::getShapeKey() {
 }
 
 bool PolyLineEntityRenderer::needsRenderUpdate() const {
-    bool textureLoadedChanged = resultWithReadLock<bool>([&] {
+    if (resultWithReadLock<bool>([&] {
         return (!_textureLoaded && _texture && _texture->isLoaded());
-    });
+    })) {
-
-    if (textureLoadedChanged) {
         return true;
     }
 
@@ -93,10 +91,6 @@ bool PolyLineEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityP
         return true;
     }
 
-    if (_isUVModeStretch != entity->getIsUVModeStretch() || _glow != entity->getGlow() || _faceCamera != entity->getFaceCamera()) {
-        return true;
-    }
-
     return Parent::needsRenderUpdateFromTypedEntity(entity);
 }
 

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp

@@ -1616,20 +1616,6 @@ ShapeKey PolyVoxEntityRenderer::getShapeKey() {
 }
 
 bool PolyVoxEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    std::array<QString, 3> xyzTextureURLs{ {
-        entity->getXTextureURL(),
-        entity->getYTextureURL(),
-        entity->getZTextureURL()
-    } };
-
-    if (xyzTextureURLs != _xyzTextureUrls) {
-        return true;
-    }
-
-    if (entity->getVoxelVolumeSize() != _lastVoxelVolumeSize) {
-        return true;
-    }
-
     if (entity->voxelToWorldMatrix() != _lastVoxelToWorldMatrix) {
         return true;
     }

libraries/entities-renderer/src/RenderableShapeEntityItem.cpp

@@ -63,26 +63,11 @@ bool ShapeEntityRenderer::needsRenderUpdate() const {
 }
 
 bool ShapeEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    if (_lastUserData != entity->getUserData()) {
-        return true;
-    }
-
-    if (_color != toGlm(entity->getColor())) {
-        return true;
-    }
-    if (_alpha != entity->getAlpha()) {
-        return true;
-    }
-
-    if (_shape != entity->getShape()) {
-        return true;
-    }
-
     if (_dimensions != entity->getScaledDimensions()) {
         return true;
     }
 
-    if (_pulseProperties != entity->getPulseProperties()) {
+    if (_lastUserData != entity->getUserData()) {
         return true;
     }
 

libraries/entities-renderer/src/RenderableTextEntityItem.cpp

@@ -93,69 +93,10 @@ uint32_t TextEntityRenderer::metaFetchMetaSubItems(ItemIDs& subItems) const {
 }
 
 bool TextEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {
-    if (_text != entity->getText()) {
-        return true;
-    }
-    if (_lineHeight != entity->getLineHeight()) {
-        return true;
-    }
-
-    if (_textColor != toGlm(entity->getTextColor())) {
-        return true;
-    }
-    if (_textAlpha != entity->getTextAlpha()) {
-        return true;
-    }
-    if (_backgroundColor != toGlm(entity->getBackgroundColor())) {
-        return true;
-    }
-    if (_backgroundAlpha != entity->getBackgroundAlpha()) {
-        return true;
-    }
-
     if (_dimensions != entity->getScaledDimensions()) {
         return true;
     }
 
-    if (_billboardMode != entity->getBillboardMode()) {
-        return true;
-    }
-
-    if (_leftMargin != entity->getLeftMargin()) {
-        return true;
-    }
-    if (_rightMargin != entity->getRightMargin()) {
-        return true;
-    }
-    if (_topMargin != entity->getTopMargin()) {
-        return true;
-    }
-    if (_bottomMargin != entity->getBottomMargin()) {
-        return true;
-    }
-
-    if (_unlit != entity->getUnlit()) {
-        return true;
-    }
-
-    if (_font != entity->getFont()) {
-        return true;
-    }
-
-    if (_effect != entity->getTextEffect()) {
-        return true;
-    }
-    if (_effectColor != toGlm(entity->getTextEffectColor())) {
-        return true;
-    }
-    if (_effectThickness != entity->getTextEffectThickness()) {
-        return true;
-    }
-
-    if (_pulseProperties != entity->getPulseProperties()) {
-        return true;
-    }
-
     return false;
 }
 

libraries/entities-renderer/src/RenderableWebEntityItem.cpp

@@ -111,42 +111,6 @@ bool WebEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointe
             return true;
         }
 
-        if (_color != entity->getColor()) {
-            return true;
-        }
-
-        if (_alpha != entity->getAlpha()) {
-            return true;
-        }
-
-        if (_billboardMode != entity->getBillboardMode()) {
-            return true;
-        }
-
-        if (_sourceURL != entity->getSourceUrl()) {
-            return true;
-        }
-
-        if (_dpi != entity->getDPI()) {
-            return true;
-        }
-
-        if (_scriptURL != entity->getScriptURL()) {
-            return true;
-        }
-
-        if (_maxFPS != entity->getMaxFPS()) {
-            return true;
-        }
-
-        if (_inputMode != entity->getInputMode()) {
-            return true;
-        }
-
-        if (_pulseProperties != entity->getPulseProperties()) {
-            return true;
-        }
-
         return false;
     })) {
         return true;

libraries/entities/src/EntityItem.cpp

@@ -2943,17 +2943,15 @@ bool EntityItem::getVisible() const {
 }
 
 void EntityItem::setVisible(bool value) {
-    bool changed = false;
+    bool changed;
     withWriteLock([&] {
-        if (_visible != value) {
+        changed = _visible != value;
-            changed = true;
+        _needsRenderUpdate |= changed;
-            _visible = value;
+        _visible = value;
-        }
     });
 
     if (changed) {
         bumpAncestorChainRenderableVersion();
-        emit requestRenderUpdate();
     }
 }
 
@@ -2966,17 +2964,10 @@ bool EntityItem::isVisibleInSecondaryCamera() const {
 }
 
 void EntityItem::setIsVisibleInSecondaryCamera(bool value) {
-    bool changed = false;
     withWriteLock([&] {
-        if (_isVisibleInSecondaryCamera != value) {
+        _needsRenderUpdate |= _isVisibleInSecondaryCamera != value;
-            changed = true;
+        _isVisibleInSecondaryCamera = value;
-            _isVisibleInSecondaryCamera = value;
-        }
     });
-
-    if (changed) {
-        emit requestRenderUpdate();
-    }
 }
 
 RenderLayer EntityItem::getRenderLayer() const {
@@ -2986,17 +2977,10 @@ RenderLayer EntityItem::getRenderLayer() const {
 }
 
 void EntityItem::setRenderLayer(RenderLayer value) {
-    bool changed = false;
     withWriteLock([&] {
-        if (_renderLayer != value) {
+        _needsRenderUpdate |= _renderLayer != value;
-            changed = true;
+        _renderLayer = value;
-            _renderLayer = value;
-        }
     });
-
-    if (changed) {
-        emit requestRenderUpdate();
-    }
 }
 
 PrimitiveMode EntityItem::getPrimitiveMode() const {
@@ -3006,17 +2990,10 @@ PrimitiveMode EntityItem::getPrimitiveMode() const {
 }
 
 void EntityItem::setPrimitiveMode(PrimitiveMode value) {
-    bool changed = false;
     withWriteLock([&] {
-        if (_primitiveMode != value) {
+        _needsRenderUpdate |= _primitiveMode != value;
-            changed = true;
+        _primitiveMode = value;
-            _primitiveMode = value;
-        }
     });
-
-    if (changed) {
-        emit requestRenderUpdate();
-    }
 }
 
 bool EntityItem::getCauterized() const {
@@ -3026,17 +3003,10 @@ bool EntityItem::getCauterized() const {
 }
 
 void EntityItem::setCauterized(bool value) {
-    bool changed = false;
     withWriteLock([&] {
-        if (_cauterized != value) {
+        _needsRenderUpdate |= _cauterized != value;
-            changed = true;
+        _cauterized = value;
-            _cauterized = value;
-        }
     });
-
-    if (changed) {
-        emit requestRenderUpdate();
-    }
 }
 
 bool EntityItem::getIgnorePickIntersection() const {
@@ -3060,17 +3030,10 @@ bool EntityItem::getCanCastShadow() const {
 }
 
 void EntityItem::setCanCastShadow(bool value) {
-    bool changed = false;
     withWriteLock([&] {
-        if (_canCastShadow != value) {
+        _needsRenderUpdate |= _canCastShadow != value;
-            changed = true;
+        _canCastShadow = value;
-            _canCastShadow = value;
-        }
     });
-
-    if (changed) {
-        emit requestRenderUpdate();
-    }
 }
 
 bool EntityItem::isChildOfMyAvatar() const {

libraries/entities/src/EntityItem.h

@@ -571,8 +571,10 @@ public:
 
     bool stillHasMyGrabAction() const;
 
+    bool needsRenderUpdate() const { return resultWithReadLock<bool>([&] { return _needsRenderUpdate; }); }
+    void setNeedsRenderUpdate(bool needsRenderUpdate) { withWriteLock([&] { _needsRenderUpdate = needsRenderUpdate; }); }
+
 signals:
-    void requestRenderUpdate();
     void spaceUpdate(std::pair<int32_t, glm::vec4> data);
 
 protected:
@@ -760,6 +762,8 @@ protected:
 
     QHash<QUuid, EntityDynamicPointer> _grabActions;
 
+    mutable bool _needsRenderUpdate { false };
+
 private:
     static std::function<glm::quat(const glm::vec3&, const glm::quat&, BillboardMode, const glm::vec3&)> _getBillboardRotationOperator;
     static std::function<glm::vec3()> _getPrimaryViewFrustumPositionOperator;

libraries/entities/src/GizmoEntityItem.cpp

@@ -46,6 +46,7 @@ bool GizmoEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool ringPropertiesChanged = _ringProperties.setProperties(properties);
         somethingChanged |= ringPropertiesChanged;
+        _needsRenderUpdate |= ringPropertiesChanged;
     });
 
     if (somethingChanged) {
@@ -185,6 +186,7 @@ bool GizmoEntityItem::findDetailedParabolaIntersection(const glm::vec3& origin,
 
 void GizmoEntityItem::setGizmoType(GizmoType value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _gizmoType != value;
         _gizmoType = value;
     });
 }

libraries/entities/src/GridEntityItem.cpp

@@ -54,6 +54,7 @@ bool GridEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
 
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(followCamera, setFollowCamera);
@@ -136,6 +137,7 @@ void GridEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
 
 void GridEntityItem::setColor(const glm::u8vec3& color) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != color;
         _color = color;
     });
 }
@@ -148,6 +150,7 @@ glm::u8vec3 GridEntityItem::getColor() const {
 
 void GridEntityItem::setAlpha(float alpha) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _alpha != alpha;
         _alpha = alpha;
     });
 }
@@ -160,6 +163,7 @@ float GridEntityItem::getAlpha() const {
 
 void GridEntityItem::setFollowCamera(bool followCamera) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _followCamera != followCamera;
         _followCamera = followCamera;
     });
 }
@@ -171,9 +175,12 @@ bool GridEntityItem::getFollowCamera() const {
 }
 
 void GridEntityItem::setMajorGridEvery(uint32_t majorGridEvery) {
+    const uint32_t MAJOR_GRID_EVERY_MIN = 1;
+    majorGridEvery = std::max(majorGridEvery, MAJOR_GRID_EVERY_MIN);
+
     withWriteLock([&] {
-        const uint32_t MAJOR_GRID_EVERY_MIN = 1;
+        _needsRenderUpdate |= _majorGridEvery != majorGridEvery;
-        _majorGridEvery = std::max(majorGridEvery, MAJOR_GRID_EVERY_MIN);
+        _majorGridEvery = majorGridEvery;
     });
 }
 
@@ -184,9 +191,12 @@ uint32_t GridEntityItem::getMajorGridEvery() const {
 }
 
 void GridEntityItem::setMinorGridEvery(float minorGridEvery) {
+    const float MINOR_GRID_EVERY_MIN = 0.01f;
+    minorGridEvery = std::max(minorGridEvery, MINOR_GRID_EVERY_MIN);
+
     withWriteLock([&] {
-        const float MINOR_GRID_EVERY_MIN = 0.01f;
+        _needsRenderUpdate |= _minorGridEvery != minorGridEvery;
-        _minorGridEvery = std::max(minorGridEvery, MINOR_GRID_EVERY_MIN);
+        _minorGridEvery = minorGridEvery;
     });
 }
 

libraries/entities/src/ImageEntityItem.cpp

@@ -53,6 +53,7 @@ bool ImageEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(billboardMode, setBillboardMode);
 
@@ -214,6 +215,7 @@ QString ImageEntityItem::getImageURL() const {
 
 void ImageEntityItem::setImageURL(const QString& url) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _imageURL != url;
         _imageURL = url;
     });
 }
@@ -228,6 +230,7 @@ bool ImageEntityItem::getEmissive() const {
 
 void ImageEntityItem::setEmissive(bool emissive) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _emissive != emissive;
         _emissive = emissive;
     });
 }
@@ -242,6 +245,7 @@ bool ImageEntityItem::getKeepAspectRatio() const {
 
 void ImageEntityItem::setKeepAspectRatio(bool keepAspectRatio) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _keepAspectRatio != keepAspectRatio;
         _keepAspectRatio = keepAspectRatio;
     });
 }
@@ -256,6 +260,7 @@ BillboardMode ImageEntityItem::getBillboardMode() const {
 
 void ImageEntityItem::setBillboardMode(BillboardMode value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _billboardMode != value;
         _billboardMode = value;
     });
 }
@@ -270,12 +275,14 @@ QRect ImageEntityItem::getSubImage() const {
 
 void ImageEntityItem::setSubImage(const QRect& subImage) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _subImage != subImage;
         _subImage = subImage;
     });
 }
 
 void ImageEntityItem::setColor(const glm::u8vec3& color) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != color;
         _color = color;
     });
 }
@@ -288,6 +295,7 @@ glm::u8vec3 ImageEntityItem::getColor() const {
 
 void ImageEntityItem::setAlpha(float alpha) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _alpha != alpha;
         _alpha = alpha;
     });
 }

libraries/entities/src/LightEntityItem.cpp

@@ -58,14 +58,14 @@ void LightEntityItem::setUnscaledDimensions(const glm::vec3& value) {
 void LightEntityItem::locationChanged(bool tellPhysics, bool tellChildren) {
     EntityItem::locationChanged(tellPhysics, tellChildren);
     withWriteLock([&] {
-        _lightPropertiesChanged = true;
+        _needsRenderUpdate = true;
     });
 }
 
 void LightEntityItem::dimensionsChanged() {
     EntityItem::dimensionsChanged();
     withWriteLock([&] {
-        _lightPropertiesChanged = true;
+        _needsRenderUpdate = true;
     });
 }
 
@@ -85,12 +85,10 @@ EntityItemProperties LightEntityItem::getProperties(const EntityPropertyFlags& d
 
 void LightEntityItem::setFalloffRadius(float value) {
     value = glm::max(value, 0.0f);
-    if (value == getFalloffRadius()) {
+
-        return;
-    }
     withWriteLock([&] {
+        _needsRenderUpdate |= _falloffRadius != value;
         _falloffRadius = value;
-        _lightPropertiesChanged = true;
     });
 }
 
@@ -110,8 +108,8 @@ void LightEntityItem::setIsSpotlight(bool value) {
     }
 
     withWriteLock([&] {
+        _needsRenderUpdate = true;
         _isSpotlight = value;
-        _lightPropertiesChanged = true;
     });
     setScaledDimensions(newDimensions);
 }
@@ -123,6 +121,7 @@ void LightEntityItem::setCutoff(float value) {
     }
 
     withWriteLock([&] {
+        _needsRenderUpdate = true;
         _cutoff = value;
     });
 
@@ -133,10 +132,6 @@ void LightEntityItem::setCutoff(float value) {
         const float width = length * glm::sin(glm::radians(_cutoff));
         setScaledDimensions(glm::vec3(width, width, length));
     }
-    
-    withWriteLock([&] {
-        _lightPropertiesChanged = true;
-    });
 }
 
 bool LightEntityItem::setProperties(const EntityItemProperties& properties) {
@@ -223,8 +218,8 @@ glm::u8vec3 LightEntityItem::getColor() const {
 
 void LightEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != value;
         _color = value;
-        _lightPropertiesChanged = true;
     });
 }
 
@@ -246,8 +241,8 @@ float LightEntityItem::getIntensity() const {
 
 void LightEntityItem::setIntensity(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _intensity != value;
         _intensity = value;
-        _lightPropertiesChanged = true;
     });
 }
 
@@ -269,8 +264,8 @@ float LightEntityItem::getExponent() const {
 
 void LightEntityItem::setExponent(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _exponent != value;
         _exponent = value;
-        _lightPropertiesChanged = true;
     });
 }
 
@@ -282,10 +277,6 @@ float LightEntityItem::getCutoff() const {
     return result;
 }
 
-void LightEntityItem::resetLightPropertiesChanged() {
-    withWriteLock([&] { _lightPropertiesChanged = false; });
-}
-
 bool LightEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                         OctreeElementPointer& element, float& distance,
                         BoxFace& face, glm::vec3& surfaceNormal,

libraries/entities/src/LightEntityItem.h

@@ -77,9 +77,6 @@ public:
     virtual void locationChanged(bool tellPhysics, bool tellChildren) override;
     virtual void dimensionsChanged() override;
 
-    bool lightPropertiesChanged() const { return _lightPropertiesChanged; }
-    void resetLightPropertiesChanged();
-
     virtual bool supportsDetailedIntersection() const override { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                             OctreeElementPointer& element, float& distance,
@@ -98,8 +95,6 @@ private:
     float _falloffRadius { DEFAULT_FALLOFF_RADIUS };
     float _exponent { DEFAULT_EXPONENT };
     float _cutoff { DEFAULT_CUTOFF };
-    // Dirty flag turn true when either light properties is changing values.
-    bool _lightPropertiesChanged { false };
 
     static bool _lightsArePickable;
 };

libraries/entities/src/LineEntityItem.cpp

@@ -76,9 +76,10 @@ bool LineEntityItem::appendPoint(const glm::vec3& point) {
         return false;
     }
     withWriteLock([&] {
+        _needsRenderUpdate = true;
         _points << point;
-        _pointsChanged = true;
     });
+
     return true;
 }
 
@@ -96,9 +97,10 @@ bool LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
     }
 
     withWriteLock([&] {
+        _needsRenderUpdate = true;
         _points = points;
-        _pointsChanged = true;
     });
+
     return true;
 }
 
@@ -155,6 +157,7 @@ glm::u8vec3 LineEntityItem::getColor() const {
 
 void LineEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != value;
         _color = value;
     });
 }
@@ -165,10 +168,4 @@ QVector<glm::vec3> LineEntityItem::getLinePoints() const {
         result = _points;
     });
     return result;
-}
+}
-
-void LineEntityItem::resetPointsChanged() { 
-    withWriteLock([&] {
-        _pointsChanged = false;
-    });
-}

libraries/entities/src/LineEntityItem.h

@@ -61,15 +61,13 @@ class LineEntityItem : public EntityItem {
                                                   BoxFace& face, glm::vec3& surfaceNormal,
                                                   QVariantMap& extraInfo,
                                                   bool precisionPicking) const override { return false; }
-    bool pointsChanged() const { return _pointsChanged; }
+
-    void resetPointsChanged();
     virtual void debugDump() const override;
     static const int MAX_POINTS_PER_LINE;
 
  private:
     glm::u8vec3 _color;
     QVector<glm::vec3> _points;
-    bool _pointsChanged { true };
 };
 
 #endif // hifi_LineEntityItem_h

libraries/entities/src/MaterialEntityItem.cpp

@@ -154,6 +154,7 @@ QString MaterialEntityItem::getMaterialURL() const {
 
 void MaterialEntityItem::setMaterialURL(const QString& materialURL) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialURL != materialURL;
         _materialURL = materialURL;
     });
 }
@@ -166,6 +167,7 @@ QString MaterialEntityItem::getMaterialData() const {
 
 void MaterialEntityItem::setMaterialData(const QString& materialData) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialData != materialData;
         _materialData = materialData;
     });
 }
@@ -178,6 +180,7 @@ MaterialMappingMode MaterialEntityItem::getMaterialMappingMode() const {
 
 void MaterialEntityItem::setMaterialMappingMode(MaterialMappingMode mode) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialMappingMode != mode;
         _materialMappingMode = mode;
     });
     setUnscaledDimensions(_desiredDimensions);
@@ -191,6 +194,7 @@ quint16 MaterialEntityItem::getPriority() const {
 
 void MaterialEntityItem::setPriority(quint16 priority) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _priority != priority;
         _priority = priority;
     });
 }
@@ -203,6 +207,7 @@ QString MaterialEntityItem::getParentMaterialName() const {
 
 void MaterialEntityItem::setParentMaterialName(const QString& parentMaterialName) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _parentMaterialName != parentMaterialName;
         _parentMaterialName = parentMaterialName;
     });
 }
@@ -215,6 +220,7 @@ glm::vec2 MaterialEntityItem::getMaterialMappingPos() const {
 
 void MaterialEntityItem::setMaterialMappingPos(const glm::vec2& materialMappingPos) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialMappingPos != materialMappingPos;
         _materialMappingPos = materialMappingPos;
     });
 }
@@ -227,6 +233,7 @@ glm::vec2 MaterialEntityItem::getMaterialMappingScale() const {
 
 void MaterialEntityItem::setMaterialMappingScale(const glm::vec2& materialMappingScale) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialMappingScale != materialMappingScale;
         _materialMappingScale = materialMappingScale;
     });
 }
@@ -239,10 +246,24 @@ float MaterialEntityItem::getMaterialMappingRot() const {
 
 void MaterialEntityItem::setMaterialMappingRot(float materialMappingRot) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _materialMappingRot != materialMappingRot;
         _materialMappingRot = materialMappingRot;
     });
 }
 
+bool MaterialEntityItem::getMaterialRepeat() const {
+    return resultWithReadLock<bool>([&] {
+        return _materialRepeat;
+    });
+}
+
+void MaterialEntityItem::setMaterialRepeat(bool value) {
+    withWriteLock([&] {
+        _needsRenderUpdate |= _materialRepeat != value;
+        _materialRepeat = value;
+    });
+}
+
 AACube MaterialEntityItem::calculateInitialQueryAACube(bool& success) {
     AACube aaCube = EntityItem::calculateInitialQueryAACube(success);
     // A Material entity's queryAACube contains its parent's queryAACube

libraries/entities/src/MaterialEntityItem.h

@@ -55,8 +55,8 @@ public:
     MaterialMappingMode getMaterialMappingMode() const;
     void setMaterialMappingMode(MaterialMappingMode mode);
 
-    bool getMaterialRepeat() const { return _materialRepeat; }
+    bool getMaterialRepeat() const;
-    void setMaterialRepeat(bool repeat) { _materialRepeat = repeat; }
+    void setMaterialRepeat(bool repeat);
 
     quint16 getPriority() const;
     void setPriority(quint16 priority);

libraries/entities/src/ModelEntityItem.cpp

@@ -50,6 +50,7 @@ const QString ModelEntityItem::getTextures() const {
 
 void ModelEntityItem::setTextures(const QString& textures) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _textures != textures;
         _textures = textures;
     });
 }
@@ -295,6 +296,7 @@ void ModelEntityItem::setModelURL(const QString& url) {
         if (_modelURL != url) {
             _modelURL = url;
             _flags |= Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS;
+            _needsRenderUpdate = true;
         }
     });
 }
@@ -576,6 +578,7 @@ bool ModelEntityItem::getRelayParentJoints() const {
 
 void ModelEntityItem::setGroupCulled(bool value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _groupCulled != value;
         _groupCulled = value;
     });
 }

libraries/entities/src/ParticleEffectEntityItem.cpp

@@ -167,211 +167,446 @@ ParticleEffectEntityItem::ParticleEffectEntityItem(const EntityItemID& entityIte
 }
 
 void ParticleEffectEntityItem::setAlpha(float alpha) {
+    alpha = glm::clamp(alpha, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+
     withWriteLock([&] {
-        _particleProperties.alpha.gradient.target  = glm::clamp(alpha, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+        _needsRenderUpdate |= _particleProperties.alpha.gradient.target != alpha;
+        _particleProperties.alpha.gradient.target  = alpha;
+    });
+}
+
+float ParticleEffectEntityItem::getAlpha() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.alpha.gradient.target;
     });
 }
 
 void ParticleEffectEntityItem::setAlphaStart(float alphaStart) {
+    alphaStart = glm::isnan(alphaStart) ? alphaStart : glm::clamp(alphaStart, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+
     withWriteLock([&] {
-        _particleProperties.alpha.range.start = glm::isnan(alphaStart) ? alphaStart : glm::clamp(alphaStart, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+        _needsRenderUpdate |= _particleProperties.alpha.range.start != alphaStart;
+        _particleProperties.alpha.range.start = alphaStart;
+    });
+}
+
+float ParticleEffectEntityItem::getAlphaStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.alpha.range.start;
     });
 }
 
 void ParticleEffectEntityItem::setAlphaFinish(float alphaFinish) {
+    alphaFinish = glm::isnan(alphaFinish) ? alphaFinish : glm::clamp(alphaFinish, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+
     withWriteLock([&] {
-        _particleProperties.alpha.range.finish = glm::isnan(alphaFinish) ? alphaFinish : glm::clamp(alphaFinish, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+        _needsRenderUpdate |= _particleProperties.alpha.range.finish != alphaFinish;
+        _particleProperties.alpha.range.finish = alphaFinish;
+    });
+}
+
+float ParticleEffectEntityItem::getAlphaFinish() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.alpha.range.finish;
     });
 }
 
 void ParticleEffectEntityItem::setAlphaSpread(float alphaSpread) {
+    alphaSpread = glm::clamp(alphaSpread, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+
     withWriteLock([&] {
-        _particleProperties.alpha.gradient.spread = glm::clamp(alphaSpread, MINIMUM_ALPHA, MAXIMUM_ALPHA);
+        _needsRenderUpdate |= _particleProperties.alpha.gradient.spread != alphaSpread;
+        _particleProperties.alpha.gradient.spread = alphaSpread;
+    });
+}
+
+float ParticleEffectEntityItem::getAlphaSpread() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.alpha.gradient.spread;
     });
 }
 
 void ParticleEffectEntityItem::setLifespan(float lifespan) {
     lifespan = glm::clamp(lifespan, MINIMUM_LIFESPAN, MAXIMUM_LIFESPAN);
-    if (lifespan != _particleProperties.lifespan) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.lifespan = lifespan;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.lifespan != lifespan;
+        _needsRenderUpdate |= changed;
+        _particleProperties.lifespan = lifespan;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getLifespan() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.lifespan;
+    });
+}
+
 void ParticleEffectEntityItem::setEmitRate(float emitRate) {
+    emitRate = glm::clamp(emitRate, MINIMUM_EMIT_RATE, MAXIMUM_EMIT_RATE);
+
     withWriteLock([&] {
-        _particleProperties.emission.rate = glm::clamp(emitRate, MINIMUM_EMIT_RATE, MAXIMUM_EMIT_RATE);
+        _needsRenderUpdate |= _particleProperties.emission.rate != emitRate;
+        _particleProperties.emission.rate = emitRate;
+    });
+}
+
+float ParticleEffectEntityItem::getEmitRate() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.emission.rate;
     });
 }
 
 void ParticleEffectEntityItem::setEmitSpeed(float emitSpeed) {
     emitSpeed = glm::clamp(emitSpeed, MINIMUM_EMIT_SPEED, MAXIMUM_EMIT_SPEED);
-    if (emitSpeed != _particleProperties.emission.speed.target) {
+
-        withWriteLock([&] { 
+    bool changed;
-            _particleProperties.emission.speed.target = emitSpeed; 
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.speed.target != emitSpeed;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.speed.target = emitSpeed;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getEmitSpeed() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.emission.speed.target;
+    });
+}
+
 void ParticleEffectEntityItem::setSpeedSpread(float speedSpread) {
     speedSpread = glm::clamp(speedSpread, MINIMUM_EMIT_SPEED, MAXIMUM_EMIT_SPEED);
-    if (speedSpread != _particleProperties.emission.speed.spread) {
+
-        withWriteLock([&] { 
+    bool changed;
-            _particleProperties.emission.speed.spread = speedSpread;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.speed.spread != speedSpread;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.speed.spread = speedSpread;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getSpeedSpread() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.emission.speed.spread;
+    });
+}
+
 void ParticleEffectEntityItem::setEmitOrientation(const glm::quat& emitOrientation_) {
     auto emitOrientation = glm::normalize(emitOrientation_);
-    if (emitOrientation != _particleProperties.emission.orientation) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.emission.orientation = emitOrientation;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.orientation != emitOrientation;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.orientation = emitOrientation;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+glm::quat ParticleEffectEntityItem::getEmitOrientation() const {
+    return resultWithReadLock<glm::quat>([&] {
+        return _particleProperties.emission.orientation;
+    });
+}
+
 void ParticleEffectEntityItem::setEmitDimensions(const glm::vec3& emitDimensions_) {
     auto emitDimensions = glm::clamp(emitDimensions_, vec3(MINIMUM_EMIT_DIMENSION), vec3(MAXIMUM_EMIT_DIMENSION));
-    if (emitDimensions != _particleProperties.emission.dimensions) {
+
-        withWriteLock([&] { 
+    bool changed;
-            _particleProperties.emission.dimensions = emitDimensions;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.dimensions != emitDimensions;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.dimensions = emitDimensions;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+glm::vec3 ParticleEffectEntityItem::getEmitDimensions() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.emission.dimensions;
+    });
+}
+
 void ParticleEffectEntityItem::setEmitRadiusStart(float emitRadiusStart) {
+    emitRadiusStart = glm::clamp(emitRadiusStart, MINIMUM_EMIT_RADIUS_START, MAXIMUM_EMIT_RADIUS_START);
+
     withWriteLock([&] {
-        _particleProperties.radiusStart = glm::clamp(emitRadiusStart, MINIMUM_EMIT_RADIUS_START, MAXIMUM_EMIT_RADIUS_START);
+        _needsRenderUpdate |= _particleProperties.radiusStart != emitRadiusStart;
+        _particleProperties.radiusStart = emitRadiusStart;
+    });
+}
+
+float ParticleEffectEntityItem::getEmitRadiusStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.radiusStart;
     });
 }
 
 void ParticleEffectEntityItem::setPolarStart(float polarStart) {
+    polarStart = glm::clamp(polarStart, MINIMUM_POLAR, MAXIMUM_POLAR);
+
     withWriteLock([&] {
-        _particleProperties.polar.start = glm::clamp(polarStart, MINIMUM_POLAR, MAXIMUM_POLAR);
+        _needsRenderUpdate |= _particleProperties.polar.start != polarStart;
+        _particleProperties.polar.start = polarStart;
+    });
+}
+
+float ParticleEffectEntityItem::getPolarStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.polar.start;
     });
 }
 
 void ParticleEffectEntityItem::setPolarFinish(float polarFinish) {
+    polarFinish = glm::clamp(polarFinish, MINIMUM_POLAR, MAXIMUM_POLAR);
+
     withWriteLock([&] {
-        _particleProperties.polar.finish = glm::clamp(polarFinish, MINIMUM_POLAR, MAXIMUM_POLAR);
+        _needsRenderUpdate |= _particleProperties.polar.finish != polarFinish;
+        _particleProperties.polar.finish = polarFinish;
+    });
+}
+
+float ParticleEffectEntityItem::getPolarFinish() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.polar.finish;
     });
 }
 
 void ParticleEffectEntityItem::setAzimuthStart(float azimuthStart) {
+    azimuthStart = glm::clamp(azimuthStart, MINIMUM_AZIMUTH, MAXIMUM_AZIMUTH);
+
     withWriteLock([&] {
-        _particleProperties.azimuth.start = glm::clamp(azimuthStart, MINIMUM_AZIMUTH, MAXIMUM_AZIMUTH);
+        _needsRenderUpdate |= _particleProperties.azimuth.start != azimuthStart;
+        _particleProperties.azimuth.start = azimuthStart;
+    });
+}
+
+float ParticleEffectEntityItem::getAzimuthStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.azimuth.start;
     });
 }
 
 void ParticleEffectEntityItem::setAzimuthFinish(float azimuthFinish) {
+    azimuthFinish = glm::clamp(azimuthFinish, MINIMUM_AZIMUTH, MAXIMUM_AZIMUTH);
+
     withWriteLock([&] {
-        _particleProperties.azimuth.finish = glm::clamp(azimuthFinish, MINIMUM_AZIMUTH, MAXIMUM_AZIMUTH);
+        _needsRenderUpdate |= _particleProperties.azimuth.finish != azimuthFinish;
+        _particleProperties.azimuth.finish = azimuthFinish;
+    });
+}
+
+float ParticleEffectEntityItem::getAzimuthFinish() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.azimuth.finish;
     });
 }
 
 void ParticleEffectEntityItem::setEmitAcceleration(const glm::vec3& emitAcceleration_) {
     auto emitAcceleration = glm::clamp(emitAcceleration_, vec3(MINIMUM_EMIT_ACCELERATION), vec3(MAXIMUM_EMIT_ACCELERATION));
-    if (emitAcceleration != _particleProperties.emission.acceleration.target) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.emission.acceleration.target = emitAcceleration;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.acceleration.target != emitAcceleration;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.acceleration.target = emitAcceleration;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+glm::vec3 ParticleEffectEntityItem::getEmitAcceleration() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.emission.acceleration.target;
+    });
+}
+
 void ParticleEffectEntityItem::setAccelerationSpread(const glm::vec3& accelerationSpread_){
     auto accelerationSpread = glm::clamp(accelerationSpread_, vec3(MINIMUM_ACCELERATION_SPREAD), vec3(MAXIMUM_ACCELERATION_SPREAD));
-    if (accelerationSpread != _particleProperties.emission.acceleration.spread) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.emission.acceleration.spread = accelerationSpread;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.emission.acceleration.spread != accelerationSpread;
+        _needsRenderUpdate |= changed;
+        _particleProperties.emission.acceleration.spread = accelerationSpread;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+glm::vec3 ParticleEffectEntityItem::getAccelerationSpread() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.emission.acceleration.spread;
+    });
+}
+
 void ParticleEffectEntityItem::setParticleRadius(float particleRadius) {
     particleRadius = glm::clamp(particleRadius, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
-    if (particleRadius != _particleProperties.radius.gradient.target) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.radius.gradient.target = particleRadius;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.radius.gradient.target != particleRadius;
+        _needsRenderUpdate |= changed;
+        _particleProperties.radius.gradient.target = particleRadius;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getParticleRadius() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.radius.gradient.target;
+    });
+}
+
 void ParticleEffectEntityItem::setRadiusStart(float radiusStart) {
     radiusStart = glm::isnan(radiusStart) ? radiusStart : glm::clamp(radiusStart, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
-    if (radiusStart != _particleProperties.radius.range.start) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.radius.range.start = radiusStart;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.radius.range.start != radiusStart;
+        _needsRenderUpdate |= changed;
+        _particleProperties.radius.range.start = radiusStart;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getRadiusStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.radius.range.start;
+    });
+}
+
 void ParticleEffectEntityItem::setRadiusFinish(float radiusFinish) {
     radiusFinish = glm::isnan(radiusFinish) ? radiusFinish : glm::clamp(radiusFinish, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
-    if (radiusFinish != _particleProperties.radius.range.finish) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.radius.range.finish = radiusFinish;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.radius.range.finish != radiusFinish;
+        _needsRenderUpdate |= changed;
+        _particleProperties.radius.range.finish = radiusFinish;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getRadiusFinish() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.radius.range.finish;
+    });
+}
+
 void ParticleEffectEntityItem::setRadiusSpread(float radiusSpread) {
     radiusSpread = glm::clamp(radiusSpread, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS);
-    if (radiusSpread != _particleProperties.radius.gradient.spread) {
+
-        withWriteLock([&] {
+    bool changed;
-            _particleProperties.radius.gradient.spread = radiusSpread;
+    withWriteLock([&] {
-        });
+        changed = _particleProperties.radius.gradient.spread != radiusSpread;
+        _needsRenderUpdate |= changed;
+        _particleProperties.radius.gradient.spread = radiusSpread;
+    });
+
+    if (changed) {
         computeAndUpdateDimensions();
     }
 }
 
+float ParticleEffectEntityItem::getRadiusSpread() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.radius.gradient.spread;
+    });
+}
+
 void ParticleEffectEntityItem::setParticleSpin(float particleSpin) {
     particleSpin = glm::clamp(particleSpin, MINIMUM_PARTICLE_SPIN, MAXIMUM_PARTICLE_SPIN);
-    if (particleSpin != _particleProperties.spin.gradient.target) {
+
-        withWriteLock([&] {
+    withWriteLock([&] {
-            _particleProperties.spin.gradient.target = particleSpin;
+        _needsRenderUpdate |= _particleProperties.spin.gradient.target != particleSpin;
-        });
+        _particleProperties.spin.gradient.target = particleSpin;
-    }
+    });
+}
+
+float ParticleEffectEntityItem::getParticleSpin() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.spin.gradient.target;
+    });
 }
 
 void ParticleEffectEntityItem::setSpinStart(float spinStart) {
     spinStart =
         glm::isnan(spinStart) ? spinStart : glm::clamp(spinStart, MINIMUM_PARTICLE_SPIN, MAXIMUM_PARTICLE_SPIN);
-    if (spinStart != _particleProperties.spin.range.start) {
+
-        withWriteLock([&] {
+    withWriteLock([&] {
-            _particleProperties.spin.range.start = spinStart;
+        _needsRenderUpdate |= _particleProperties.spin.range.start != spinStart;
-        });
+        _particleProperties.spin.range.start = spinStart;
-    }
+    });
+}
+
+float ParticleEffectEntityItem::getSpinStart() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.spin.range.start;
+    });
 }
 
 void ParticleEffectEntityItem::setSpinFinish(float spinFinish) {
     spinFinish =
         glm::isnan(spinFinish) ? spinFinish : glm::clamp(spinFinish, MINIMUM_PARTICLE_SPIN, MAXIMUM_PARTICLE_SPIN);
-    if (spinFinish != _particleProperties.spin.range.finish) {
+
-        withWriteLock([&] {
+    withWriteLock([&] {
-            _particleProperties.spin.range.finish = spinFinish;
+        _needsRenderUpdate |= _particleProperties.spin.range.finish != spinFinish;
-        });
+        _particleProperties.spin.range.finish = spinFinish;
-    }
+    });
+}
+
+float ParticleEffectEntityItem::getSpinFinish() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.spin.range.finish;
+    });
 }
 
 void ParticleEffectEntityItem::setSpinSpread(float spinSpread) {
     spinSpread = glm::clamp(spinSpread, MINIMUM_PARTICLE_SPIN, MAXIMUM_PARTICLE_SPIN);
-    if (spinSpread != _particleProperties.spin.gradient.spread) {
+
-        withWriteLock([&] {
+    withWriteLock([&] {
-            _particleProperties.spin.gradient.spread = spinSpread;
+        _needsRenderUpdate |= _particleProperties.spin.gradient.spread != spinSpread;
-        });
+        _particleProperties.spin.gradient.spread = spinSpread;
-    }
+    });
+}
+
+float ParticleEffectEntityItem::getSpinSpread() const {
+    return resultWithReadLock<float>([&] {
+        return _particleProperties.spin.gradient.spread;
+    });
 }
 
 void ParticleEffectEntityItem::computeAndUpdateDimensions() {
@@ -471,6 +706,7 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(textures, setTextures);
 
@@ -529,10 +765,17 @@ bool ParticleEffectEntityItem::setProperties(const EntityItemProperties& propert
 
 void ParticleEffectEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.color.gradient.target != glm::vec3(value);
         _particleProperties.color.gradient.target = value;
     });
 }
 
+glm::u8vec3 ParticleEffectEntityItem::getColor() const {
+    return resultWithReadLock<glm::u8vec3>([&] {
+        return _particleProperties.color.gradient.target;
+    });
+}
+
 int ParticleEffectEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
                                                                ReadBitstreamToTreeParams& args,
                                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
@@ -740,6 +983,7 @@ void ParticleEffectEntityItem::setShapeType(ShapeType type) {
     }
 
     withWriteLock([&] {
+        _needsRenderUpdate |= _shapeType != type;
         _shapeType = type;
     });
 }
@@ -752,6 +996,7 @@ ShapeType ParticleEffectEntityItem::getShapeType() const {
 
 void ParticleEffectEntityItem::setCompoundShapeURL(const QString& compoundShapeURL) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _compoundShapeURL != compoundShapeURL;
         _compoundShapeURL = compoundShapeURL;
     });
 }
@@ -762,44 +1007,90 @@ QString ParticleEffectEntityItem::getCompoundShapeURL() const {
     });
 }
 
-void ParticleEffectEntityItem::setMaxParticles(quint32 maxParticles) {
+void ParticleEffectEntityItem::setIsEmitting(bool isEmitting) {
     withWriteLock([&] {
-        _particleProperties.maxParticles = glm::clamp(maxParticles, MINIMUM_MAX_PARTICLES, MAXIMUM_MAX_PARTICLES);
+        _needsRenderUpdate |= _isEmitting != isEmitting;
+        _isEmitting = isEmitting;
+    });
+}
+
+void ParticleEffectEntityItem::setMaxParticles(quint32 maxParticles) {
+    maxParticles = glm::clamp(maxParticles, MINIMUM_MAX_PARTICLES, MAXIMUM_MAX_PARTICLES);
+
+    withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.maxParticles != maxParticles;
+        _particleProperties.maxParticles = maxParticles;
+    });
+}
+
+quint32 ParticleEffectEntityItem::getMaxParticles() const {
+    return resultWithReadLock<quint32>([&] {
+        return _particleProperties.maxParticles;
     });
 }
 
 void ParticleEffectEntityItem::setTextures(const QString& textures) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.textures != textures;
         _particleProperties.textures = textures;
     });
 }
 
+QString ParticleEffectEntityItem::getTextures() const {
+    return resultWithReadLock<QString>([&] {
+        return _particleProperties.textures;
+    });
+}
+
 void ParticleEffectEntityItem::setColorStart(const vec3& colorStart) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.color.range.start != colorStart;
         _particleProperties.color.range.start = colorStart;
     });
 }
 
+glm::vec3 ParticleEffectEntityItem::getColorStart() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.color.range.start;
+    });
+}
+
 void ParticleEffectEntityItem::setColorFinish(const vec3& colorFinish) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.color.range.finish != colorFinish;
         _particleProperties.color.range.finish = colorFinish;
     });
 }
 
+glm::vec3 ParticleEffectEntityItem::getColorFinish() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.color.range.finish;
+    });
+}
+
 void ParticleEffectEntityItem::setColorSpread(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.color.gradient.spread != glm::vec3(value);
         _particleProperties.color.gradient.spread = value;
     });
 }
 
+glm::u8vec3 ParticleEffectEntityItem::getColorSpread() const {
+    return resultWithReadLock<glm::vec3>([&] {
+        return _particleProperties.color.gradient.spread;
+    });
+}
+
 void ParticleEffectEntityItem::setEmitterShouldTrail(bool emitterShouldTrail) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.emission.shouldTrail != emitterShouldTrail;
         _particleProperties.emission.shouldTrail = emitterShouldTrail;
     });
 }
 
 void ParticleEffectEntityItem::setRotateWithEntity(bool rotateWithEntity) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _particleProperties.rotateWithEntity != rotateWithEntity;
         _particleProperties.rotateWithEntity = rotateWithEntity;
     });
 }
@@ -808,34 +1099,34 @@ particle::Properties ParticleEffectEntityItem::getParticleProperties() const {
     particle::Properties result;  
     withReadLock([&] {
         result = _particleProperties;
-
-        // Special case the properties that get treated differently if they're unintialized
-        if (glm::any(glm::isnan(result.color.range.start))) {
-            result.color.range.start = getColor();
-        }
-        if (glm::any(glm::isnan(result.color.range.finish))) {
-            result.color.range.finish = getColor();
-        }
-        if (glm::isnan(result.alpha.range.start)) {
-            result.alpha.range.start = getAlpha();
-        }
-        if (glm::isnan(result.alpha.range.finish)) {
-            result.alpha.range.finish = getAlpha();
-        }
-        if (glm::isnan(result.radius.range.start)) {
-            result.radius.range.start = getParticleRadius();
-        }
-        if (glm::isnan(result.radius.range.finish)) {
-            result.radius.range.finish = getParticleRadius();
-        }
-        if (glm::isnan(result.spin.range.start)) {
-            result.spin.range.start = getParticleSpin();
-        }
-        if (glm::isnan(result.spin.range.finish)) {
-            result.spin.range.finish = getParticleSpin();
-        }
     });
 
+    // Special case the properties that get treated differently if they're unintialized
+    if (glm::any(glm::isnan(result.color.range.start))) {
+        result.color.range.start = getColor();
+    }
+    if (glm::any(glm::isnan(result.color.range.finish))) {
+        result.color.range.finish = getColor();
+    }
+    if (glm::isnan(result.alpha.range.start)) {
+        result.alpha.range.start = getAlpha();
+    }
+    if (glm::isnan(result.alpha.range.finish)) {
+        result.alpha.range.finish = getAlpha();
+    }
+    if (glm::isnan(result.radius.range.start)) {
+        result.radius.range.start = getParticleRadius();
+    }
+    if (glm::isnan(result.radius.range.finish)) {
+        result.radius.range.finish = getParticleRadius();
+    }
+    if (glm::isnan(result.spin.range.start)) {
+        result.spin.range.start = getParticleSpin();
+    }
+    if (glm::isnan(result.spin.range.finish)) {
+        result.spin.range.finish = getParticleSpin();
+    }
+
     if (!result.valid()) {
         qCWarning(entities) << "failed validation";
     }

libraries/entities/src/ParticleEffectEntityItem.h

@@ -233,29 +233,31 @@ public:
 
     bool shouldBePhysical() const override { return false; }
 
+    virtual void debugDump() const override;
+
     void setColor(const glm::u8vec3& value);
-    glm::u8vec3 getColor() const { return _particleProperties.color.gradient.target; }
+    glm::u8vec3 getColor() const;
 
     void setColorStart(const vec3& colorStart);
-    vec3 getColorStart() const { return _particleProperties.color.range.start; }
+    vec3 getColorStart() const;
 
     void setColorFinish(const vec3& colorFinish);
-    vec3 getColorFinish() const { return _particleProperties.color.range.finish; }
+    vec3 getColorFinish() const;
 
     void setColorSpread(const glm::u8vec3& colorSpread);
-    glm::u8vec3 getColorSpread() const { return _particleProperties.color.gradient.spread; }
+    glm::u8vec3 getColorSpread() const;
 
     void setAlpha(float alpha);
-    float getAlpha() const { return _particleProperties.alpha.gradient.target; }
+    float getAlpha() const;
 
     void setAlphaStart(float alphaStart);
-    float getAlphaStart() const { return _particleProperties.alpha.range.start; }
+    float getAlphaStart() const;
 
     void setAlphaFinish(float alphaFinish);
-    float getAlphaFinish() const { return _particleProperties.alpha.range.finish; }
+    float getAlphaFinish() const;
 
     void setAlphaSpread(float alphaSpread);
-    float getAlphaSpread() const { return _particleProperties.alpha.gradient.spread; }
+    float getAlphaSpread() const;
 
     void setShapeType(ShapeType type) override;
     virtual ShapeType getShapeType() const override;
@@ -263,76 +265,74 @@ public:
     QString getCompoundShapeURL() const;
     virtual void setCompoundShapeURL(const QString& url);
 
-    virtual void debugDump() const override;
-
     bool getIsEmitting() const { return _isEmitting; }
-    void setIsEmitting(bool isEmitting) { _isEmitting = isEmitting; }
+    void setIsEmitting(bool isEmitting);
 
     void setMaxParticles(quint32 maxParticles);
-    quint32 getMaxParticles() const { return _particleProperties.maxParticles; }
+    quint32 getMaxParticles() const;
 
     void setLifespan(float lifespan);
-    float getLifespan() const { return _particleProperties.lifespan; }
+    float getLifespan() const;
 
     void setEmitRate(float emitRate);
-    float getEmitRate() const { return _particleProperties.emission.rate; }
+    float getEmitRate() const;
 
     void setEmitSpeed(float emitSpeed);
-    float getEmitSpeed() const { return _particleProperties.emission.speed.target; }
+    float getEmitSpeed() const;
 
     void setSpeedSpread(float speedSpread);
-    float getSpeedSpread() const { return _particleProperties.emission.speed.spread; }
+    float getSpeedSpread() const;
 
     void setEmitOrientation(const glm::quat& emitOrientation);
-    const glm::quat& getEmitOrientation() const { return _particleProperties.emission.orientation; }
+    glm::quat getEmitOrientation() const;
 
     void setEmitDimensions(const glm::vec3& emitDimensions);
-    const glm::vec3& getEmitDimensions() const { return _particleProperties.emission.dimensions; }
+    glm::vec3 getEmitDimensions() const;
 
     void setEmitRadiusStart(float emitRadiusStart);
-    float getEmitRadiusStart() const { return _particleProperties.radiusStart; }
+    float getEmitRadiusStart() const;
 
     void setPolarStart(float polarStart);
-    float getPolarStart() const { return _particleProperties.polar.start; }
+    float getPolarStart() const;
 
     void setPolarFinish(float polarFinish);
-    float getPolarFinish() const { return _particleProperties.polar.finish; }
+    float getPolarFinish() const;
 
     void setAzimuthStart(float azimuthStart);
-    float getAzimuthStart() const { return _particleProperties.azimuth.start; }
+    float getAzimuthStart() const;
 
     void setAzimuthFinish(float azimuthFinish);
-    float getAzimuthFinish() const { return _particleProperties.azimuth.finish; }
+    float getAzimuthFinish() const;
 
     void setEmitAcceleration(const glm::vec3& emitAcceleration);
-    const glm::vec3& getEmitAcceleration() const { return _particleProperties.emission.acceleration.target; }
+    glm::vec3 getEmitAcceleration() const;
     
     void setAccelerationSpread(const glm::vec3& accelerationSpread);
-    const glm::vec3& getAccelerationSpread() const { return _particleProperties.emission.acceleration.spread; }
+    glm::vec3 getAccelerationSpread() const;
 
     void setParticleRadius(float particleRadius);
-    float getParticleRadius() const { return _particleProperties.radius.gradient.target; }
+    float getParticleRadius() const;
 
     void setRadiusStart(float radiusStart);
-    float getRadiusStart() const { return _particleProperties.radius.range.start; }
+    float getRadiusStart() const;
 
     void setRadiusFinish(float radiusFinish);
-    float getRadiusFinish() const { return _particleProperties.radius.range.finish; }
+    float getRadiusFinish() const;
 
     void setRadiusSpread(float radiusSpread);
-    float getRadiusSpread() const { return _particleProperties.radius.gradient.spread; }
+    float getRadiusSpread() const;
 
     void setParticleSpin(float particleSpin);
-    float getParticleSpin() const { return _particleProperties.spin.gradient.target; }
+    float getParticleSpin() const;
 
     void setSpinStart(float spinStart);
-    float getSpinStart() const { return _particleProperties.spin.range.start; }
+    float getSpinStart() const;
 
     void setSpinFinish(float spinFinish);
-    float getSpinFinish() const { return _particleProperties.spin.range.finish; }
+    float getSpinFinish() const;
 
     void setSpinSpread(float spinSpread);
-    float getSpinSpread() const { return _particleProperties.spin.gradient.spread; }
+    float getSpinSpread() const;
 
     void setRotateWithEntity(bool rotateWithEntity);
     bool getRotateWithEntity() const { return _particleProperties.rotateWithEntity; }
@@ -340,10 +340,10 @@ public:
     void computeAndUpdateDimensions();
 
     void setTextures(const QString& textures);
-    QString getTextures() const { return _particleProperties.textures; }
+    QString getTextures() const;
 
-    bool getEmitterShouldTrail() const { return _particleProperties.emission.shouldTrail; }
     void setEmitterShouldTrail(bool emitterShouldTrail);
+    bool getEmitterShouldTrail() const { return _particleProperties.emission.shouldTrail; }
 
     virtual bool supportsDetailedIntersection() const override { return false; }
 

libraries/entities/src/PolyLineEntityItem.cpp

@@ -247,3 +247,24 @@ glm::u8vec3 PolyLineEntityItem::getColor() const {
         return _color;
     });
 }
+
+void PolyLineEntityItem::setIsUVModeStretch(bool isUVModeStretch) {
+    withWriteLock([&] {
+        _needsRenderUpdate = _isUVModeStretch != isUVModeStretch;
+        _isUVModeStretch = isUVModeStretch;
+    });
+}
+
+void PolyLineEntityItem::setGlow(bool glow) {
+    withWriteLock([&] {
+        _needsRenderUpdate = _glow != glow;
+        _glow = glow;
+    });
+}
+
+void PolyLineEntityItem::setFaceCamera(bool faceCamera) {
+    withWriteLock([&] {
+        _needsRenderUpdate = _faceCamera != faceCamera;
+        _faceCamera = faceCamera;
+    });
+}

libraries/entities/src/PolyLineEntityItem.h

@@ -58,16 +58,16 @@ class PolyLineEntityItem : public EntityItem {
     void setStrokeColors(const QVector<glm::vec3>& strokeColors);
     QVector<glm::vec3> getStrokeColors() const;
 
-    void setIsUVModeStretch(bool isUVModeStretch){ _isUVModeStretch = isUVModeStretch; }
+    void setIsUVModeStretch(bool isUVModeStretch);
     bool getIsUVModeStretch() const{ return _isUVModeStretch; }
 
     QString getTextures() const;
     void setTextures(const QString& textures);
 
-    void setGlow(bool glow) { _glow = glow; }
+    void setGlow(bool glow);
     bool getGlow() const { return _glow; }
 
-    void setFaceCamera(bool faceCamera) { _faceCamera = faceCamera; }
+    void setFaceCamera(bool faceCamera);
     bool getFaceCamera() const { return _faceCamera; }
 
     bool pointsChanged() const { return _pointsChanged; } 

libraries/entities/src/PolyVoxEntityItem.cpp

@@ -70,37 +70,12 @@ PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID) : EntityI
     _type = EntityTypes::PolyVox;
 }
 
-void PolyVoxEntityItem::setVoxelVolumeSize(const glm::vec3& voxelVolumeSize) {
+void PolyVoxEntityItem::setVoxelVolumeSize(const glm::vec3& voxelVolumeSize_) {
+    auto voxelVolumeSize = glm::clamp(glm::round(voxelVolumeSize_), glm::vec3(1.0f), glm::vec3(MAX_VOXEL_DIMENSION));
+
     withWriteLock([&] {
-        assert(!glm::any(glm::isnan(voxelVolumeSize)));
+        _needsRenderUpdate |= _voxelVolumeSize != voxelVolumeSize;
-
+        _voxelVolumeSize = voxelVolumeSize;
-        _voxelVolumeSize = glm::vec3(roundf(voxelVolumeSize.x), roundf(voxelVolumeSize.y), roundf(voxelVolumeSize.z));
-        if (_voxelVolumeSize.x < 1) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping x of" << _voxelVolumeSize.x << "to 1";
-            _voxelVolumeSize.x = 1;
-        }
-        if (_voxelVolumeSize.x > MAX_VOXEL_DIMENSION) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping x of" << _voxelVolumeSize.x << "to max";
-            _voxelVolumeSize.x = MAX_VOXEL_DIMENSION;
-        }
-
-        if (_voxelVolumeSize.y < 1) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping y of" << _voxelVolumeSize.y << "to 1";
-            _voxelVolumeSize.y = 1;
-        }
-        if (_voxelVolumeSize.y > MAX_VOXEL_DIMENSION) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping y of" << _voxelVolumeSize.y << "to max";
-            _voxelVolumeSize.y = MAX_VOXEL_DIMENSION;
-        }
-
-        if (_voxelVolumeSize.z < 1) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping z of" << _voxelVolumeSize.z << "to 1";
-            _voxelVolumeSize.z = 1;
-        }
-        if (_voxelVolumeSize.z > MAX_VOXEL_DIMENSION) {
-            qCDebug(entities) << "PolyVoxEntityItem::setVoxelVolumeSize clamping z of" << _voxelVolumeSize.z << "to max";
-            _voxelVolumeSize.z = MAX_VOXEL_DIMENSION;
-        }
     });
 }
 
@@ -247,13 +222,14 @@ QByteArray PolyVoxEntityItem::getVoxelData() const {
 }
 
 
-void PolyVoxEntityItem::setXTextureURL(const QString& xTextureURL) { 
+void PolyVoxEntityItem::setXTextureURL(const QString& xTextureURL) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _xTextureURL != xTextureURL;
         _xTextureURL = xTextureURL;
     });
 }
 
-QString PolyVoxEntityItem::getXTextureURL() const { 
+QString PolyVoxEntityItem::getXTextureURL() const {
     QString result;
     withReadLock([&] {
         result = _xTextureURL;
@@ -263,11 +239,12 @@ QString PolyVoxEntityItem::getXTextureURL() const {
 
 void PolyVoxEntityItem::setYTextureURL(const QString& yTextureURL) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _yTextureURL != yTextureURL;
         _yTextureURL = yTextureURL;
     });
 }
 
-QString PolyVoxEntityItem::getYTextureURL() const { 
+QString PolyVoxEntityItem::getYTextureURL() const {
     QString result;
     withReadLock([&] {
         result = _yTextureURL;
@@ -277,10 +254,11 @@ QString PolyVoxEntityItem::getYTextureURL() const {
 
 void PolyVoxEntityItem::setZTextureURL(const QString& zTextureURL) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _zTextureURL != zTextureURL;
         _zTextureURL = zTextureURL;
     });
 }
-QString PolyVoxEntityItem::getZTextureURL() const { 
+QString PolyVoxEntityItem::getZTextureURL() const {
     QString result;
     withReadLock([&] {
         result = _zTextureURL;
@@ -288,13 +266,13 @@ QString PolyVoxEntityItem::getZTextureURL() const {
     return result;
 }
 
-void PolyVoxEntityItem::setXNNeighborID(const EntityItemID& xNNeighborID) { 
+void PolyVoxEntityItem::setXNNeighborID(const EntityItemID& xNNeighborID) {
     withWriteLock([&] {
         _xNNeighborID = xNNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getXNNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getXNNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _xNNeighborID;
@@ -302,13 +280,13 @@ EntityItemID PolyVoxEntityItem::getXNNeighborID() const {
     return result;
 }
 
-void PolyVoxEntityItem::setYNNeighborID(const EntityItemID& yNNeighborID) { 
+void PolyVoxEntityItem::setYNNeighborID(const EntityItemID& yNNeighborID) {
     withWriteLock([&] {
         _yNNeighborID = yNNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getYNNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getYNNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _yNNeighborID;
@@ -316,13 +294,13 @@ EntityItemID PolyVoxEntityItem::getYNNeighborID() const {
     return result;
 }
 
-void PolyVoxEntityItem::setZNNeighborID(const EntityItemID& zNNeighborID) { 
+void PolyVoxEntityItem::setZNNeighborID(const EntityItemID& zNNeighborID) {
     withWriteLock([&] {
         _zNNeighborID = zNNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getZNNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getZNNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _zNNeighborID;
@@ -330,13 +308,13 @@ EntityItemID PolyVoxEntityItem::getZNNeighborID() const {
     return result;
 }
 
-void PolyVoxEntityItem::setXPNeighborID(const EntityItemID& xPNeighborID) { 
+void PolyVoxEntityItem::setXPNeighborID(const EntityItemID& xPNeighborID) {
     withWriteLock([&] {
         _xPNeighborID = xPNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getXPNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getXPNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _xPNeighborID;
@@ -344,13 +322,13 @@ EntityItemID PolyVoxEntityItem::getXPNeighborID() const {
     return result;
 }
 
-void PolyVoxEntityItem::setYPNeighborID(const EntityItemID& yPNeighborID) { 
+void PolyVoxEntityItem::setYPNeighborID(const EntityItemID& yPNeighborID) {
     withWriteLock([&] {
         _yPNeighborID = yPNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getYPNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getYPNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _yPNeighborID;
@@ -358,13 +336,13 @@ EntityItemID PolyVoxEntityItem::getYPNeighborID() const {
     return result;
 }
 
-void PolyVoxEntityItem::setZPNeighborID(const EntityItemID& zPNeighborID) { 
+void PolyVoxEntityItem::setZPNeighborID(const EntityItemID& zPNeighborID) {
     withWriteLock([&] {
         _zPNeighborID = zPNeighborID;
     });
 }
 
-EntityItemID PolyVoxEntityItem::getZPNeighborID() const { 
+EntityItemID PolyVoxEntityItem::getZPNeighborID() const {
     EntityItemID result;
     withReadLock([&] {
         result = _zPNeighborID;

libraries/entities/src/ShapeEntityItem.cpp

@@ -129,9 +129,7 @@ EntityItemProperties ShapeEntityItem::getProperties(const EntityPropertyFlags& d
 }
 
 void ShapeEntityItem::setShape(const entity::Shape& shape) {
-    const entity::Shape prevShape = _shape;
+    switch (shape) {
-    _shape = shape;
-    switch (_shape) {
         case entity::Shape::Cube:
             _type = EntityTypes::Box;
             break;
@@ -151,12 +149,22 @@ void ShapeEntityItem::setShape(const entity::Shape& shape) {
             break;
     }
 
-    if (_shape != prevShape) {
+    if (shape != getShape()) {
         // Internally grabs writeLock
         markDirtyFlags(Simulation::DIRTY_SHAPE);
+        withWriteLock([&] {
+            _needsRenderUpdate = true;
+            _shape = shape;
+        });
     }
 }
 
+entity::Shape ShapeEntityItem::getShape() const {
+    return resultWithReadLock<entity::Shape>([&] {
+        return _shape;
+    });
+}
+
 bool ShapeEntityItem::setProperties(const EntityItemProperties& properties) {
     bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
 
@@ -165,6 +173,7 @@ bool ShapeEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(shape, setShape);
 
@@ -232,6 +241,7 @@ void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
 
 void ShapeEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != value;
         _color = value;
     });
 }
@@ -244,6 +254,7 @@ glm::u8vec3 ShapeEntityItem::getColor() const {
 
 void ShapeEntityItem::setAlpha(float alpha) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _alpha != alpha;
         _alpha = alpha;
     });
 }

libraries/entities/src/ShapeEntityItem.h

@@ -72,7 +72,7 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                 bool& somethingChanged) override;
 
-    entity::Shape getShape() const { return _shape; }
+    entity::Shape getShape() const;
     void setShape(const entity::Shape& shape);
     void setShape(const QString& shape) { setShape(entity::shapeFromString(shape)); }
 

libraries/entities/src/TextEntityItem.cpp

@@ -80,6 +80,7 @@ bool TextEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(billboardMode, setBillboardMode);
 
@@ -180,7 +181,7 @@ void TextEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
                                     EntityPropertyFlags& propertyFlags,
                                     EntityPropertyFlags& propertiesDidntFit,
                                     int& propertyCount, 
-                                    OctreeElement::AppendState& appendState) const { 
+                                    OctreeElement::AppendState& appendState) const {
 
     bool successPropertyFits = true;
 
@@ -272,6 +273,7 @@ bool TextEntityItem::findDetailedParabolaIntersection(const glm::vec3& origin, c
 
 void TextEntityItem::setText(const QString& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _text != value;
         _text = value;
     });
 }
@@ -282,13 +284,14 @@ QString TextEntityItem::getText() const {
     });
 }
 
-void TextEntityItem::setLineHeight(float value) { 
+void TextEntityItem::setLineHeight(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _lineHeight != value;
         _lineHeight = value;
     });
 }
 
-float TextEntityItem::getLineHeight() const { 
+float TextEntityItem::getLineHeight() const {
     float result;
     withReadLock([&] {
         result = _lineHeight;
@@ -298,6 +301,7 @@ float TextEntityItem::getLineHeight() const {
 
 void TextEntityItem::setTextColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _textColor != value;
         _textColor = value;
     });
 }
@@ -310,6 +314,7 @@ glm::u8vec3 TextEntityItem::getTextColor() const {
 
 void TextEntityItem::setTextAlpha(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _textAlpha != value;
         _textAlpha = value;
     });
 }
@@ -322,6 +327,7 @@ float TextEntityItem::getTextAlpha() const {
 
 void TextEntityItem::setBackgroundColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _backgroundColor != value;
         _backgroundColor = value;
     });
 }
@@ -334,6 +340,7 @@ glm::u8vec3 TextEntityItem::getBackgroundColor() const {
 
 void TextEntityItem::setBackgroundAlpha(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _backgroundAlpha != value;
         _backgroundAlpha = value;
     });
 }
@@ -354,12 +361,14 @@ BillboardMode TextEntityItem::getBillboardMode() const {
 
 void TextEntityItem::setBillboardMode(BillboardMode value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _billboardMode != value;
         _billboardMode = value;
     });
 }
 
 void TextEntityItem::setLeftMargin(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _leftMargin != value;
         _leftMargin = value;
     });
 }
@@ -372,6 +381,7 @@ float TextEntityItem::getLeftMargin() const {
 
 void TextEntityItem::setRightMargin(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _rightMargin != value;
         _rightMargin = value;
     });
 }
@@ -384,6 +394,7 @@ float TextEntityItem::getRightMargin() const {
 
 void TextEntityItem::setTopMargin(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _topMargin != value;
         _topMargin = value;
     });
 }
@@ -396,6 +407,7 @@ float TextEntityItem::getTopMargin() const {
 
 void TextEntityItem::setBottomMargin(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _bottomMargin != value;
         _bottomMargin = value;
     });
 }
@@ -408,6 +420,7 @@ float TextEntityItem::getBottomMargin() const {
 
 void TextEntityItem::setUnlit(bool value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _unlit != value;
         _unlit = value;
     });
 }
@@ -420,6 +433,7 @@ bool TextEntityItem::getUnlit() const {
 
 void TextEntityItem::setFont(const QString& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _font != value;
         _font = value;
     });
 }
@@ -432,6 +446,7 @@ QString TextEntityItem::getFont() const {
 
 void TextEntityItem::setTextEffect(TextEffect value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _effect != value;
         _effect = value;
     });
 }
@@ -444,6 +459,7 @@ TextEffect TextEntityItem::getTextEffect() const {
 
 void TextEntityItem::setTextEffectColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _effectColor != value;
         _effectColor = value;
     });
 }
@@ -456,6 +472,7 @@ glm::u8vec3 TextEntityItem::getTextEffectColor() const {
 
 void TextEntityItem::setTextEffectThickness(float value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _effectThickness != value;
         _effectThickness = value;
     });
 }

libraries/entities/src/WebEntityItem.cpp

@@ -68,6 +68,7 @@ bool WebEntityItem::setProperties(const EntityItemProperties& properties) {
     withWriteLock([&] {
         bool pulsePropertiesChanged = _pulseProperties.setProperties(properties);
         somethingChanged |= pulsePropertiesChanged;
+        _needsRenderUpdate |= pulsePropertiesChanged;
     });
     SET_ENTITY_PROPERTY_FROM_PROPERTIES(billboardMode, setBillboardMode);
 
@@ -229,6 +230,7 @@ bool WebEntityItem::findDetailedParabolaIntersection(const glm::vec3& origin, co
 
 void WebEntityItem::setColor(const glm::u8vec3& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _color != value;
         _color = value;
     });
 }
@@ -241,6 +243,7 @@ glm::u8vec3 WebEntityItem::getColor() const {
 
 void WebEntityItem::setAlpha(float alpha) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _alpha != alpha;
         _alpha = alpha;
     });
 }
@@ -259,12 +262,14 @@ BillboardMode WebEntityItem::getBillboardMode() const {
 
 void WebEntityItem::setBillboardMode(BillboardMode value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _billboardMode != value;
         _billboardMode = value;
     });
 }
 
 void WebEntityItem::setSourceUrl(const QString& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _sourceUrl != value;
         _sourceUrl = value;
     });
 }
@@ -277,6 +282,7 @@ QString WebEntityItem::getSourceUrl() const {
 
 void WebEntityItem::setDPI(uint16_t value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _dpi != value;
         _dpi = value;
     });
 }
@@ -288,16 +294,18 @@ uint16_t WebEntityItem::getDPI() const {
 }
 
 void WebEntityItem::setScriptURL(const QString& value) {
-    withWriteLock([&] {
+    auto newURL = QUrl::fromUserInput(value);
-        if (_scriptURL != value) {
-            auto newURL = QUrl::fromUserInput(value);
 
-            if (newURL.isValid()) {
+    if (!newURL.isValid()) {
-                _scriptURL = newURL.toDisplayString();
-            } else {
                 qCDebug(entities) << "Not setting web entity script URL since" << value << "cannot be parsed to a valid URL.";
-            }
+        return;
-        }
+    }
+
+    auto urlString = newURL.toDisplayString();
+
+    withWriteLock([&] {
+        _needsRenderUpdate |= _scriptURL != urlString;
+        _scriptURL = urlString;
     });
 }
 
@@ -309,6 +317,7 @@ QString WebEntityItem::getScriptURL() const {
 
 void WebEntityItem::setMaxFPS(uint8_t value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _maxFPS != value;
         _maxFPS = value;
     });
 }
@@ -321,6 +330,7 @@ uint8_t WebEntityItem::getMaxFPS() const {
 
 void WebEntityItem::setInputMode(const WebInputMode& value) {
     withWriteLock([&] {
+        _needsRenderUpdate |= _inputMode != value;
         _inputMode = value;
     });
 }