Fix crashes in entity rendering on OSX

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp

@@ -91,20 +91,27 @@ void ParticleEffectEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePoi
             qCWarning(entitiesrenderer) << "Bad particle properties";
         }
     }
-    if (_particleProperties != newParticleProperties) {
+    
+    if (resultWithReadLock<bool>([&]{ return _particleProperties != newParticleProperties; })) {
         _timeUntilNextEmit = 0;
-        _particleProperties = newParticleProperties;
+        withWriteLock([&]{
+            _particleProperties = newParticleProperties;
+        });
     }
     _emitting = entity->getIsEmitting();
 
-    if (_particleProperties.textures.isEmpty()) {
+    bool hasTexture = resultWithReadLock<bool>([&]{ return _particleProperties.textures.isEmpty(); });
+    if (hasTexture) {
         if (_networkTexture) {
             withWriteLock([&] { 
                 _networkTexture.reset();
             });
         }
     } else {
-        if (!_networkTexture || _networkTexture->getURL() != QUrl(_particleProperties.textures)) {
+        bool textureNeedsUpdate = resultWithReadLock<bool>([&]{
+            return !_networkTexture || _networkTexture->getURL() != QUrl(_particleProperties.textures);
+        });
+        if (textureNeedsUpdate) {
             withWriteLock([&] { 
                 _networkTexture = DependencyManager::get<TextureCache>()->getTexture(_particleProperties.textures);
             });
@@ -115,15 +122,17 @@ void ParticleEffectEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePoi
 void ParticleEffectEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) {
     // Fill in Uniforms structure
     ParticleUniforms particleUniforms;
-    particleUniforms.radius.start = _particleProperties.radius.range.start;
+    withReadLock([&]{
-    particleUniforms.radius.middle = _particleProperties.radius.gradient.target;
+        particleUniforms.radius.start = _particleProperties.radius.range.start;
-    particleUniforms.radius.finish = _particleProperties.radius.range.finish;
+        particleUniforms.radius.middle = _particleProperties.radius.gradient.target;
-    particleUniforms.radius.spread = _particleProperties.radius.gradient.spread;
+        particleUniforms.radius.finish = _particleProperties.radius.range.finish;
-    particleUniforms.color.start = _particleProperties.getColorStart();
+        particleUniforms.radius.spread = _particleProperties.radius.gradient.spread;
-    particleUniforms.color.middle = _particleProperties.getColorMiddle();
+        particleUniforms.color.start = _particleProperties.getColorStart();
-    particleUniforms.color.finish = _particleProperties.getColorFinish();
+        particleUniforms.color.middle = _particleProperties.getColorMiddle();
-    particleUniforms.color.spread = _particleProperties.getColorSpread();
+        particleUniforms.color.finish = _particleProperties.getColorFinish();
-    particleUniforms.lifespan = _particleProperties.lifespan;
+        particleUniforms.color.spread = _particleProperties.getColorSpread();
+        particleUniforms.lifespan = _particleProperties.lifespan;
+    });
     // Update particle uniforms
     memcpy(&_uniformBuffer.edit<ParticleUniforms>(), &particleUniforms, sizeof(ParticleUniforms));
 }
@@ -146,35 +155,26 @@ Item::Bound ParticleEffectEntityRenderer::getBound() {
 
 static const size_t VERTEX_PER_PARTICLE = 4;
 
-bool ParticleEffectEntityRenderer::emitting() const {
+ParticleEffectEntityRenderer::CpuParticle ParticleEffectEntityRenderer::createParticle(uint64_t now, const Transform& baseTransform, const particle::Properties& particleProperties) {
-    return (
-        _emitting &&
-        _particleProperties.emission.rate > 0.0f &&
-        _particleProperties.lifespan > 0.0f &&
-        _particleProperties.polar.start <= _particleProperties.polar.finish
-    );
-}
-
-void ParticleEffectEntityRenderer::createParticle(uint64_t now) {
     CpuParticle particle;
 
-    const auto& accelerationSpread = _particleProperties.emission.acceleration.spread;
+    const auto& accelerationSpread = particleProperties.emission.acceleration.spread;
-    const auto& azimuthStart = _particleProperties.azimuth.start;
+    const auto& azimuthStart = particleProperties.azimuth.start;
-    const auto& azimuthFinish = _particleProperties.azimuth.finish;
+    const auto& azimuthFinish = particleProperties.azimuth.finish;
-    const auto& emitDimensions = _particleProperties.emission.dimensions;
+    const auto& emitDimensions = particleProperties.emission.dimensions;
-    const auto& emitAcceleration = _particleProperties.emission.acceleration.target;
+    const auto& emitAcceleration = particleProperties.emission.acceleration.target;
-    auto emitOrientation = _particleProperties.emission.orientation;
+    auto emitOrientation = particleProperties.emission.orientation;
-    const auto& emitRadiusStart = glm::max(_particleProperties.radiusStart, EPSILON); // Avoid math complications at center
+    const auto& emitRadiusStart = glm::max(particleProperties.radiusStart, EPSILON); // Avoid math complications at center
-    const auto& emitSpeed = _particleProperties.emission.speed.target;
+    const auto& emitSpeed = particleProperties.emission.speed.target;
-    const auto& speedSpread = _particleProperties.emission.speed.spread;
+    const auto& speedSpread = particleProperties.emission.speed.spread;
-    const auto& polarStart = _particleProperties.polar.start;
+    const auto& polarStart = particleProperties.polar.start;
-    const auto& polarFinish = _particleProperties.polar.finish;
+    const auto& polarFinish = particleProperties.polar.finish;
 
     particle.seed = randFloatInRange(-1.0f, 1.0f);
-    particle.expiration = now + (uint64_t)(_particleProperties.lifespan * USECS_PER_SECOND);
+    particle.expiration = now + (uint64_t)(particleProperties.lifespan * USECS_PER_SECOND);
-    if (_particleProperties.emission.shouldTrail) {
+    if (particleProperties.emission.shouldTrail) {
-        particle.position = _modelTransform.getTranslation();
+        particle.position = baseTransform.getTranslation();
-        emitOrientation = _modelTransform.getRotation() * emitOrientation;
+        emitOrientation = baseTransform.getRotation() * emitOrientation;
     }
 
     // Position, velocity, and acceleration
@@ -232,7 +232,7 @@ void ParticleEffectEntityRenderer::createParticle(uint64_t now) {
         particle.acceleration = emitAcceleration + randFloatInRange(-1.0f, 1.0f) * accelerationSpread;
     }
 
-    _cpuParticles.push_back(particle);
+    return particle;
 }
 
 void ParticleEffectEntityRenderer::stepSimulation() {
@@ -244,14 +244,19 @@ void ParticleEffectEntityRenderer::stepSimulation() {
     const auto now = usecTimestampNow();
     const auto interval = std::min<uint64_t>(USECS_PER_SECOND / 60, now - _lastSimulated);
     _lastSimulated = now;
+    
+    particle::Properties particleProperties;
+    withReadLock([&]{
+        particleProperties = _particleProperties;
+    });
 
-    if (emitting()) {
+    if (_emitting && particleProperties.emitting()) {
-        uint64_t emitInterval = (uint64_t)(USECS_PER_SECOND / _particleProperties.emission.rate);
+        uint64_t emitInterval = particleProperties.emitIntervalUsecs();
-        if (interval >= _timeUntilNextEmit) {
+        if (emitInterval > 0 && interval >= _timeUntilNextEmit) {
             auto timeRemaining = interval;
             while (timeRemaining > _timeUntilNextEmit) {
                 // emit particle
-                createParticle(now);
+                _cpuParticles.push_back(createParticle(now, _modelTransform, particleProperties));
                 _timeUntilNextEmit = emitInterval;
                 if (emitInterval < timeRemaining) {
                     timeRemaining -= emitInterval;
@@ -263,7 +268,7 @@ void ParticleEffectEntityRenderer::stepSimulation() {
     }
 
     // Kill any particles that have expired or are over the max size
-    while (_cpuParticles.size() > _particleProperties.maxParticles || (!_cpuParticles.empty() && _cpuParticles.front().expiration <= now)) {
+    while (_cpuParticles.size() > particleProperties.maxParticles || (!_cpuParticles.empty() && _cpuParticles.front().expiration <= now)) {
         _cpuParticles.pop_front();
     }
 

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h

@@ -93,9 +93,8 @@ private:
     };
 
 
-    void createParticle(uint64_t now);
+    static CpuParticle createParticle(uint64_t now, const Transform& baseTransform, const particle::Properties& particleProperties);
     void stepSimulation();
-    bool emitting() const;
 
     particle::Properties _particleProperties;
     CpuParticles _cpuParticles;

libraries/entities-renderer/src/RenderableTextEntityItem.cpp

@@ -30,14 +30,11 @@ TextEntityRenderer::TextEntityRenderer(const EntityItemPointer& entity) :
 
 }
 
-
+TextEntityRenderer::~TextEntityRenderer() {
-void TextEntityRenderer::onRemoveFromSceneTyped(const TypedEntityPointer& entity) {
     auto geometryCache = DependencyManager::get<GeometryCache>();
     if (_geometryID && geometryCache) {
         geometryCache->releaseID(_geometryID);
     }
-    delete _textRenderer;
-    _textRenderer = nullptr;
 }
 
 bool TextEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const {

libraries/entities-renderer/src/RenderableTextEntityItem.h

@@ -24,14 +24,13 @@ class TextEntityRenderer : public TypedEntityRenderer<TextEntityItem> {
     using Pointer = std::shared_ptr<TextEntityRenderer>;
 public:
     TextEntityRenderer(const EntityItemPointer& entity);
-
+    ~TextEntityRenderer();
 private:
-    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;
     int _geometryID{ 0 };
-    TextRenderer3D* _textRenderer;
+    std::shared_ptr<TextRenderer3D> _textRenderer;
     bool _faceCamera;
     glm::vec3 _dimensions;
     glm::vec3 _textColor;

libraries/entities/src/ParticleEffectEntityItem.cpp

@@ -104,7 +104,7 @@ bool operator!=(const Properties& a, const Properties& b) {
     return !(a == b);
 }
 
-bool particle::Properties::valid() const {
+bool Properties::valid() const {
     if (glm::any(glm::isnan(emission.orientation))) {
         qCWarning(entities) << "Bad particle data";
         return false;
@@ -133,6 +133,19 @@ bool particle::Properties::valid() const {
         (radius.gradient.spread == glm::clamp(radius.gradient.spread, MINIMUM_PARTICLE_RADIUS, MAXIMUM_PARTICLE_RADIUS));
 }
 
+bool Properties::emitting() const {
+    return emission.rate > 0.0f && lifespan > 0.0f && polar.start <= polar.finish;
+    
+}
+
+uint64_t Properties::emitIntervalUsecs() const {
+    if (emission.rate > 0.0f) {
+        return (uint64_t)(USECS_PER_SECOND / emission.rate);
+    }
+    return 0;
+}
+
+
 EntityItemPointer ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     EntityItemPointer entity { new ParticleEffectEntityItem(entityID) };
     entity->setProperties(properties);

libraries/entities/src/ParticleEffectEntityItem.h

@@ -160,7 +160,9 @@ namespace particle {
         Properties() {};
         Properties(const Properties& other) { *this = other; }
         bool valid() const;
-
+        bool emitting() const;
+        uint64_t emitIntervalUsecs() const;
+        
         Properties& operator =(const Properties& other) {
             color = other.color;
             alpha = other.alpha;