Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-21 09:24:00 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

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

Browse source
This commit is contained in:
ZappoMan 2015-05-28 09:43:36 -07:00
parent 3f14a7a262
commit 806ee88f1f
9 changed files with 90 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
libraries/entities-renderer/src/EntityTreeRenderer.cpp
View file

@ -96,18 +96,11 @@ void EntityTreeRenderer::clear() {
OctreeRenderer::clear();
_entityScripts.clear();
qDebug() << "EntityTreeRenderer::clear() need to clear the scene... ";
render::Scene::PendingChanges pendingChanges;
QList<EntityItemID> keys = _entityToSceneItems.uniqueKeys();
for (auto key : keys) {
QList<render::ItemID> values = _entityToSceneItems.values(key);
for (auto renderItem : values) {
pendingChanges.removeItem(renderItem);
}
auto scene = _viewState->getMain3DScene();
foreach(auto entity, _entitiesInScene) {
entity->removeFromScene(entity, scene);
}
_entityToSceneItems.clear();
_viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
_entitiesInScene.clear();
}
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
render::Scene::PendingChanges pendingChanges;
if (_entityToSceneItems.contains(entityID)) {
QList<render::ItemID> values = _entityToSceneItems.values(entityID);
for (render::ItemID renderItem : values) {
pendingChanges.removeItem(renderItem);
}
_viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
if (entity && _entitiesInScene.contains(entity)) {
auto scene = _viewState->getMain3DScene();
entity->removeFromScene(entity, scene);
_entitiesInScene.remove(entity);
}
}
@ -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);
if (entity->canRenderInScene()) {
render::Scene::PendingChanges pendingChanges;
render::ItemID renderItem = _viewState->getMain3DScene()->allocateID();
_entityToSceneItems.insert(entityID, renderItem);
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();
auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
if (entity && entity->canRenderInScene()) {
auto scene = _viewState->getMain3DScene();
if (entity->addToScene(entity, scene)) {
_entitiesInScene.insert(entity);
}
}
}

2
libraries/entities-renderer/src/EntityTreeRenderer.h
View file

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

7
libraries/entities-renderer/src/RenderableBoxEntityItem.h
View file

@ -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;
};

6
libraries/entities-renderer/src/RenderableEntityItem.cpp
View file

@ -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) {

40
libraries/entities-renderer/src/RenderableEntityItem.h
View file

@ -15,19 +15,47 @@
#include <render/Scene.h>
#include <EntityItem.h>
class RenderableEntityItem {
class RenderableEntityItemProxy {
public:
RenderableEntityItem(EntityItemPointer entity) : entity(entity) { }
typedef render::Payload<RenderableEntityItem> Payload;
RenderableEntityItemProxy(EntityItemPointer entity) : entity(entity) { }
typedef render::Payload<RenderableEntityItemProxy> Payload;
typedef Payload::DataPointer Pointer;
EntityItemPointer entity;
};
namespace render {
template <> const ItemKey payloadGetKey(const RenderableEntityItem::Pointer& payload);
template <> const Item::Bound payloadGetBound(const RenderableEntityItem::Pointer& payload);
template <> void payloadRender(const RenderableEntityItem::Pointer& payload, RenderArgs* args);
template <> const ItemKey payloadGetKey(const RenderableEntityItemProxy::Pointer& payload);
template <> const Item::Bound payloadGetBound(const RenderableEntityItemProxy::Pointer& payload);
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

7
libraries/entities-renderer/src/RenderableLineEntityItem.h
View file

@ -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;
};

7
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h
View file

@ -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;

8
libraries/entities-renderer/src/RenderableSphereEntityItem.h
View file

@ -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;
};

9
libraries/entities/src/EntityItem.h
View file

@ -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();