place burden of adding/removing to/from scene on entity

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -96,18 +96,11 @@ void EntityTreeRenderer::clear() {
     OctreeRenderer::clear();
     _entityScripts.clear();
 
-    qDebug() << "EntityTreeRenderer::clear() need to clear the scene... ";
+    auto scene = _viewState->getMain3DScene();
-    render::Scene::PendingChanges pendingChanges;
+    foreach(auto entity, _entitiesInScene) {
-
+        entity->removeFromScene(entity, scene);
-    QList<EntityItemID> keys = _entityToSceneItems.uniqueKeys();
-    for (auto key : keys) {
-        QList<render::ItemID> values = _entityToSceneItems.values(key);
-        for (auto renderItem : values) {
-            pendingChanges.removeItem(renderItem);
-        }
     }
-    _entityToSceneItems.clear();
+    _entitiesInScene.clear();
-    _viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
 }
 
 void EntityTreeRenderer::init() {
@@ -1072,15 +1065,11 @@ void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) {
     _entityScripts.remove(entityID);
     
     // here's where we remove the entity payload from the scene
-
+    auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
-    render::Scene::PendingChanges pendingChanges;
+    if (entity && _entitiesInScene.contains(entity)) {
-    if (_entityToSceneItems.contains(entityID)) {
+        auto scene = _viewState->getMain3DScene();
-        
+        entity->removeFromScene(entity, scene);
-        QList<render::ItemID> values = _entityToSceneItems.values(entityID);
+        _entitiesInScene.remove(entity);
-        for (render::ItemID renderItem : values) {
-            pendingChanges.removeItem(renderItem);
-        }
-        _viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
     }
 }
 
@@ -1088,19 +1077,12 @@ void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
     checkAndCallPreload(entityID);
 
     // here's where we add the entity payload to the scene
-    EntityItemPointer entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
+    auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
-    if (entity->canRenderInScene()) {
+    if (entity && entity->canRenderInScene()) {
-        render::Scene::PendingChanges pendingChanges;
+        auto scene = _viewState->getMain3DScene();
-        render::ItemID renderItem = _viewState->getMain3DScene()->allocateID();
+        if (entity->addToScene(entity, scene)) {
-        _entityToSceneItems.insert(entityID, renderItem);
+            _entitiesInScene.insert(entity);
-
+        }
-        auto renderData = RenderableEntityItem::Pointer(new RenderableEntityItem(entity));
-        auto renderPayload = render::PayloadPointer(new RenderableEntityItem::Payload(renderData));
-
-        pendingChanges.resetItem(renderItem, renderPayload);
-
-        _viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
-        _viewState->getMain3DScene()->processPendingChangesQueue();
     }
 }
 

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -187,7 +187,7 @@ private:
     float _previousStageHour;
     int _previousStageDay;
     
-    QMultiHash<EntityItemID, render::ItemID> _entityToSceneItems;
+    QSet<EntityItemPointer> _entitiesInScene;
 };
 
 

libraries/entities-renderer/src/RenderableBoxEntityItem.h

@@ -14,6 +14,7 @@
 
 #include <BoxEntityItem.h>
 #include "RenderableDebugableEntityItem.h"
+#include "RenderableEntityItem.h"
 
 class RenderableBoxEntityItem : public BoxEntityItem {
 public:
@@ -24,6 +25,12 @@ public:
         { }
 
     virtual void render(RenderArgs* args);
+
+    virtual bool canRenderInScene() { return true; } // we use our _renderHelper to render in scene
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { return _renderHelper.addToScene(self, scene); }
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { _renderHelper.removeFromScene(self, scene); }
+private:
+    SingleRenderableEntityItem _renderHelper;
 };
 
 

libraries/entities-renderer/src/RenderableEntityItem.cpp

@@ -13,17 +13,17 @@
 #include "RenderableEntityItem.h"
 
 namespace render {
-    template <> const ItemKey payloadGetKey(const RenderableEntityItem::Pointer& payload) { 
+    template <> const ItemKey payloadGetKey(const RenderableEntityItemProxy::Pointer& payload) { 
         return ItemKey::Builder::opaqueShape();
     }
     
-    template <> const Item::Bound payloadGetBound(const RenderableEntityItem::Pointer& payload) { 
+    template <> const Item::Bound payloadGetBound(const RenderableEntityItemProxy::Pointer& payload) { 
         if (payload && payload->entity) {
             return payload->entity->getAABox();
         }
         return render::Item::Bound();
     }
-    template <> void payloadRender(const RenderableEntityItem::Pointer& payload, RenderArgs* args) {
+    template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args) {
         if (args) {
             args->_elementsTouched++;
             if (payload && payload->entity) {

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -15,19 +15,47 @@
 #include <render/Scene.h>
 #include <EntityItem.h>
 
-class RenderableEntityItem {
+
+class RenderableEntityItemProxy {
 public:
-    RenderableEntityItem(EntityItemPointer entity) : entity(entity) { }
+    RenderableEntityItemProxy(EntityItemPointer entity) : entity(entity) { }
-    typedef render::Payload<RenderableEntityItem> Payload;
+    typedef render::Payload<RenderableEntityItemProxy> Payload;
     typedef Payload::DataPointer Pointer;
     
     EntityItemPointer entity;
 };
 
 namespace render {
-   template <> const ItemKey payloadGetKey(const RenderableEntityItem::Pointer& payload); 
+   template <> const ItemKey payloadGetKey(const RenderableEntityItemProxy::Pointer& payload); 
-   template <> const Item::Bound payloadGetBound(const RenderableEntityItem::Pointer& payload);
+   template <> const Item::Bound payloadGetBound(const RenderableEntityItemProxy::Pointer& payload);
-   template <> void payloadRender(const RenderableEntityItem::Pointer& payload, RenderArgs* args);
+   template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args);
 }
 
+// Mixin class for implementing basic single item rendering
+class SingleRenderableEntityItem {
+public:
+    bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) {
+        render::Scene::PendingChanges pendingChanges;
+        _myItem = scene->allocateID();
+        
+        auto renderData = RenderableEntityItemProxy::Pointer(new RenderableEntityItemProxy(self));
+        auto renderPayload = render::PayloadPointer(new RenderableEntityItemProxy::Payload(renderData));
+        
+        pendingChanges.resetItem(_myItem, renderPayload);
+        
+        scene->enqueuePendingChanges(pendingChanges);
+        return true;
+    }
+
+    void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) {
+        render::Scene::PendingChanges pendingChanges;
+        pendingChanges.removeItem(_myItem);
+        scene->enqueuePendingChanges(pendingChanges);
+    }
+    
+private:
+    render::ItemID _myItem;
+};
+
+
 #endif // hifi_RenderableEntityItem_h

libraries/entities-renderer/src/RenderableLineEntityItem.h

@@ -14,6 +14,7 @@
 
 #include <LineEntityItem.h>
 #include "RenderableDebugableEntityItem.h"
+#include "RenderableEntityItem.h"
 
 class RenderableLineEntityItem : public LineEntityItem {
 public:
@@ -23,6 +24,12 @@ public:
         LineEntityItem(entityItemID, properties) { }
 
     virtual void render(RenderArgs* args);
+
+    virtual bool canRenderInScene() { return true; } // we use our _renderHelper to render in scene
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { return _renderHelper.addToScene(self, scene); }
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { _renderHelper.removeFromScene(self, scene); }
+private:
+    SingleRenderableEntityItem _renderHelper;
 };
 
 

libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h

@@ -13,6 +13,7 @@
 
 #include <ParticleEffectEntityItem.h>
 #include <TextureCache.h>
+#include "RenderableEntityItem.h"
 
 class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem  {
 public:
@@ -22,6 +23,12 @@ public:
 
     void updateQuads(RenderArgs* args, bool textured);
 
+    virtual bool canRenderInScene() { return true; } // we use our _renderHelper to render in scene
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { return _renderHelper.addToScene(self, scene); }
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { _renderHelper.removeFromScene(self, scene); }
+private:
+    SingleRenderableEntityItem _renderHelper;
+
 protected:
 
     int _cacheID;

libraries/entities-renderer/src/RenderableSphereEntityItem.h

@@ -14,6 +14,8 @@
 
 #include <SphereEntityItem.h>
 
+#include "RenderableEntityItem.h"
+
 class RenderableSphereEntityItem : public SphereEntityItem  {
 public:
     static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
@@ -23,6 +25,12 @@ public:
         { }
 
     virtual void render(RenderArgs* args);
+
+    virtual bool canRenderInScene() { return true; } // we use our _renderHelper to render in scene
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { return _renderHelper.addToScene(self, scene); }
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { _renderHelper.removeFromScene(self, scene); }
+private:
+    SingleRenderableEntityItem _renderHelper;
 };
 
 

libraries/entities/src/EntityItem.h

@@ -12,6 +12,7 @@
 #ifndef hifi_EntityItem_h
 #define hifi_EntityItem_h
 
+#include <memory>
 #include <stdint.h>
 
 #include <glm/glm.hpp>
@@ -33,6 +34,10 @@ class EntitySimulation;
 class EntityTreeElement;
 class EntityTreeElementExtraEncodeData;
 
+namespace render {
+    class Scene;
+}
+
 // these thesholds determine what updates will be ignored (client and server)
 const float IGNORE_POSITION_DELTA = 0.0001f;
 const float IGNORE_DIMENSIONS_DELTA = 0.0005f;
@@ -151,7 +156,9 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData) 
                                                 { return 0; }
 
-    virtual bool canRenderInScene() { return true; } // does your entity property render using Render Items and Payloads
+    virtual bool canRenderInScene() { return false; } // does your entity property render using Render Items and Payloads
+    virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { return false; } // by default entity items don't add to scene
+    virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene) { } // by default entity items don't add to scene
     virtual void render(RenderArgs* args) { } // by default entity items don't know how to render
 
     static int expectedBytes();