Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-06 23:09:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #4954 from ZappoMan/entitysmartpointers

Browse source 
EnitityItem smart pointers
This commit is contained in:
Andrew Meadows 2015-05-26 14:05:03 -07:00
commit 16e5710325
68 changed files with 318 additions and 305 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
interface/src/Application.cpp
View file

@ -1974,7 +1974,7 @@ void Application::toggleFaceTrackerMute() {
} }
bool Application::exportEntities(const QString& filename, const QVector<EntityItemID>& entityIDs) { bool Application::exportEntities(const QString& filename, const QVector<EntityItemID>& entityIDs) {
QVector<EntityItem*> entities; QVector<EntityItemPointer> entities;
auto entityTree = _entities.getTree(); auto entityTree = _entities.getTree();
EntityTree exportTree; EntityTree exportTree;
@ -2015,7 +2015,7 @@ bool Application::exportEntities(const QString& filename, const QVector<EntityIt
} }
bool Application::exportEntities(const QString& filename, float x, float y, float z, float scale) { bool Application::exportEntities(const QString& filename, float x, float y, float z, float scale) {
QVector<EntityItem*> entities; QVector<EntityItemPointer> entities;
_entities.getTree()->findEntities(AACube(glm::vec3(x, y, z), scale), entities); _entities.getTree()->findEntities(AACube(glm::vec3(x, y, z), scale), entities);
if (entities.size() > 0) { if (entities.size() > 0) {

14
interface/src/avatar/ModelReferential.cpp
View file

@ -30,7 +30,7 @@ ModelReferential::ModelReferential(Referential* referential, EntityTree* tree, A
return; return;
} }
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
if (item != NULL) { if (item != NULL) {
_lastRefDimension = item->getDimensions(); _lastRefDimension = item->getDimensions();
_refRotation = item->getRotation(); _refRotation = item->getRotation();
@ -44,7 +44,7 @@ ModelReferential::ModelReferential(const QUuid& entityID, EntityTree* tree, Avat
_entityID(entityID), _entityID(entityID),
_tree(tree) _tree(tree)
{ {
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
if (!isValid() || item == NULL) { if (!isValid() || item == NULL) {
qCDebug(interfaceapp) << "ModelReferential::constructor(): Not Valid"; qCDebug(interfaceapp) << "ModelReferential::constructor(): Not Valid";
_isValid = false; _isValid = false;
@ -61,7 +61,7 @@ ModelReferential::ModelReferential(const QUuid& entityID, EntityTree* tree, Avat
} }
void ModelReferential::update() { void ModelReferential::update() {
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
if (!isValid() || item == NULL || _avatar == NULL) { if (!isValid() || item == NULL || _avatar == NULL) {
return; return;
} }
@ -105,7 +105,7 @@ JointReferential::JointReferential(Referential* referential, EntityTree* tree, A
return; return;
} }
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
const Model* model = getModel(item); const Model* model = getModel(item);
if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) { if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) {
_lastRefDimension = item->getDimensions(); _lastRefDimension = item->getDimensions();
@ -120,7 +120,7 @@ JointReferential::JointReferential(uint32_t jointIndex, const QUuid& entityID, E
_jointIndex(jointIndex) _jointIndex(jointIndex)
{ {
_type = JOINT; _type = JOINT;
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
const Model* model = getModel(item); const Model* model = getModel(item);
if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) { if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) {
qCDebug(interfaceapp) << "JointReferential::constructor(): Not Valid"; qCDebug(interfaceapp) << "JointReferential::constructor(): Not Valid";
@ -139,7 +139,7 @@ JointReferential::JointReferential(uint32_t jointIndex, const QUuid& entityID, E
} }
void JointReferential::update() { void JointReferential::update() {
const EntityItem* item = _tree->findEntityByID(_entityID); EntityItemPointer item = _tree->findEntityByID(_entityID);
const Model* model = getModel(item); const Model* model = getModel(item);
if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) { if (!isValid() || model == NULL || _jointIndex >= (uint32_t)(model->getJointStateCount())) {
return; return;
@ -163,7 +163,7 @@ void JointReferential::update() {
} }
} }
const Model* JointReferential::getModel(const EntityItem* item) { const Model* JointReferential::getModel(EntityItemPointer item) {
EntityItemFBXService* fbxService = _tree->getFBXService(); EntityItemFBXService* fbxService = _tree->getFBXService();
if (item != NULL && fbxService != NULL) { if (item != NULL && fbxService != NULL) {
return fbxService->getModelForEntityItem(item); return fbxService->getModelForEntityItem(item);

2
interface/src/avatar/ModelReferential.h
View file

@ -38,7 +38,7 @@ public:
virtual void update(); virtual void update();
protected: protected:
const Model* getModel(const EntityItem* item); const Model* getModel(EntityItemPointer item);
virtual int packExtraData(unsigned char* destinationBuffer) const; virtual int packExtraData(unsigned char* destinationBuffer) const;
virtual int unpackExtraData(const unsigned char* sourceBuffer, int size); virtual int unpackExtraData(const unsigned char* sourceBuffer, int size);

2
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -11,8 +11,6 @@
#include <GlowEffect.h> #include <GlowEffect.h>
#include "../../Menu.h"
#include "ModelOverlay.h" #include "ModelOverlay.h"
ModelOverlay::ModelOverlay() ModelOverlay::ModelOverlay()

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

@ -138,7 +138,7 @@ void EntityTreeRenderer::errorInLoadingScript(const QUrl& url) {
} }
QScriptValue EntityTreeRenderer::loadEntityScript(const EntityItemID& entityItemID, bool isPreload) { QScriptValue EntityTreeRenderer::loadEntityScript(const EntityItemID& entityItemID, bool isPreload) {
EntityItem* entity = static_cast<EntityTree*>(_tree)->findEntityByEntityItemID(entityItemID); EntityItemPointer entity = static_cast<EntityTree*>(_tree)->findEntityByEntityItemID(entityItemID);
return loadEntityScript(entity, isPreload); return loadEntityScript(entity, isPreload);
} }
@ -190,7 +190,7 @@ QString EntityTreeRenderer::loadScriptContents(const QString& scriptMaybeURLorTe
} }
QScriptValue EntityTreeRenderer::loadEntityScript(EntityItem* entity, bool isPreload) { QScriptValue EntityTreeRenderer::loadEntityScript(EntityItemPointer entity, bool isPreload) {
if (_shuttingDown) { if (_shuttingDown) {
return QScriptValue(); // since we're shutting down, we don't load any more scripts return QScriptValue(); // since we're shutting down, we don't load any more scripts
} }
@ -324,7 +324,7 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
if (avatarPosition != _lastAvatarPosition) { if (avatarPosition != _lastAvatarPosition) {
float radius = 1.0f; // for now, assume 1 meter radius float radius = 1.0f; // for now, assume 1 meter radius
QVector<const EntityItem*> foundEntities; QVector<EntityItemPointer> foundEntities;
QVector<EntityItemID> entitiesContainingAvatar; QVector<EntityItemID> entitiesContainingAvatar;
// find the entities near us // find the entities near us
@ -332,7 +332,7 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
static_cast<EntityTree*>(_tree)->findEntities(avatarPosition, radius, foundEntities); static_cast<EntityTree*>(_tree)->findEntities(avatarPosition, radius, foundEntities);
// create a list of entities that actually contain the avatar's position // create a list of entities that actually contain the avatar's position
foreach(const EntityItem* entity, foundEntities) { foreach(EntityItemPointer entity, foundEntities) {
if (entity->contains(avatarPosition)) { if (entity->contains(avatarPosition)) {
entitiesContainingAvatar << entity->getEntityItemID(); entitiesContainingAvatar << entity->getEntityItemID();
} }
@ -517,12 +517,12 @@ void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
deleteReleasedModels(); // seems like as good as any other place to do some memory cleanup deleteReleasedModels(); // seems like as good as any other place to do some memory cleanup
} }
const FBXGeometry* EntityTreeRenderer::getGeometryForEntity(const EntityItem* entityItem) { const FBXGeometry* EntityTreeRenderer::getGeometryForEntity(EntityItemPointer entityItem) {
const FBXGeometry* result = NULL; const FBXGeometry* result = NULL;
if (entityItem->getType() == EntityTypes::Model) { if (entityItem->getType() == EntityTypes::Model) {
const RenderableModelEntityItem* constModelEntityItem = dynamic_cast<const RenderableModelEntityItem*>(entityItem); std::shared_ptr<RenderableModelEntityItem> modelEntityItem =
RenderableModelEntityItem* modelEntityItem = const_cast<RenderableModelEntityItem*>(constModelEntityItem); std::dynamic_pointer_cast<RenderableModelEntityItem>(entityItem);
assert(modelEntityItem); // we need this!!! assert(modelEntityItem); // we need this!!!
Model* model = modelEntityItem->getModel(this); Model* model = modelEntityItem->getModel(this);
if (model) { if (model) {
@ -532,23 +532,23 @@ const FBXGeometry* EntityTreeRenderer::getGeometryForEntity(const EntityItem* en
return result; return result;
} }
const Model* EntityTreeRenderer::getModelForEntityItem(const EntityItem* entityItem) { const Model* EntityTreeRenderer::getModelForEntityItem(EntityItemPointer entityItem) {
const Model* result = NULL; const Model* result = NULL;
if (entityItem->getType() == EntityTypes::Model) { if (entityItem->getType() == EntityTypes::Model) {
const RenderableModelEntityItem* constModelEntityItem = dynamic_cast<const RenderableModelEntityItem*>(entityItem); std::shared_ptr<RenderableModelEntityItem> modelEntityItem =
RenderableModelEntityItem* modelEntityItem = const_cast<RenderableModelEntityItem*>(constModelEntityItem); std::dynamic_pointer_cast<RenderableModelEntityItem>(entityItem);
result = modelEntityItem->getModel(this); result = modelEntityItem->getModel(this);
} }
return result; return result;
} }
const FBXGeometry* EntityTreeRenderer::getCollisionGeometryForEntity(const EntityItem* entityItem) { const FBXGeometry* EntityTreeRenderer::getCollisionGeometryForEntity(EntityItemPointer entityItem) {
const FBXGeometry* result = NULL; const FBXGeometry* result = NULL;
if (entityItem->getType() == EntityTypes::Model) { if (entityItem->getType() == EntityTypes::Model) {
const RenderableModelEntityItem* constModelEntityItem = dynamic_cast<const RenderableModelEntityItem*>(entityItem); std::shared_ptr<RenderableModelEntityItem> modelEntityItem =
if (constModelEntityItem->hasCompoundShapeURL()) { std::dynamic_pointer_cast<RenderableModelEntityItem>(entityItem);
RenderableModelEntityItem* modelEntityItem = const_cast<RenderableModelEntityItem*>(constModelEntityItem); if (modelEntityItem->hasCompoundShapeURL()) {
Model* model = modelEntityItem->getModel(this); Model* model = modelEntityItem->getModel(this);
if (model) { if (model) {
const QSharedPointer<NetworkGeometry> collisionNetworkGeometry = model->getCollisionGeometry(); const QSharedPointer<NetworkGeometry> collisionNetworkGeometry = model->getCollisionGeometry();
@ -615,7 +615,7 @@ void EntityTreeRenderer::renderElementProxy(EntityTreeElement* entityTreeElement
} }
} }
void EntityTreeRenderer::renderProxies(const EntityItem* entity, RenderArgs* args) { void EntityTreeRenderer::renderProxies(EntityItemPointer entity, RenderArgs* args) {
bool isShadowMode = args->_renderMode == RenderArgs::SHADOW_RENDER_MODE; bool isShadowMode = args->_renderMode == RenderArgs::SHADOW_RENDER_MODE;
if (!isShadowMode && _displayModelBounds) { if (!isShadowMode && _displayModelBounds) {
PerformanceTimer perfTimer("renderProxies"); PerformanceTimer perfTimer("renderProxies");
@ -674,7 +674,7 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args)
// we need to iterate the actual entityItems of the element // we need to iterate the actual entityItems of the element
EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element); EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element);
QList<EntityItem*>& entityItems = entityTreeElement->getEntities(); EntityItems& entityItems = entityTreeElement->getEntities();
uint16_t numberOfEntities = entityItems.size(); uint16_t numberOfEntities = entityItems.size();
@ -686,7 +686,7 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args)
} }
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
EntityItem* entityItem = entityItems[i]; EntityItemPointer entityItem = entityItems[i];
if (entityItem->isVisible()) { if (entityItem->isVisible()) {
@ -696,17 +696,17 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args)
float entityVolumeEstimate = entityItem->getVolumeEstimate(); float entityVolumeEstimate = entityItem->getVolumeEstimate();
if (entityVolumeEstimate < _bestZoneVolume) { if (entityVolumeEstimate < _bestZoneVolume) {
_bestZoneVolume = entityVolumeEstimate; _bestZoneVolume = entityVolumeEstimate;
_bestZone = dynamic_cast<const ZoneEntityItem*>(entityItem); _bestZone = std::dynamic_pointer_cast<ZoneEntityItem>(entityItem);
} else if (entityVolumeEstimate == _bestZoneVolume) { } else if (entityVolumeEstimate == _bestZoneVolume) {
if (!_bestZone) { if (!_bestZone) {
_bestZoneVolume = entityVolumeEstimate; _bestZoneVolume = entityVolumeEstimate;
_bestZone = dynamic_cast<const ZoneEntityItem*>(entityItem); _bestZone = std::dynamic_pointer_cast<ZoneEntityItem>(entityItem);
} else { } else {
// in the case of the volume being equal, we will use the // in the case of the volume being equal, we will use the
// EntityItemID to deterministically pick one entity over the other // EntityItemID to deterministically pick one entity over the other
if (entityItem->getEntityItemID() < _bestZone->getEntityItemID()) { if (entityItem->getEntityItemID() < _bestZone->getEntityItemID()) {
_bestZoneVolume = entityVolumeEstimate; _bestZoneVolume = entityVolumeEstimate;
_bestZone = dynamic_cast<const ZoneEntityItem*>(entityItem); _bestZone = std::dynamic_pointer_cast<ZoneEntityItem>(entityItem);
} }
} }
} }
@ -835,7 +835,7 @@ RayToEntityIntersectionResult EntityTreeRenderer::findRayIntersectionWorker(cons
EntityTree* entityTree = static_cast<EntityTree*>(_tree); EntityTree* entityTree = static_cast<EntityTree*>(_tree);
OctreeElement* element; OctreeElement* element;
EntityItem* intersectedEntity = NULL; EntityItemPointer intersectedEntity = NULL;
result.intersects = entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face, result.intersects = entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face,
(void**)&intersectedEntity, lockType, &result.accurate, (void**)&intersectedEntity, lockType, &result.accurate,
precisionPicking); precisionPicking);
@ -1110,7 +1110,7 @@ void EntityTreeRenderer::changingEntityID(const EntityItemID& oldEntityID, const
} }
void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision) { void EntityTreeRenderer::playEntityCollisionSound(const QUuid& myNodeID, EntityTree* entityTree, const EntityItemID& id, const Collision& collision) {
EntityItem* entity = entityTree->findEntityByEntityItemID(id); EntityItemPointer entity = entityTree->findEntityByEntityItemID(id);
if (!entity) { if (!entity) {
return; return;
} }

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

@ -62,9 +62,9 @@ public:
RenderArgs::RenderSide renderSide = RenderArgs::MONO, RenderArgs::RenderSide renderSide = RenderArgs::MONO,
RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE); RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem); virtual const FBXGeometry* getGeometryForEntity(EntityItemPointer entityItem);
virtual const Model* getModelForEntityItem(const EntityItem* entityItem); virtual const Model* getModelForEntityItem(EntityItemPointer entityItem);
virtual const FBXGeometry* getCollisionGeometryForEntity(const EntityItem* entityItem); virtual const FBXGeometry* getCollisionGeometryForEntity(EntityItemPointer entityItem);
/// clears the tree /// clears the tree
virtual void clear(); virtual void clear();
@ -130,7 +130,7 @@ private:
void checkAndCallUnload(const EntityItemID& entityID); void checkAndCallUnload(const EntityItemID& entityID);
QList<Model*> _releasedModels; QList<Model*> _releasedModels;
void renderProxies(const EntityItem* entity, RenderArgs* args); void renderProxies(EntityItemPointer entity, RenderArgs* args);
RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType,
bool precisionPicking); bool precisionPicking);
@ -147,7 +147,7 @@ private:
ScriptEngine* _entitiesScriptEngine; ScriptEngine* _entitiesScriptEngine;
ScriptEngine* _sandboxScriptEngine; ScriptEngine* _sandboxScriptEngine;
QScriptValue loadEntityScript(EntityItem* entity, bool isPreload = false); QScriptValue loadEntityScript(EntityItemPointer entity, bool isPreload = false);
QScriptValue loadEntityScript(const EntityItemID& entityItemID, bool isPreload = false); QScriptValue loadEntityScript(const EntityItemID& entityItemID, bool isPreload = false);
QScriptValue getPreviouslyLoadedEntityScript(const EntityItemID& entityItemID); QScriptValue getPreviouslyLoadedEntityScript(const EntityItemID& entityItemID);
QString loadScriptContents(const QString& scriptMaybeURLorText, bool& isURL, bool& isPending, QUrl& url); QString loadScriptContents(const QString& scriptMaybeURLorText, bool& isURL, bool& isPending, QUrl& url);
@ -173,7 +173,7 @@ private:
QMultiMap<QUrl, EntityItemID> _waitingOnPreload; QMultiMap<QUrl, EntityItemID> _waitingOnPreload;
bool _hasPreviousZone = false; bool _hasPreviousZone = false;
const ZoneEntityItem* _bestZone; std::shared_ptr<ZoneEntityItem> _bestZone;
float _bestZoneVolume; float _bestZoneVolume;
glm::vec3 _previousKeyLightColor; glm::vec3 _previousKeyLightColor;

4
libraries/entities-renderer/src/RenderableBoxEntityItem.cpp
View file

@ -18,8 +18,8 @@
#include "RenderableBoxEntityItem.h" #include "RenderableBoxEntityItem.h"
EntityItem* RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableBoxEntityItem(entityID, properties); return EntityItemPointer(new RenderableBoxEntityItem(entityID, properties));
} }
void RenderableBoxEntityItem::render(RenderArgs* args) { void RenderableBoxEntityItem::render(RenderArgs* args) {

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

@ -17,7 +17,7 @@
class RenderableBoxEntityItem : public BoxEntityItem { class RenderableBoxEntityItem : public BoxEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableBoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableBoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
BoxEntityItem(entityItemID, properties) BoxEntityItem(entityItemID, properties)

4
libraries/entities-renderer/src/RenderableLightEntityItem.cpp
View file

@ -19,8 +19,8 @@
#include "RenderableLightEntityItem.h" #include "RenderableLightEntityItem.h"
EntityItem* RenderableLightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableLightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableLightEntityItem(entityID, properties); return EntityItemPointer(new RenderableLightEntityItem(entityID, properties));
} }
void RenderableLightEntityItem::render(RenderArgs* args) { void RenderableLightEntityItem::render(RenderArgs* args) {

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

@ -16,7 +16,7 @@
class RenderableLightEntityItem : public LightEntityItem { class RenderableLightEntityItem : public LightEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableLightEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableLightEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
LightEntityItem(entityItemID, properties) LightEntityItem(entityItemID, properties)

5
libraries/entities-renderer/src/RenderableLineEntityItem.cpp
View file

@ -18,8 +18,8 @@
#include "RenderableLineEntityItem.h" #include "RenderableLineEntityItem.h"
EntityItem* RenderableLineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableLineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableLineEntityItem(entityID, properties); return EntityItemPointer(new RenderableLineEntityItem(entityID, properties));
} }
void RenderableLineEntityItem::render(RenderArgs* args) { void RenderableLineEntityItem::render(RenderArgs* args) {
@ -37,5 +37,6 @@ void RenderableLineEntityItem::render(RenderArgs* args) {
glm::vec3& p2 = dimensions; glm::vec3& p2 = dimensions;
DependencyManager::get<DeferredLightingEffect>()->renderLine(p1, p2, lineColor, lineColor); DependencyManager::get<DeferredLightingEffect>()->renderLine(p1, p2, lineColor, lineColor);
glPopMatrix(); glPopMatrix();
RenderableDebugableEntityItem::render(this, args); RenderableDebugableEntityItem::render(this, args);
}; };

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

@ -17,7 +17,7 @@
class RenderableLineEntityItem : public LineEntityItem { class RenderableLineEntityItem : public LineEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableLineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableLineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
LineEntityItem(entityItemID, properties) { } LineEntityItem(entityItemID, properties) { }

4
libraries/entities-renderer/src/RenderableModelEntityItem.cpp
View file

@ -23,8 +23,8 @@
#include "EntitiesRendererLogging.h" #include "EntitiesRendererLogging.h"
#include "RenderableModelEntityItem.h" #include "RenderableModelEntityItem.h"
EntityItem* RenderableModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableModelEntityItem(entityID, properties); return EntityItemPointer(new RenderableModelEntityItem(entityID, properties));
} }
RenderableModelEntityItem::~RenderableModelEntityItem() { RenderableModelEntityItem::~RenderableModelEntityItem() {

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

@ -23,7 +23,7 @@ class EntityTreeRenderer;
class RenderableModelEntityItem : public ModelEntityItem { class RenderableModelEntityItem : public ModelEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
ModelEntityItem(entityItemID, properties), ModelEntityItem(entityItemID, properties),

4
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
View file

@ -20,8 +20,8 @@
#include "RenderableParticleEffectEntityItem.h" #include "RenderableParticleEffectEntityItem.h"
EntityItem* RenderableParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableParticleEffectEntityItem(entityID, properties); return EntityItemPointer(new RenderableParticleEffectEntityItem(entityID, properties));
} }
RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

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

@ -16,7 +16,7 @@
class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem { class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
virtual void render(RenderArgs* args); virtual void render(RenderArgs* args);

4
libraries/entities-renderer/src/RenderableSphereEntityItem.cpp
View file

@ -19,8 +19,8 @@
#include "RenderableSphereEntityItem.h" #include "RenderableSphereEntityItem.h"
EntityItem* RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableSphereEntityItem(entityID, properties); return EntityItemPointer(new RenderableSphereEntityItem(entityID, properties));
} }
void RenderableSphereEntityItem::render(RenderArgs* args) { void RenderableSphereEntityItem::render(RenderArgs* args) {

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

@ -16,7 +16,7 @@
class RenderableSphereEntityItem : public SphereEntityItem { class RenderableSphereEntityItem : public SphereEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableSphereEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableSphereEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
SphereEntityItem(entityItemID, properties) SphereEntityItem(entityItemID, properties)

4
libraries/entities-renderer/src/RenderableTextEntityItem.cpp
View file

@ -23,8 +23,8 @@
const int FIXED_FONT_POINT_SIZE = 40; const int FIXED_FONT_POINT_SIZE = 40;
EntityItem* RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableTextEntityItem(entityID, properties); return EntityItemPointer(new RenderableTextEntityItem(entityID, properties));
} }
void RenderableTextEntityItem::render(RenderArgs* args) { void RenderableTextEntityItem::render(RenderArgs* args) {

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

@ -16,7 +16,7 @@
class RenderableTextEntityItem : public TextEntityItem { class RenderableTextEntityItem : public TextEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableTextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableTextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
TextEntityItem(entityItemID, properties) TextEntityItem(entityItemID, properties)

4
libraries/entities-renderer/src/RenderableWebEntityItem.cpp
View file

@ -28,8 +28,8 @@
const float DPI = 30.47f; const float DPI = 30.47f;
const float METERS_TO_INCHES = 39.3701f; const float METERS_TO_INCHES = 39.3701f;
EntityItem* RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableWebEntityItem(entityID, properties); return EntityItemPointer(new RenderableWebEntityItem(entityID, properties));
} }
RenderableWebEntityItem::RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableWebEntityItem::RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

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

@ -17,7 +17,7 @@ class OffscreenQmlSurface;
class RenderableWebEntityItem : public WebEntityItem { class RenderableWebEntityItem : public WebEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
~RenderableWebEntityItem(); ~RenderableWebEntityItem();

4
libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
View file

@ -16,8 +16,8 @@
#include <GeometryCache.h> #include <GeometryCache.h>
#include <PerfStat.h> #include <PerfStat.h>
EntityItem* RenderableZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableZoneEntityItem(entityID, properties); return EntityItemPointer(new RenderableZoneEntityItem(entityID, properties));
} }
template<typename Lambda> template<typename Lambda>

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

@ -19,7 +19,7 @@ class NetworkGeometry;
class RenderableZoneEntityItem : public ZoneEntityItem { class RenderableZoneEntityItem : public ZoneEntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
ZoneEntityItem(entityItemID, properties), ZoneEntityItem(entityItemID, properties),

2
libraries/entities/src/AddEntityOperator.cpp
View file

@ -16,7 +16,7 @@
#include "AddEntityOperator.h" #include "AddEntityOperator.h"
AddEntityOperator::AddEntityOperator(EntityTree* tree, AddEntityOperator::AddEntityOperator(EntityTree* tree,
EntityItem* newEntity) : EntityItemPointer newEntity) :
_tree(tree), _tree(tree),
_newEntity(newEntity), _newEntity(newEntity),
_foundNew(false), _foundNew(false),

4
libraries/entities/src/AddEntityOperator.h
View file

@ -14,14 +14,14 @@
class AddEntityOperator : public RecurseOctreeOperator { class AddEntityOperator : public RecurseOctreeOperator {
public: public:
AddEntityOperator(EntityTree* tree, EntityItem* newEntity); AddEntityOperator(EntityTree* tree, EntityItemPointer newEntity);
virtual bool preRecursion(OctreeElement* element); virtual bool preRecursion(OctreeElement* element);
virtual bool postRecursion(OctreeElement* element); virtual bool postRecursion(OctreeElement* element);
virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex); virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex);
private: private:
EntityTree* _tree; EntityTree* _tree;
EntityItem* _newEntity; EntityItemPointer _newEntity;
bool _foundNew; bool _foundNew;
quint64 _changeTime; quint64 _changeTime;

4
libraries/entities/src/BoxEntityItem.cpp
View file

@ -20,8 +20,8 @@
#include "EntityTreeElement.h" #include "EntityTreeElement.h"
EntityItem* BoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer BoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new BoxEntityItem(entityID, properties); EntityItemPointer result { new BoxEntityItem(entityID, properties) };
return result; return result;
} }

2
libraries/entities/src/BoxEntityItem.h
View file

@ -16,7 +16,7 @@
class BoxEntityItem : public EntityItem { class BoxEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
BoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); BoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

2
libraries/entities/src/DeleteEntityOperator.cpp
View file

@ -92,7 +92,7 @@ bool DeleteEntityOperator::preRecursion(OctreeElement* element) {
// If this is the element we're looking for, then ask it to remove the old entity // If this is the element we're looking for, then ask it to remove the old entity
// and we can stop searching. // and we can stop searching.
if (entityTreeElement == details.containingElement) { if (entityTreeElement == details.containingElement) {
EntityItem* theEntity = details.entity; EntityItemPointer theEntity = details.entity;
bool entityDeleted = entityTreeElement->removeEntityItem(theEntity); // remove it from the element bool entityDeleted = entityTreeElement->removeEntityItem(theEntity); // remove it from the element
assert(entityDeleted); assert(entityDeleted);
_tree->setContainingElement(details.entity->getEntityItemID(), NULL); // update or id to element lookup _tree->setContainingElement(details.entity->getEntityItemID(), NULL); // update or id to element lookup

2
libraries/entities/src/DeleteEntityOperator.h
View file

@ -14,7 +14,7 @@
class EntityToDeleteDetails { class EntityToDeleteDetails {
public: public:
EntityItem* entity; EntityItemPointer entity;
AACube cube; AACube cube;
EntityTreeElement* containingElement; EntityTreeElement* containingElement;
}; };

21
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -78,7 +78,7 @@ QUuid EntityScriptingInterface::addEntity(const EntityItemProperties& properties
bool success = true; bool success = true;
if (_entityTree) { if (_entityTree) {
_entityTree->lockForWrite(); _entityTree->lockForWrite();
EntityItem* entity = _entityTree->addEntity(id, propertiesWithSimID); EntityItemPointer entity = _entityTree->addEntity(id, propertiesWithSimID);
if (entity) { if (entity) {
entity->setLastBroadcast(usecTimestampNow()); entity->setLastBroadcast(usecTimestampNow());
// This Node is creating a new object. If it's in motion, set this Node as the simulator. // This Node is creating a new object. If it's in motion, set this Node as the simulator.
@ -102,7 +102,8 @@ EntityItemProperties EntityScriptingInterface::getEntityProperties(QUuid identit
EntityItemProperties results; EntityItemProperties results;
if (_entityTree) { if (_entityTree) {
_entityTree->lockForRead(); _entityTree->lockForRead();
EntityItem* entity = const_cast<EntityItem*>(_entityTree->findEntityByEntityItemID(EntityItemID(identity)));
EntityItemPointer entity = _entityTree->findEntityByEntityItemID(EntityItemID(identity));
if (entity) { if (entity) {
results = entity->getProperties(); results = entity->getProperties();
@ -137,7 +138,7 @@ QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties&
// make sure the properties has a type, so that the encode can know which properties to include // make sure the properties has a type, so that the encode can know which properties to include
if (properties.getType() == EntityTypes::Unknown) { if (properties.getType() == EntityTypes::Unknown) {
EntityItem* entity = _entityTree->findEntityByEntityItemID(entityID); EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
if (entity) { if (entity) {
// we need to change the outgoing properties, so we make a copy, modify, and send. // we need to change the outgoing properties, so we make a copy, modify, and send.
EntityItemProperties modifiedProperties = properties; EntityItemProperties modifiedProperties = properties;
@ -161,7 +162,7 @@ void EntityScriptingInterface::deleteEntity(QUuid id) {
if (_entityTree) { if (_entityTree) {
_entityTree->lockForWrite(); _entityTree->lockForWrite();
EntityItem* entity = const_cast<EntityItem*>(_entityTree->findEntityByEntityItemID(entityID)); EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
if (entity) { if (entity) {
if (entity->getLocked()) { if (entity->getLocked()) {
shouldDelete = false; shouldDelete = false;
@ -183,7 +184,7 @@ QUuid EntityScriptingInterface::findClosestEntity(const glm::vec3& center, float
EntityItemID result; EntityItemID result;
if (_entityTree) { if (_entityTree) {
_entityTree->lockForRead(); _entityTree->lockForRead();
const EntityItem* closestEntity = _entityTree->findClosestEntity(center, radius); EntityItemPointer closestEntity = _entityTree->findClosestEntity(center, radius);
_entityTree->unlock(); _entityTree->unlock();
if (closestEntity) { if (closestEntity) {
result = closestEntity->getEntityItemID(); result = closestEntity->getEntityItemID();
@ -205,11 +206,11 @@ QVector<QUuid> EntityScriptingInterface::findEntities(const glm::vec3& center, f
QVector<QUuid> result; QVector<QUuid> result;
if (_entityTree) { if (_entityTree) {
_entityTree->lockForRead(); _entityTree->lockForRead();
QVector<const EntityItem*> entities; QVector<EntityItemPointer> entities;
_entityTree->findEntities(center, radius, entities); _entityTree->findEntities(center, radius, entities);
_entityTree->unlock(); _entityTree->unlock();
foreach (const EntityItem* entity, entities) { foreach (EntityItemPointer entity, entities) {
result << entity->getEntityItemID(); result << entity->getEntityItemID();
} }
} }
@ -221,11 +222,11 @@ QVector<QUuid> EntityScriptingInterface::findEntitiesInBox(const glm::vec3& corn
if (_entityTree) { if (_entityTree) {
_entityTree->lockForRead(); _entityTree->lockForRead();
AABox box(corner, dimensions); AABox box(corner, dimensions);
QVector<EntityItem*> entities; QVector<EntityItemPointer> entities;
_entityTree->findEntities(box, entities); _entityTree->findEntities(box, entities);
_entityTree->unlock(); _entityTree->unlock();
foreach (const EntityItem* entity, entities) { foreach (EntityItemPointer entity, entities) {
result << entity->getEntityItemID(); result << entity->getEntityItemID();
} }
} }
@ -248,7 +249,7 @@ RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorke
RayToEntityIntersectionResult result; RayToEntityIntersectionResult result;
if (_entityTree) { if (_entityTree) {
OctreeElement* element; OctreeElement* element;
EntityItem* intersectedEntity = NULL; EntityItemPointer intersectedEntity = NULL;
result.intersects = _entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face, result.intersects = _entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face,
(void**)&intersectedEntity, lockType, &result.accurate, (void**)&intersectedEntity, lockType, &result.accurate,
precisionPicking); precisionPicking);

2
libraries/entities/src/EntityScriptingInterface.h
View file

@ -39,7 +39,7 @@ public:
float distance; float distance;
BoxFace face; BoxFace face;
glm::vec3 intersection; glm::vec3 intersection;
EntityItem* entity; EntityItemPointer entity;
}; };
Q_DECLARE_METATYPE(RayToEntityIntersectionResult) Q_DECLARE_METATYPE(RayToEntityIntersectionResult)

23
libraries/entities/src/EntitySimulation.cpp
View file

@ -38,22 +38,21 @@ void EntitySimulation::updateEntities() {
} }
void EntitySimulation::getEntitiesToDelete(VectorOfEntities& entitiesToDelete) { void EntitySimulation::getEntitiesToDelete(VectorOfEntities& entitiesToDelete) {
for (auto entityItr : _entitiesToDelete) {
EntityItem* entity = &(*entityItr); for (auto entity : _entitiesToDelete) {
// this entity is still in its tree, so we insert into the external list // this entity is still in its tree, so we insert into the external list
entitiesToDelete.push_back(entity); entitiesToDelete.push_back(entity);
++entityItr;
} }
_entitiesToDelete.clear(); _entitiesToDelete.clear();
} }
void EntitySimulation::addEntityInternal(EntityItem* entity) { void EntitySimulation::addEntityInternal(EntityItemPointer entity) {
if (entity->isMoving() && !entity->getPhysicsInfo()) { if (entity->isMoving() && !entity->getPhysicsInfo()) {
_simpleKinematicEntities.insert(entity); _simpleKinematicEntities.insert(entity);
} }
} }
void EntitySimulation::changeEntityInternal(EntityItem* entity) { void EntitySimulation::changeEntityInternal(EntityItemPointer entity) {
if (entity->isMoving() && !entity->getPhysicsInfo()) { if (entity->isMoving() && !entity->getPhysicsInfo()) {
_simpleKinematicEntities.insert(entity); _simpleKinematicEntities.insert(entity);
} else { } else {
@ -68,7 +67,7 @@ void EntitySimulation::expireMortalEntities(const quint64& now) {
_nextExpiry = quint64(-1); _nextExpiry = quint64(-1);
SetOfEntities::iterator itemItr = _mortalEntities.begin(); SetOfEntities::iterator itemItr = _mortalEntities.begin();
while (itemItr != _mortalEntities.end()) { while (itemItr != _mortalEntities.end()) {
EntityItem* entity = *itemItr; EntityItemPointer entity = *itemItr;
quint64 expiry = entity->getExpiry(); quint64 expiry = entity->getExpiry();
if (expiry < now) { if (expiry < now) {
_entitiesToDelete.insert(entity); _entitiesToDelete.insert(entity);
@ -96,7 +95,7 @@ void EntitySimulation::callUpdateOnEntitiesThatNeedIt(const quint64& now) {
PerformanceTimer perfTimer("updatingEntities"); PerformanceTimer perfTimer("updatingEntities");
SetOfEntities::iterator itemItr = _entitiesToUpdate.begin(); SetOfEntities::iterator itemItr = _entitiesToUpdate.begin();
while (itemItr != _entitiesToUpdate.end()) { while (itemItr != _entitiesToUpdate.end()) {
EntityItem* entity = *itemItr; EntityItemPointer entity = *itemItr;
// TODO: catch transition from needing update to not as a "change" // TODO: catch transition from needing update to not as a "change"
// so we don't have to scan for it here. // so we don't have to scan for it here.
if (!entity->needsToCallUpdate()) { if (!entity->needsToCallUpdate()) {
@ -117,7 +116,7 @@ void EntitySimulation::sortEntitiesThatMoved() {
AACube domainBounds(glm::vec3(0.0f,0.0f,0.0f), (float)TREE_SCALE); AACube domainBounds(glm::vec3(0.0f,0.0f,0.0f), (float)TREE_SCALE);
SetOfEntities::iterator itemItr = _entitiesToSort.begin(); SetOfEntities::iterator itemItr = _entitiesToSort.begin();
while (itemItr != _entitiesToSort.end()) { while (itemItr != _entitiesToSort.end()) {
EntityItem* entity = *itemItr; EntityItemPointer entity = *itemItr;
// check to see if this movement has sent the entity outside of the domain. // check to see if this movement has sent the entity outside of the domain.
AACube newCube = entity->getMaximumAACube(); AACube newCube = entity->getMaximumAACube();
if (!domainBounds.touches(newCube)) { if (!domainBounds.touches(newCube)) {
@ -145,7 +144,7 @@ void EntitySimulation::sortEntitiesThatMoved() {
_entitiesToSort.clear(); _entitiesToSort.clear();
} }
void EntitySimulation::addEntity(EntityItem* entity) { void EntitySimulation::addEntity(EntityItemPointer entity) {
assert(entity); assert(entity);
if (entity->isMortal()) { if (entity->isMortal()) {
_mortalEntities.insert(entity); _mortalEntities.insert(entity);
@ -167,7 +166,7 @@ void EntitySimulation::addEntity(EntityItem* entity) {
entity->clearDirtyFlags(); entity->clearDirtyFlags();
} }
void EntitySimulation::removeEntity(EntityItem* entity) { void EntitySimulation::removeEntity(EntityItemPointer entity) {
assert(entity); assert(entity);
_entitiesToUpdate.remove(entity); _entitiesToUpdate.remove(entity);
_mortalEntities.remove(entity); _mortalEntities.remove(entity);
@ -180,7 +179,7 @@ void EntitySimulation::removeEntity(EntityItem* entity) {
entity->_simulated = false; entity->_simulated = false;
} }
void EntitySimulation::changeEntity(EntityItem* entity) { void EntitySimulation::changeEntity(EntityItemPointer entity) {
assert(entity); assert(entity);
if (!entity->_simulated) { if (!entity->_simulated) {
// This entity was either never added to the simulation or has been removed // This entity was either never added to the simulation or has been removed
@ -250,7 +249,7 @@ void EntitySimulation::clearEntities() {
void EntitySimulation::moveSimpleKinematics(const quint64& now) { void EntitySimulation::moveSimpleKinematics(const quint64& now) {
SetOfEntities::iterator itemItr = _simpleKinematicEntities.begin(); SetOfEntities::iterator itemItr = _simpleKinematicEntities.begin();
while (itemItr != _simpleKinematicEntities.end()) { while (itemItr != _simpleKinematicEntities.end()) {
EntityItem* entity = *itemItr; EntityItemPointer entity = *itemItr;
if (entity->isMoving() && !entity->getPhysicsInfo()) { if (entity->isMoving() && !entity->getPhysicsInfo()) {
entity->simulate(now); entity->simulate(now);
_entitiesToSort.insert(entity); _entitiesToSort.insert(entity);

16
libraries/entities/src/EntitySimulation.h
View file

@ -21,8 +21,8 @@
#include "EntityItem.h" #include "EntityItem.h"
#include "EntityTree.h" #include "EntityTree.h"
typedef QSet<EntityItem*> SetOfEntities; typedef QSet<EntityItemPointer> SetOfEntities;
typedef QVector<EntityItem*> VectorOfEntities; typedef QVector<EntityItemPointer> VectorOfEntities;
// the EntitySimulation needs to know when these things change on an entity, // the EntitySimulation needs to know when these things change on an entity,
// so it can sort EntityItem or relay its state to the PhysicsEngine. // so it can sort EntityItem or relay its state to the PhysicsEngine.
@ -59,16 +59,16 @@ public:
protected: // these only called by the EntityTree? protected: // these only called by the EntityTree?
/// \param entity pointer to EntityItem to be added /// \param entity pointer to EntityItem to be added
/// \sideeffect sets relevant backpointers in entity, but maybe later when appropriate data structures are locked /// \sideeffect sets relevant backpointers in entity, but maybe later when appropriate data structures are locked
void addEntity(EntityItem* entity); void addEntity(EntityItemPointer entity);
/// \param entity pointer to EntityItem to be removed /// \param entity pointer to EntityItem to be removed
/// \brief the actual removal may happen later when appropriate data structures are locked /// \brief the actual removal may happen later when appropriate data structures are locked
/// \sideeffect nulls relevant backpointers in entity /// \sideeffect nulls relevant backpointers in entity
void removeEntity(EntityItem* entity); void removeEntity(EntityItemPointer entity);
/// \param entity pointer to EntityItem to that may have changed in a way that would affect its simulation /// \param entity pointer to EntityItem to that may have changed in a way that would affect its simulation
/// call this whenever an entity was changed from some EXTERNAL event (NOT by the EntitySimulation itself) /// call this whenever an entity was changed from some EXTERNAL event (NOT by the EntitySimulation itself)
void changeEntity(EntityItem* entity); void changeEntity(EntityItemPointer entity);
void clearEntities(); void clearEntities();
@ -88,9 +88,9 @@ protected:
// These pure virtual methods are protected because they are not to be called will-nilly. The base class // These pure virtual methods are protected because they are not to be called will-nilly. The base class
// calls them in the right places. // calls them in the right places.
virtual void updateEntitiesInternal(const quint64& now) = 0; virtual void updateEntitiesInternal(const quint64& now) = 0;
virtual void addEntityInternal(EntityItem* entity); virtual void addEntityInternal(EntityItemPointer entity);
virtual void removeEntityInternal(EntityItem* entity) = 0; virtual void removeEntityInternal(EntityItemPointer entity) = 0;
virtual void changeEntityInternal(EntityItem* entity); virtual void changeEntityInternal(EntityItemPointer entity);
virtual void clearEntitiesInternal() = 0; virtual void clearEntitiesInternal() = 0;
void expireMortalEntities(const quint64& now); void expireMortalEntities(const quint64& now);

64
libraries/entities/src/EntityTree.cpp
View file

@ -75,7 +75,7 @@ bool EntityTree::handlesEditPacketType(PacketType packetType) const {
} }
/// Adds a new entity item to the tree /// Adds a new entity item to the tree
void EntityTree::postAddEntity(EntityItem* entity) { void EntityTree::postAddEntity(EntityItemPointer entity) {
assert(entity); assert(entity);
// check to see if we need to simulate this entity.. // check to see if we need to simulate this entity..
if (_simulation) { if (_simulation) {
@ -94,7 +94,7 @@ bool EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProp
return false; return false;
} }
EntityItem* existingEntity = containingElement->getEntityWithEntityItemID(entityID); EntityItemPointer existingEntity = containingElement->getEntityWithEntityItemID(entityID);
if (!existingEntity) { if (!existingEntity) {
qCDebug(entities) << "UNEXPECTED!!!! don't call updateEntity() on entity items that don't exist. entityID=" << entityID; qCDebug(entities) << "UNEXPECTED!!!! don't call updateEntity() on entity items that don't exist. entityID=" << entityID;
return false; return false;
@ -103,7 +103,7 @@ bool EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProp
return updateEntityWithElement(existingEntity, properties, containingElement, senderNode); return updateEntityWithElement(existingEntity, properties, containingElement, senderNode);
} }
bool EntityTree::updateEntity(EntityItem* entity, const EntityItemProperties& properties, const SharedNodePointer& senderNode) { bool EntityTree::updateEntity(EntityItemPointer entity, const EntityItemProperties& properties, const SharedNodePointer& senderNode) {
EntityTreeElement* containingElement = getContainingElement(entity->getEntityItemID()); EntityTreeElement* containingElement = getContainingElement(entity->getEntityItemID());
if (!containingElement) { if (!containingElement) {
qCDebug(entities) << "UNEXPECTED!!!! EntityTree::updateEntity() entity-->element lookup failed!!! entityID=" qCDebug(entities) << "UNEXPECTED!!!! EntityTree::updateEntity() entity-->element lookup failed!!! entityID="
@ -113,7 +113,7 @@ bool EntityTree::updateEntity(EntityItem* entity, const EntityItemProperties& pr
return updateEntityWithElement(entity, properties, containingElement, senderNode); return updateEntityWithElement(entity, properties, containingElement, senderNode);
} }
bool EntityTree::updateEntityWithElement(EntityItem* entity, const EntityItemProperties& origProperties, bool EntityTree::updateEntityWithElement(EntityItemPointer entity, const EntityItemProperties& origProperties,
EntityTreeElement* containingElement, const SharedNodePointer& senderNode) { EntityTreeElement* containingElement, const SharedNodePointer& senderNode) {
EntityItemProperties properties = origProperties; EntityItemProperties properties = origProperties;
@ -220,8 +220,8 @@ bool EntityTree::updateEntityWithElement(EntityItem* entity, const EntityItemPro
return true; return true;
} }
EntityItem* EntityTree::addEntity(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer EntityTree::addEntity(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = NULL; EntityItemPointer result = NULL;
if (getIsClient()) { if (getIsClient()) {
// if our Node isn't allowed to create entities in this domain, don't try. // if our Node isn't allowed to create entities in this domain, don't try.
@ -291,7 +291,7 @@ void EntityTree::deleteEntity(const EntityItemID& entityID, bool force, bool ign
return; return;
} }
EntityItem* existingEntity = containingElement->getEntityWithEntityItemID(entityID); EntityItemPointer existingEntity = containingElement->getEntityWithEntityItemID(entityID);
if (!existingEntity) { if (!existingEntity) {
if (!ignoreWarnings) { if (!ignoreWarnings) {
qCDebug(entities) << "UNEXPECTED!!!! don't call EntityTree::deleteEntity() on entity items that don't exist. " qCDebug(entities) << "UNEXPECTED!!!! don't call EntityTree::deleteEntity() on entity items that don't exist. "
@ -328,7 +328,7 @@ void EntityTree::deleteEntities(QSet<EntityItemID> entityIDs, bool force, bool i
continue; continue;
} }
EntityItem* existingEntity = containingElement->getEntityWithEntityItemID(entityID); EntityItemPointer existingEntity = containingElement->getEntityWithEntityItemID(entityID);
if (!existingEntity) { if (!existingEntity) {
if (!ignoreWarnings) { if (!ignoreWarnings) {
qCDebug(entities) << "UNEXPECTED!!!! don't call EntityTree::deleteEntities() on entity items that don't exist. " qCDebug(entities) << "UNEXPECTED!!!! don't call EntityTree::deleteEntities() on entity items that don't exist. "
@ -362,7 +362,7 @@ void EntityTree::processRemovedEntities(const DeleteEntityOperator& theOperator)
_simulation->lock(); _simulation->lock();
} }
foreach(const EntityToDeleteDetails& details, entities) { foreach(const EntityToDeleteDetails& details, entities) {
EntityItem* theEntity = details.entity; EntityItemPointer theEntity = details.entity;
if (getIsServer()) { if (getIsServer()) {
// set up the deleted entities ID // set up the deleted entities ID
@ -374,8 +374,7 @@ void EntityTree::processRemovedEntities(const DeleteEntityOperator& theOperator)
if (_simulation) { if (_simulation) {
_simulation->removeEntity(theEntity); _simulation->removeEntity(theEntity);
} }
delete theEntity; // we can delete the entity immediately
} }
if (_simulation) { if (_simulation) {
_simulation->unlock(); _simulation->unlock();
@ -388,7 +387,7 @@ public:
glm::vec3 position; glm::vec3 position;
float targetRadius; float targetRadius;
bool found; bool found;
const EntityItem* closestEntity; EntityItemPointer closestEntity;
float closestEntityDistance; float closestEntityDistance;
}; };
@ -402,7 +401,7 @@ bool EntityTree::findNearPointOperation(OctreeElement* element, void* extraData)
// If this entityTreeElement contains the point, then search it... // If this entityTreeElement contains the point, then search it...
if (sphereIntersection) { if (sphereIntersection) {
const EntityItem* thisClosestEntity = entityTreeElement->getClosestEntity(args->position); EntityItemPointer thisClosestEntity = entityTreeElement->getClosestEntity(args->position);
// we may have gotten NULL back, meaning no entity was available // we may have gotten NULL back, meaning no entity was available
if (thisClosestEntity) { if (thisClosestEntity) {
@ -428,7 +427,7 @@ bool EntityTree::findNearPointOperation(OctreeElement* element, void* extraData)
return false; return false;
} }
const EntityItem* EntityTree::findClosestEntity(glm::vec3 position, float targetRadius) { EntityItemPointer EntityTree::findClosestEntity(glm::vec3 position, float targetRadius) {
FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX }; FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX };
lockForRead(); lockForRead();
// NOTE: This should use recursion, since this is a spatial operation // NOTE: This should use recursion, since this is a spatial operation
@ -441,7 +440,7 @@ class FindAllNearPointArgs {
public: public:
glm::vec3 position; glm::vec3 position;
float targetRadius; float targetRadius;
QVector<const EntityItem*> entities; QVector<EntityItemPointer> entities;
}; };
@ -462,8 +461,8 @@ bool EntityTree::findInSphereOperation(OctreeElement* element, void* extraData)
} }
// NOTE: assumes caller has handled locking // NOTE: assumes caller has handled locking
void EntityTree::findEntities(const glm::vec3& center, float radius, QVector<const EntityItem*>& foundEntities) { void EntityTree::findEntities(const glm::vec3& center, float radius, QVector<EntityItemPointer>& foundEntities) {
FindAllNearPointArgs args = { center, radius, QVector<const EntityItem*>() }; FindAllNearPointArgs args = { center, radius, QVector<EntityItemPointer>() };
// NOTE: This should use recursion, since this is a spatial operation // NOTE: This should use recursion, since this is a spatial operation
recurseTreeWithOperation(findInSphereOperation, &args); recurseTreeWithOperation(findInSphereOperation, &args);
@ -478,7 +477,7 @@ public:
} }
AACube _cube; AACube _cube;
QVector<EntityItem*> _foundEntities; QVector<EntityItemPointer> _foundEntities;
}; };
bool EntityTree::findInCubeOperation(OctreeElement* element, void* extraData) { bool EntityTree::findInCubeOperation(OctreeElement* element, void* extraData) {
@ -492,7 +491,7 @@ bool EntityTree::findInCubeOperation(OctreeElement* element, void* extraData) {
} }
// NOTE: assumes caller has handled locking // NOTE: assumes caller has handled locking
void EntityTree::findEntities(const AACube& cube, QVector<EntityItem*>& foundEntities) { void EntityTree::findEntities(const AACube& cube, QVector<EntityItemPointer>& foundEntities) {
FindEntitiesInCubeArgs args(cube); FindEntitiesInCubeArgs args(cube);
// NOTE: This should use recursion, since this is a spatial operation // NOTE: This should use recursion, since this is a spatial operation
recurseTreeWithOperation(findInCubeOperation, &args); recurseTreeWithOperation(findInCubeOperation, &args);
@ -507,7 +506,7 @@ public:
} }
AABox _box; AABox _box;
QVector<EntityItem*> _foundEntities; QVector<EntityItemPointer> _foundEntities;
}; };
bool EntityTree::findInBoxOperation(OctreeElement* element, void* extraData) { bool EntityTree::findInBoxOperation(OctreeElement* element, void* extraData) {
@ -521,7 +520,7 @@ bool EntityTree::findInBoxOperation(OctreeElement* element, void* extraData) {
} }
// NOTE: assumes caller has handled locking // NOTE: assumes caller has handled locking
void EntityTree::findEntities(const AABox& box, QVector<EntityItem*>& foundEntities) { void EntityTree::findEntities(const AABox& box, QVector<EntityItemPointer>& foundEntities) {
FindEntitiesInBoxArgs args(box); FindEntitiesInBoxArgs args(box);
// NOTE: This should use recursion, since this is a spatial operation // NOTE: This should use recursion, since this is a spatial operation
recurseTreeWithOperation(findInBoxOperation, &args); recurseTreeWithOperation(findInBoxOperation, &args);
@ -529,13 +528,13 @@ void EntityTree::findEntities(const AABox& box, QVector<EntityItem*>& foundEntit
foundEntities.swap(args._foundEntities); foundEntities.swap(args._foundEntities);
} }
EntityItem* EntityTree::findEntityByID(const QUuid& id) { EntityItemPointer EntityTree::findEntityByID(const QUuid& id) {
EntityItemID entityID(id); EntityItemID entityID(id);
return findEntityByEntityItemID(entityID); return findEntityByEntityItemID(entityID);
} }
EntityItem* EntityTree::findEntityByEntityItemID(const EntityItemID& entityID) /*const*/ { EntityItemPointer EntityTree::findEntityByEntityItemID(const EntityItemID& entityID) /*const*/ {
EntityItem* foundEntity = NULL; EntityItemPointer foundEntity = NULL;
EntityTreeElement* containingElement = getContainingElement(entityID); EntityTreeElement* containingElement = getContainingElement(entityID);
if (containingElement) { if (containingElement) {
foundEntity = containingElement->getEntityWithEntityItemID(entityID); foundEntity = containingElement->getEntityWithEntityItemID(entityID);
@ -571,7 +570,7 @@ int EntityTree::processEditPacketData(PacketType packetType, const unsigned char
// an existing entity... handle appropriately // an existing entity... handle appropriately
if (validEditPacket) { if (validEditPacket) {
// search for the entity by EntityItemID // search for the entity by EntityItemID
EntityItem* existingEntity = findEntityByEntityItemID(entityItemID); EntityItemPointer existingEntity = findEntityByEntityItemID(entityItemID);
if (existingEntity && packetType == PacketTypeEntityEdit) { if (existingEntity && packetType == PacketTypeEntityEdit) {
// if the EntityItem exists, then update it // if the EntityItem exists, then update it
if (wantEditLogging()) { if (wantEditLogging()) {
@ -588,7 +587,7 @@ int EntityTree::processEditPacketData(PacketType packetType, const unsigned char
qCDebug(entities) << " properties:" << properties; qCDebug(entities) << " properties:" << properties;
} }
properties.setCreated(properties.getLastEdited()); properties.setCreated(properties.getLastEdited());
EntityItem* newEntity = addEntity(entityItemID, properties); EntityItemPointer newEntity = addEntity(entityItemID, properties);
if (newEntity) { if (newEntity) {
newEntity->markAsChangedOnServer(); newEntity->markAsChangedOnServer();
notifyNewlyCreatedEntity(*newEntity, senderNode); notifyNewlyCreatedEntity(*newEntity, senderNode);
@ -604,7 +603,7 @@ int EntityTree::processEditPacketData(PacketType packetType, const unsigned char
<< "] attempted to add an entity."; << "] attempted to add an entity.";
} }
} else { } else {
qCDebug(entities) << "Add or Edit failed." << packetType << existingEntity; qCDebug(entities) << "Add or Edit failed." << packetType << existingEntity.get();
} }
} }
break; break;
@ -652,7 +651,7 @@ void EntityTree::releaseSceneEncodeData(OctreeElementExtraEncodeData* extraEncod
extraEncodeData->clear(); extraEncodeData->clear();
} }
void EntityTree::entityChanged(EntityItem* entity) { void EntityTree::entityChanged(EntityItemPointer entity) {
if (_simulation) { if (_simulation) {
_simulation->lock(); _simulation->lock();
_simulation->changeEntity(entity); _simulation->changeEntity(entity);
@ -672,11 +671,12 @@ void EntityTree::update() {
if (pendingDeletes.size() > 0) { if (pendingDeletes.size() > 0) {
// translate into list of ID's // translate into list of ID's
QSet<EntityItemID> idsToDelete; QSet<EntityItemID> idsToDelete;
for (auto entityItr : pendingDeletes) {
EntityItem* entity = &(*entityItr); for (auto entity : pendingDeletes) {
assert(!entity->getPhysicsInfo()); // TODO: Andrew to remove this after testing assert(!entity->getPhysicsInfo()); // TODO: Andrew to remove this after testing
idsToDelete.insert(entity->getEntityItemID()); idsToDelete.insert(entity->getEntityItemID());
} }
// delete these things the roundabout way // delete these things the roundabout way
deleteEntities(idsToDelete, true); deleteEntities(idsToDelete, true);
} }
@ -1004,7 +1004,7 @@ bool EntityTree::sendEntitiesOperation(OctreeElement* element, void* extraData)
SendEntitiesOperationArgs* args = static_cast<SendEntitiesOperationArgs*>(extraData); SendEntitiesOperationArgs* args = static_cast<SendEntitiesOperationArgs*>(extraData);
EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element); EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element);
const QList<EntityItem*>& entities = entityTreeElement->getEntities(); const EntityItems& entities = entityTreeElement->getEntities();
for (int i = 0; i < entities.size(); i++) { for (int i = 0; i < entities.size(); i++) {
EntityItemID newID(QUuid::createUuid()); EntityItemID newID(QUuid::createUuid());
args->newEntityIDs->append(newID); args->newEntityIDs->append(newID);
@ -1056,7 +1056,7 @@ bool EntityTree::readFromMap(QVariantMap& map) {
entityItemID = EntityItemID(QUuid::createUuid()); entityItemID = EntityItemID(QUuid::createUuid());
} }
EntityItem* entity = addEntity(entityItemID, properties); EntityItemPointer entity = addEntity(entityItemID, properties);
if (!entity) { if (!entity) {
qCDebug(entities) << "adding Entity failed:" << entityItemID << properties.getType(); qCDebug(entities) << "adding Entity failed:" << entityItemID << properties.getType();
} }

38
libraries/entities/src/EntityTree.h
View file

@ -30,9 +30,9 @@ public:
class EntityItemFBXService { class EntityItemFBXService {
public: public:
virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem) = 0; virtual const FBXGeometry* getGeometryForEntity(EntityItemPointer entityItem) = 0;
virtual const Model* getModelForEntityItem(const EntityItem* entityItem) = 0; virtual const Model* getModelForEntityItem(EntityItemPointer entityItem) = 0;
virtual const FBXGeometry* getCollisionGeometryForEntity(const EntityItem* entityItem) = 0; virtual const FBXGeometry* getCollisionGeometryForEntity(EntityItemPointer entityItem) = 0;
}; };
@ -83,24 +83,24 @@ public:
virtual void update(); virtual void update();
// The newer API... // The newer API...
void postAddEntity(EntityItem* entityItem); void postAddEntity(EntityItemPointer entityItem);
EntityItem* addEntity(const EntityItemID& entityID, const EntityItemProperties& properties); EntityItemPointer addEntity(const EntityItemID& entityID, const EntityItemProperties& properties);
// use this method if you only know the entityID // use this method if you only know the entityID
bool updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties, const SharedNodePointer& senderNode = SharedNodePointer(nullptr)); bool updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties, const SharedNodePointer& senderNode = SharedNodePointer(nullptr));
// use this method if you have a pointer to the entity (avoid an extra entity lookup) // use this method if you have a pointer to the entity (avoid an extra entity lookup)
bool updateEntity(EntityItem* entity, const EntityItemProperties& properties, const SharedNodePointer& senderNode = SharedNodePointer(nullptr)); bool updateEntity(EntityItemPointer entity, const EntityItemProperties& properties, const SharedNodePointer& senderNode = SharedNodePointer(nullptr));
void deleteEntity(const EntityItemID& entityID, bool force = false, bool ignoreWarnings = false); void deleteEntity(const EntityItemID& entityID, bool force = false, bool ignoreWarnings = false);
void deleteEntities(QSet<EntityItemID> entityIDs, bool force = false, bool ignoreWarnings = false); void deleteEntities(QSet<EntityItemID> entityIDs, bool force = false, bool ignoreWarnings = false);
/// \param position point of query in world-frame (meters) /// \param position point of query in world-frame (meters)
/// \param targetRadius radius of query (meters) /// \param targetRadius radius of query (meters)
const EntityItem* findClosestEntity(glm::vec3 position, float targetRadius); EntityItemPointer findClosestEntity(glm::vec3 position, float targetRadius);
EntityItem* findEntityByID(const QUuid& id); EntityItemPointer findEntityByID(const QUuid& id);
EntityItem* findEntityByEntityItemID(const EntityItemID& entityID); EntityItemPointer findEntityByEntityItemID(const EntityItemID& entityID);
EntityItemID assignEntityID(const EntityItemID& entityItemID); /// Assigns a known ID for a creator token ID EntityItemID assignEntityID(const EntityItemID& entityItemID); /// Assigns a known ID for a creator token ID
@ -108,21 +108,21 @@ public:
/// finds all entities that touch a sphere /// finds all entities that touch a sphere
/// \param center the center of the sphere in world-frame (meters) /// \param center the center of the sphere in world-frame (meters)
/// \param radius the radius of the sphere in world-frame (meters) /// \param radius the radius of the sphere in world-frame (meters)
/// \param foundEntities[out] vector of const EntityItem* /// \param foundEntities[out] vector of EntityItemPointer
/// \remark Side effect: any initial contents in foundEntities will be lost /// \remark Side effect: any initial contents in foundEntities will be lost
void findEntities(const glm::vec3& center, float radius, QVector<const EntityItem*>& foundEntities); void findEntities(const glm::vec3& center, float radius, QVector<EntityItemPointer>& foundEntities);
/// finds all entities that touch a cube /// finds all entities that touch a cube
/// \param cube the query cube in world-frame (meters) /// \param cube the query cube in world-frame (meters)
/// \param foundEntities[out] vector of non-const EntityItem* /// \param foundEntities[out] vector of non-EntityItemPointer
/// \remark Side effect: any initial contents in entities will be lost /// \remark Side effect: any initial contents in entities will be lost
void findEntities(const AACube& cube, QVector<EntityItem*>& foundEntities); void findEntities(const AACube& cube, QVector<EntityItemPointer>& foundEntities);
/// finds all entities that touch a box /// finds all entities that touch a box
/// \param box the query box in world-frame (meters) /// \param box the query box in world-frame (meters)
/// \param foundEntities[out] vector of non-const EntityItem* /// \param foundEntities[out] vector of non-EntityItemPointer
/// \remark Side effect: any initial contents in entities will be lost /// \remark Side effect: any initial contents in entities will be lost
void findEntities(const AABox& box, QVector<EntityItem*>& foundEntities); void findEntities(const AABox& box, QVector<EntityItemPointer>& foundEntities);
void addNewlyCreatedHook(NewlyCreatedEntityHook* hook); void addNewlyCreatedHook(NewlyCreatedEntityHook* hook);
void removeNewlyCreatedHook(NewlyCreatedEntityHook* hook); void removeNewlyCreatedHook(NewlyCreatedEntityHook* hook);
@ -138,10 +138,10 @@ public:
EntityItemFBXService* getFBXService() const { return _fbxService; } EntityItemFBXService* getFBXService() const { return _fbxService; }
void setFBXService(EntityItemFBXService* service) { _fbxService = service; } void setFBXService(EntityItemFBXService* service) { _fbxService = service; }
const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem) { const FBXGeometry* getGeometryForEntity(EntityItemPointer entityItem) {
return _fbxService ? _fbxService->getGeometryForEntity(entityItem) : NULL; return _fbxService ? _fbxService->getGeometryForEntity(entityItem) : NULL;
} }
const Model* getModelForEntityItem(const EntityItem* entityItem) { const Model* getModelForEntityItem(EntityItemPointer entityItem) {
return _fbxService ? _fbxService->getModelForEntityItem(entityItem) : NULL; return _fbxService ? _fbxService->getModelForEntityItem(entityItem) : NULL;
} }
@ -153,7 +153,7 @@ public:
QVector<EntityItemID> sendEntities(EntityEditPacketSender* packetSender, EntityTree* localTree, float x, float y, float z); QVector<EntityItemID> sendEntities(EntityEditPacketSender* packetSender, EntityTree* localTree, float x, float y, float z);
void entityChanged(EntityItem* entity); void entityChanged(EntityItemPointer entity);
void emitEntityScriptChanging(const EntityItemID& entityItemID); void emitEntityScriptChanging(const EntityItemID& entityItemID);
@ -177,7 +177,7 @@ signals:
private: private:
void processRemovedEntities(const DeleteEntityOperator& theOperator); void processRemovedEntities(const DeleteEntityOperator& theOperator);
bool updateEntityWithElement(EntityItem* entity, const EntityItemProperties& properties, bool updateEntityWithElement(EntityItemPointer entity, const EntityItemProperties& properties,
EntityTreeElement* containingElement, EntityTreeElement* containingElement,
const SharedNodePointer& senderNode = SharedNodePointer(nullptr)); const SharedNodePointer& senderNode = SharedNodePointer(nullptr));
static bool findNearPointOperation(OctreeElement* element, void* extraData); static bool findNearPointOperation(OctreeElement* element, void* extraData);

76
libraries/entities/src/EntityTreeElement.cpp
View file

@ -39,7 +39,7 @@ OctreeElement* EntityTreeElement::createNewElement(unsigned char* octalCode) {
void EntityTreeElement::init(unsigned char* octalCode) { void EntityTreeElement::init(unsigned char* octalCode) {
OctreeElement::init(octalCode); OctreeElement::init(octalCode);
_entityItems = new QList<EntityItem*>; _entityItems = new EntityItems;
_octreeMemoryUsage += sizeof(EntityTreeElement); _octreeMemoryUsage += sizeof(EntityTreeElement);
} }
@ -85,7 +85,7 @@ void EntityTreeElement::initializeExtraEncodeData(EncodeBitstreamParams& params)
} }
} }
for (uint16_t i = 0; i < _entityItems->size(); i++) { for (uint16_t i = 0; i < _entityItems->size(); i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
entityTreeElementExtraEncodeData->entities.insert(entity->getEntityItemID(), entity->getEntityProperties(params)); entityTreeElementExtraEncodeData->entities.insert(entity->getEntityItemID(), entity->getEntityProperties(params));
} }
@ -263,7 +263,7 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
} }
} }
for (uint16_t i = 0; i < _entityItems->size(); i++) { for (uint16_t i = 0; i < _entityItems->size(); i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
entityTreeElementExtraEncodeData->entities.insert(entity->getEntityItemID(), entity->getEntityProperties(params)); entityTreeElementExtraEncodeData->entities.insert(entity->getEntityItemID(), entity->getEntityProperties(params));
} }
} }
@ -284,7 +284,7 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
// need to handle the case where our sibling elements need encoding but we don't. // need to handle the case where our sibling elements need encoding but we don't.
if (!entityTreeElementExtraEncodeData->elementCompleted) { if (!entityTreeElementExtraEncodeData->elementCompleted) {
for (uint16_t i = 0; i < _entityItems->size(); i++) { for (uint16_t i = 0; i < _entityItems->size(); i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
bool includeThisEntity = true; bool includeThisEntity = true;
if (!params.forceSendScene && entity->getLastChangedOnServer() < params.lastViewFrustumSent) { if (!params.forceSendScene && entity->getLastChangedOnServer() < params.lastViewFrustumSent) {
@ -320,7 +320,7 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
if (successAppendEntityCount) { if (successAppendEntityCount) {
foreach (uint16_t i, indexesOfEntitiesToInclude) { foreach (uint16_t i, indexesOfEntitiesToInclude) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
LevelDetails entityLevel = packetData->startLevel(); LevelDetails entityLevel = packetData->startLevel();
OctreeElement::AppendState appendEntityState = entity->appendEntityData(packetData, OctreeElement::AppendState appendEntityState = entity->appendEntityData(packetData,
params, entityTreeElementExtraEncodeData); params, entityTreeElementExtraEncodeData);
@ -408,11 +408,11 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
return appendElementState; return appendElementState;
} }
bool EntityTreeElement::containsEntityBounds(const EntityItem* entity) const { bool EntityTreeElement::containsEntityBounds(EntityItemPointer entity) const {
return containsBounds(entity->getMaximumAACube()); return containsBounds(entity->getMaximumAACube());
} }
bool EntityTreeElement::bestFitEntityBounds(const EntityItem* entity) const { bool EntityTreeElement::bestFitEntityBounds(EntityItemPointer entity) const {
return bestFitBounds(entity->getMaximumAACube()); return bestFitBounds(entity->getMaximumAACube());
} }
@ -476,14 +476,14 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
// only called if we do intersect our bounding cube, but find if we actually intersect with entities... // only called if we do intersect our bounding cube, but find if we actually intersect with entities...
int entityNumber = 0; int entityNumber = 0;
QList<EntityItem*>::iterator entityItr = _entityItems->begin(); EntityItems::iterator entityItr = _entityItems->begin();
QList<EntityItem*>::const_iterator entityEnd = _entityItems->end(); EntityItems::const_iterator entityEnd = _entityItems->end();
bool somethingIntersected = false; bool somethingIntersected = false;
//float bestEntityDistance = distance; //float bestEntityDistance = distance;
while(entityItr != entityEnd) { while(entityItr != entityEnd) {
EntityItem* entity = (*entityItr); EntityItemPointer entity = (*entityItr);
AABox entityBox = entity->getAABox(); AABox entityBox = entity->getAABox();
float localDistance; float localDistance;
@ -519,7 +519,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
if (localDistance < distance) { if (localDistance < distance) {
distance = localDistance; distance = localDistance;
face = localFace; face = localFace;
*intersectedObject = (void*)entity; *intersectedObject = (void*)entity.get();
somethingIntersected = true; somethingIntersected = true;
} }
} }
@ -528,7 +528,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
if (localDistance < distance) { if (localDistance < distance) {
distance = localDistance; distance = localDistance;
face = localFace; face = localFace;
*intersectedObject = (void*)entity; *intersectedObject = (void*)entity.get();
somethingIntersected = true; somethingIntersected = true;
} }
} }
@ -545,10 +545,10 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
// TODO: change this to use better bounding shape for entity than sphere // TODO: change this to use better bounding shape for entity than sphere
bool EntityTreeElement::findSpherePenetration(const glm::vec3& center, float radius, bool EntityTreeElement::findSpherePenetration(const glm::vec3& center, float radius,
glm::vec3& penetration, void** penetratedObject) const { glm::vec3& penetration, void** penetratedObject) const {
QList<EntityItem*>::iterator entityItr = _entityItems->begin(); EntityItems::iterator entityItr = _entityItems->begin();
QList<EntityItem*>::const_iterator entityEnd = _entityItems->end(); EntityItems::const_iterator entityEnd = _entityItems->end();
while(entityItr != entityEnd) { while(entityItr != entityEnd) {
EntityItem* entity = (*entityItr); EntityItemPointer entity = (*entityItr);
glm::vec3 entityCenter = entity->getPosition(); glm::vec3 entityCenter = entity->getPosition();
float entityRadius = entity->getRadius(); float entityRadius = entity->getRadius();
@ -559,7 +559,9 @@ bool EntityTreeElement::findSpherePenetration(const glm::vec3& center, float rad
if (findSphereSpherePenetration(center, radius, entityCenter, entityRadius, penetration)) { if (findSphereSpherePenetration(center, radius, entityCenter, entityRadius, penetration)) {
// return true on first valid entity penetration // return true on first valid entity penetration
*penetratedObject = (void*)(entity);
*penetratedObject = (void*)(entity.get());
return true; return true;
} }
++entityItr; ++entityItr;
@ -567,8 +569,8 @@ bool EntityTreeElement::findSpherePenetration(const glm::vec3& center, float rad
return false; return false;
} }
const EntityItem* EntityTreeElement::getClosestEntity(glm::vec3 position) const { EntityItemPointer EntityTreeElement::getClosestEntity(glm::vec3 position) const {
const EntityItem* closestEntity = NULL; EntityItemPointer closestEntity = NULL;
float closestEntityDistance = FLT_MAX; float closestEntityDistance = FLT_MAX;
uint16_t numberOfEntities = _entityItems->size(); uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
@ -581,10 +583,10 @@ const EntityItem* EntityTreeElement::getClosestEntity(glm::vec3 position) const
} }
// TODO: change this to use better bounding shape for entity than sphere // TODO: change this to use better bounding shape for entity than sphere
void EntityTreeElement::getEntities(const glm::vec3& searchPosition, float searchRadius, QVector<const EntityItem*>& foundEntities) const { void EntityTreeElement::getEntities(const glm::vec3& searchPosition, float searchRadius, QVector<EntityItemPointer>& foundEntities) const {
uint16_t numberOfEntities = _entityItems->size(); uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
const EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
float distance = glm::length(entity->getPosition() - searchPosition); float distance = glm::length(entity->getPosition() - searchPosition);
if (distance < searchRadius + entity->getRadius()) { if (distance < searchRadius + entity->getRadius()) {
foundEntities.push_back(entity); foundEntities.push_back(entity);
@ -593,12 +595,12 @@ void EntityTreeElement::getEntities(const glm::vec3& searchPosition, float searc
} }
// TODO: change this to use better bounding shape for entity than sphere // TODO: change this to use better bounding shape for entity than sphere
void EntityTreeElement::getEntities(const AACube& box, QVector<EntityItem*>& foundEntities) { void EntityTreeElement::getEntities(const AACube& box, QVector<EntityItemPointer>& foundEntities) {
QList<EntityItem*>::iterator entityItr = _entityItems->begin(); EntityItems::iterator entityItr = _entityItems->begin();
QList<EntityItem*>::iterator entityEnd = _entityItems->end(); EntityItems::iterator entityEnd = _entityItems->end();
AACube entityCube; AACube entityCube;
while(entityItr != entityEnd) { while(entityItr != entityEnd) {
EntityItem* entity = (*entityItr); EntityItemPointer entity = (*entityItr);
float radius = entity->getRadius(); float radius = entity->getRadius();
// NOTE: we actually do cube-cube collision queries here, which is sloppy but good enough for now // NOTE: we actually do cube-cube collision queries here, which is sloppy but good enough for now
// TODO: decide whether to replace entityCube-cube query with sphere-cube (requires a square root // TODO: decide whether to replace entityCube-cube query with sphere-cube (requires a square root
@ -611,8 +613,8 @@ void EntityTreeElement::getEntities(const AACube& box, QVector<EntityItem*>& fou
} }
} }
const EntityItem* EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id) const { EntityItemPointer EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id) const {
const EntityItem* foundEntity = NULL; EntityItemPointer foundEntity = NULL;
uint16_t numberOfEntities = _entityItems->size(); uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
if ((*_entityItems)[i]->getEntityItemID() == id) { if ((*_entityItems)[i]->getEntityItemID() == id) {
@ -623,8 +625,8 @@ const EntityItem* EntityTreeElement::getEntityWithEntityItemID(const EntityItemI
return foundEntity; return foundEntity;
} }
EntityItem* EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id) { EntityItemPointer EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id) {
EntityItem* foundEntity = NULL; EntityItemPointer foundEntity = NULL;
uint16_t numberOfEntities = _entityItems->size(); uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
if ((*_entityItems)[i]->getEntityItemID() == id) { if ((*_entityItems)[i]->getEntityItemID() == id) {
@ -638,9 +640,13 @@ EntityItem* EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id)
void EntityTreeElement::cleanupEntities() { void EntityTreeElement::cleanupEntities() {
uint16_t numberOfEntities = _entityItems->size(); uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
entity->_element = NULL; entity->_element = NULL;
delete entity;
// NOTE: We explicitly don't delete the EntityItem here because since we only
// access it by smart pointers, when we remove it from the _entityItems
// we know that it will be deleted.
//delete entity;
} }
_entityItems->clear(); _entityItems->clear();
} }
@ -659,7 +665,7 @@ bool EntityTreeElement::removeEntityWithEntityItemID(const EntityItemID& id) {
return foundEntity; return foundEntity;
} }
bool EntityTreeElement::removeEntityItem(EntityItem* entity) { bool EntityTreeElement::removeEntityItem(EntityItemPointer entity) {
int numEntries = _entityItems->removeAll(entity); int numEntries = _entityItems->removeAll(entity);
if (numEntries > 0) { if (numEntries > 0) {
assert(entity->_element == this); assert(entity->_element == this);
@ -706,7 +712,7 @@ int EntityTreeElement::readElementDataFromBuffer(const unsigned char* data, int
for (uint16_t i = 0; i < numberOfEntities; i++) { for (uint16_t i = 0; i < numberOfEntities; i++) {
int bytesForThisEntity = 0; int bytesForThisEntity = 0;
EntityItemID entityItemID; EntityItemID entityItemID;
EntityItem* entityItem = NULL; EntityItemPointer entityItem = NULL;
// Old model files don't have UUIDs in them. So we don't want to try to read those IDs from the stream. // Old model files don't have UUIDs in them. So we don't want to try to read those IDs from the stream.
// Since this can only happen on loading an old file, we can safely treat these as new entity cases, // Since this can only happen on loading an old file, we can safely treat these as new entity cases,
@ -771,7 +777,7 @@ int EntityTreeElement::readElementDataFromBuffer(const unsigned char* data, int
return bytesRead; return bytesRead;
} }
void EntityTreeElement::addEntityItem(EntityItem* entity) { void EntityTreeElement::addEntityItem(EntityItemPointer entity) {
assert(entity); assert(entity);
assert(entity->_element == NULL); assert(entity->_element == NULL);
_entityItems->push_back(entity); _entityItems->push_back(entity);
@ -809,7 +815,7 @@ bool EntityTreeElement::pruneChildren() {
void EntityTreeElement::expandExtentsToContents(Extents& extents) { void EntityTreeElement::expandExtentsToContents(Extents& extents) {
if (_entityItems->size()) { if (_entityItems->size()) {
for (uint16_t i = 0; i < _entityItems->size(); i++) { for (uint16_t i = 0; i < _entityItems->size(); i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
extents.add(entity->getAABox()); extents.add(entity->getAABox());
} }
} }
@ -825,7 +831,7 @@ void EntityTreeElement::debugDump() {
qCDebug(entities) << " has entities:" << _entityItems->size(); qCDebug(entities) << " has entities:" << _entityItems->size();
qCDebug(entities) << "--------------------------------------------------"; qCDebug(entities) << "--------------------------------------------------";
for (uint16_t i = 0; i < _entityItems->size(); i++) { for (uint16_t i = 0; i < _entityItems->size(); i++) {
EntityItem* entity = (*_entityItems)[i]; EntityItemPointer entity = (*_entityItems)[i];
entity->debugDump(); entity->debugDump();
} }
qCDebug(entities) << "--------------------------------------------------"; qCDebug(entities) << "--------------------------------------------------";

39
libraries/entities/src/EntityTreeElement.h
View file

@ -12,6 +12,8 @@
#ifndef hifi_EntityTreeElement_h #ifndef hifi_EntityTreeElement_h
#define hifi_EntityTreeElement_h #define hifi_EntityTreeElement_h
#include <memory>
#include <OctreeElement.h> #include <OctreeElement.h>
#include <QList> #include <QList>
@ -19,6 +21,8 @@
#include "EntityItem.h" #include "EntityItem.h"
#include "EntityTree.h" #include "EntityTree.h"
typedef QVector<EntityItemPointer> EntityItems;
class EntityTree; class EntityTree;
class EntityTreeElement; class EntityTreeElement;
@ -30,7 +34,7 @@ public:
_movingItems(0) _movingItems(0)
{ } { }
QList<EntityItem*> _movingEntities; QList<EntityItemPointer> _movingEntities;
int _totalElements; int _totalElements;
int _totalItems; int _totalItems;
int _movingItems; int _movingItems;
@ -142,40 +146,41 @@ public:
virtual bool findSpherePenetration(const glm::vec3& center, float radius, virtual bool findSpherePenetration(const glm::vec3& center, float radius,
glm::vec3& penetration, void** penetratedObject) const; glm::vec3& penetration, void** penetratedObject) const;
const QList<EntityItem*>& getEntities() const { return *_entityItems; } const EntityItems& getEntities() const { return *_entityItems; }
QList<EntityItem*>& getEntities() { return *_entityItems; } EntityItems& getEntities() { return *_entityItems; }
bool hasEntities() const { return _entityItems ? _entityItems->size() > 0 : false; } bool hasEntities() const { return _entityItems ? _entityItems->size() > 0 : false; }
void setTree(EntityTree* tree) { _myTree = tree; } void setTree(EntityTree* tree) { _myTree = tree; }
bool updateEntity(const EntityItem& entity); bool updateEntity(const EntityItem& entity);
void addEntityItem(EntityItem* entity); void addEntityItem(EntityItemPointer entity);
const EntityItem* getClosestEntity(glm::vec3 position) const; EntityItemPointer getClosestEntity(glm::vec3 position) const;
/// finds all entities that touch a sphere /// finds all entities that touch a sphere
/// \param position the center of the query sphere /// \param position the center of the query sphere
/// \param radius the radius of the query sphere /// \param radius the radius of the query sphere
/// \param entities[out] vector of const EntityItem* /// \param entities[out] vector of const EntityItemPointer
void getEntities(const glm::vec3& position, float radius, QVector<const EntityItem*>& foundEntities) const; void getEntities(const glm::vec3& position, float radius, QVector<EntityItemPointer>& foundEntities) const;
/// finds all entities that touch a box /// finds all entities that touch a box
/// \param box the query box /// \param box the query box
/// \param entities[out] vector of non-const EntityItem* /// \param entities[out] vector of non-const EntityItemPointer
void getEntities(const AACube& box, QVector<EntityItem*>& foundEntities); void getEntities(const AACube& box, QVector<EntityItemPointer>& foundEntities);
const EntityItem* getEntityWithID(uint32_t id) const; EntityItemPointer getEntityWithID(uint32_t id) const;
const EntityItem* getEntityWithEntityItemID(const EntityItemID& id) const; EntityItemPointer getEntityWithEntityItemID(const EntityItemID& id) const;
void getEntitiesInside(const AACube& box, QVector<EntityItem*>& foundEntities); void getEntitiesInside(const AACube& box, QVector<EntityItemPointer>& foundEntities);
EntityItem* getEntityWithEntityItemID(const EntityItemID& id); EntityItemPointer getEntityWithEntityItemID(const EntityItemID& id);
void cleanupEntities(); /// called by EntityTree on cleanup this will free all entities void cleanupEntities(); /// called by EntityTree on cleanup this will free all entities
bool removeEntityWithEntityItemID(const EntityItemID& id); bool removeEntityWithEntityItemID(const EntityItemID& id);
bool removeEntityItem(EntityItem* entity); bool removeEntityItem(EntityItemPointer entity);
bool containsEntityBounds(const EntityItem* entity) const; bool containsEntityBounds(EntityItemPointer entity) const;
bool bestFitEntityBounds(const EntityItem* entity) const; bool bestFitEntityBounds(EntityItemPointer entity) const;
bool containsBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters bool containsBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters
bool bestFitBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters bool bestFitBounds(const EntityItemProperties& properties) const; // NOTE: property units in meters
@ -198,7 +203,7 @@ public:
protected: protected:
virtual void init(unsigned char * octalCode); virtual void init(unsigned char * octalCode);
EntityTree* _myTree; EntityTree* _myTree;
QList<EntityItem*>* _entityItems; EntityItems* _entityItems;
}; };
#endif // hifi_EntityTreeElement_h #endif // hifi_EntityTreeElement_h

6
libraries/entities/src/EntityTypes.cpp
View file

@ -76,9 +76,9 @@ bool EntityTypes::registerEntityType(EntityType entityType, const char* name, En
return false; return false;
} }
EntityItem* EntityTypes::constructEntityItem(EntityType entityType, const EntityItemID& entityID, EntityItemPointer EntityTypes::constructEntityItem(EntityType entityType, const EntityItemID& entityID,
const EntityItemProperties& properties) { const EntityItemProperties& properties) {
EntityItem* newEntityItem = NULL; EntityItemPointer newEntityItem = NULL;
EntityTypeFactory factory = NULL; EntityTypeFactory factory = NULL;
if (entityType >= 0 && entityType <= LAST) { if (entityType >= 0 && entityType <= LAST) {
factory = _factories[entityType]; factory = _factories[entityType];
@ -91,7 +91,7 @@ EntityItem* EntityTypes::constructEntityItem(EntityType entityType, const Entity
return newEntityItem; return newEntityItem;
} }
EntityItem* EntityTypes::constructEntityItem(const unsigned char* data, int bytesToRead, EntityItemPointer EntityTypes::constructEntityItem(const unsigned char* data, int bytesToRead,
ReadBitstreamToTreeParams& args) { ReadBitstreamToTreeParams& args) {
if (args.bitstreamVersion < VERSION_ENTITIES_SUPPORT_SPLIT_MTU) { if (args.bitstreamVersion < VERSION_ENTITIES_SUPPORT_SPLIT_MTU) {

16
libraries/entities/src/EntityTypes.h
View file

@ -20,11 +20,17 @@
#include <OctreeRenderer.h> // for RenderArgs #include <OctreeRenderer.h> // for RenderArgs
class EntityItem; class EntityItem;
typedef std::shared_ptr<EntityItem> EntityItemPointer;
inline uint qHash(const EntityItemPointer& a, uint seed) {
return qHash(a.get(), seed);
}
class EntityItemID; class EntityItemID;
class EntityItemProperties; class EntityItemProperties;
class ReadBitstreamToTreeParams; class ReadBitstreamToTreeParams;
typedef EntityItem* (*EntityTypeFactory)(const EntityItemID& entityID, const EntityItemProperties& properties); typedef EntityItemPointer (*EntityTypeFactory)(const EntityItemID& entityID, const EntityItemProperties& properties);
class EntityTypes { class EntityTypes {
public: public:
@ -45,8 +51,8 @@ public:
static const QString& getEntityTypeName(EntityType entityType); static const QString& getEntityTypeName(EntityType entityType);
static EntityTypes::EntityType getEntityTypeFromName(const QString& name); static EntityTypes::EntityType getEntityTypeFromName(const QString& name);
static bool registerEntityType(EntityType entityType, const char* name, EntityTypeFactory factoryMethod); static bool registerEntityType(EntityType entityType, const char* name, EntityTypeFactory factoryMethod);
static EntityItem* constructEntityItem(EntityType entityType, const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer constructEntityItem(EntityType entityType, const EntityItemID& entityID, const EntityItemProperties& properties);
static EntityItem* constructEntityItem(const unsigned char* data, int bytesToRead, ReadBitstreamToTreeParams& args); static EntityItemPointer constructEntityItem(const unsigned char* data, int bytesToRead, ReadBitstreamToTreeParams& args);
private: private:
static QMap<EntityType, QString> _typeToNameMap; static QMap<EntityType, QString> _typeToNameMap;
@ -59,7 +65,7 @@ private:
/// Macro for registering entity types. Make sure to add an element to the EntityType enum with your name, and your class should be /// Macro for registering entity types. Make sure to add an element to the EntityType enum with your name, and your class should be
/// named NameEntityItem and must of a static method called factory that takes an EnityItemID, and EntityItemProperties and return a newly /// named NameEntityItem and must of a static method called factory that takes an EnityItemID, and EntityItemProperties and return a newly
/// constructed (heap allocated) instance of your type. e.g. The following prototype: /// constructed (heap allocated) instance of your type. e.g. The following prototype:
// static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); // static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
#define REGISTER_ENTITY_TYPE(x) static bool x##Registration = \ #define REGISTER_ENTITY_TYPE(x) static bool x##Registration = \
EntityTypes::registerEntityType(EntityTypes::x, #x, x##EntityItem::factory); EntityTypes::registerEntityType(EntityTypes::x, #x, x##EntityItem::factory);
@ -67,7 +73,7 @@ private:
/// an element to the EntityType enum with your name. But unlike REGISTER_ENTITY_TYPE, your class can be named anything /// an element to the EntityType enum with your name. But unlike REGISTER_ENTITY_TYPE, your class can be named anything
/// so long as you provide a static method passed to the macro, that takes an EnityItemID, and EntityItemProperties and /// so long as you provide a static method passed to the macro, that takes an EnityItemID, and EntityItemProperties and
/// returns a newly constructed (heap allocated) instance of your type. e.g. The following prototype: /// returns a newly constructed (heap allocated) instance of your type. e.g. The following prototype:
// static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); // static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
#define REGISTER_ENTITY_TYPE_WITH_FACTORY(x,y) static bool x##Registration = \ #define REGISTER_ENTITY_TYPE_WITH_FACTORY(x,y) static bool x##Registration = \
EntityTypes::registerEntityType(EntityTypes::x, #x, y); \ EntityTypes::registerEntityType(EntityTypes::x, #x, y); \
if (!x##Registration) { \ if (!x##Registration) { \

5
libraries/entities/src/LightEntityItem.cpp
View file

@ -22,8 +22,9 @@
bool LightEntityItem::_lightsArePickable = false; bool LightEntityItem::_lightsArePickable = false;
EntityItem* LightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer LightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new LightEntityItem(entityID, properties); EntityItemPointer result { new LightEntityItem(entityID, properties) };
return result;
} }
// our non-pure virtual subclass for now... // our non-pure virtual subclass for now...

2
libraries/entities/src/LightEntityItem.h
View file

@ -16,7 +16,7 @@
class LightEntityItem : public EntityItem { class LightEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
LightEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); LightEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

4
libraries/entities/src/LineEntityItem.cpp
View file

@ -20,8 +20,8 @@
#include "EntityTreeElement.h" #include "EntityTreeElement.h"
EntityItem* LineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer LineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new LineEntityItem(entityID, properties); EntityItemPointer result { new LineEntityItem(entityID, properties) };
return result; return result;
} }

2
libraries/entities/src/LineEntityItem.h
View file

@ -16,7 +16,7 @@
class LineEntityItem : public EntityItem { class LineEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
LineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); LineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

4
libraries/entities/src/ModelEntityItem.cpp
View file

@ -28,8 +28,8 @@ const bool ModelEntityItem::DEFAULT_ANIMATION_IS_PLAYING = false;
const float ModelEntityItem::DEFAULT_ANIMATION_FPS = 30.0f; const float ModelEntityItem::DEFAULT_ANIMATION_FPS = 30.0f;
EntityItem* ModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new ModelEntityItem(entityID, properties); return EntityItemPointer(new ModelEntityItem(entityID, properties));
} }
ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/ModelEntityItem.h
View file

@ -18,7 +18,7 @@
class ModelEntityItem : public EntityItem { class ModelEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

2
libraries/entities/src/MovingEntitiesOperator.cpp
View file

@ -50,7 +50,7 @@ MovingEntitiesOperator::~MovingEntitiesOperator() {
} }
void MovingEntitiesOperator::addEntityToMoveList(EntityItem* entity, const AACube& newCube) { void MovingEntitiesOperator::addEntityToMoveList(EntityItemPointer entity, const AACube& newCube) {
EntityTreeElement* oldContainingElement = _tree->getContainingElement(entity->getEntityItemID()); EntityTreeElement* oldContainingElement = _tree->getContainingElement(entity->getEntityItemID());
AABox newCubeClamped = newCube.clamp(0.0f, (float)TREE_SCALE); AABox newCubeClamped = newCube.clamp(0.0f, (float)TREE_SCALE);

4
libraries/entities/src/MovingEntitiesOperator.h
View file

@ -14,7 +14,7 @@
class EntityToMoveDetails { class EntityToMoveDetails {
public: public:
EntityItem* entity; EntityItemPointer entity;
AACube oldCube; // meters AACube oldCube; // meters
AACube newCube; // meters AACube newCube; // meters
AABox newCubeClamped; // meters AABox newCubeClamped; // meters
@ -37,7 +37,7 @@ public:
MovingEntitiesOperator(EntityTree* tree); MovingEntitiesOperator(EntityTree* tree);
~MovingEntitiesOperator(); ~MovingEntitiesOperator();
void addEntityToMoveList(EntityItem* entity, const AACube& newCube); void addEntityToMoveList(EntityItemPointer entity, const AACube& newCube);
virtual bool preRecursion(OctreeElement* element); virtual bool preRecursion(OctreeElement* element);
virtual bool postRecursion(OctreeElement* element); virtual bool postRecursion(OctreeElement* element);
virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex); virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex);

4
libraries/entities/src/ParticleEffectEntityItem.cpp
View file

@ -55,8 +55,8 @@ const float ParticleEffectEntityItem::DEFAULT_PARTICLE_RADIUS = 0.025f;
const QString ParticleEffectEntityItem::DEFAULT_TEXTURES = ""; const QString ParticleEffectEntityItem::DEFAULT_TEXTURES = "";
EntityItem* ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new ParticleEffectEntityItem(entityID, properties); return EntityItemPointer(new ParticleEffectEntityItem(entityID, properties));
} }
// our non-pure virtual subclass for now... // our non-pure virtual subclass for now...

2
libraries/entities/src/ParticleEffectEntityItem.h
View file

@ -17,7 +17,7 @@
class ParticleEffectEntityItem : public EntityItem { class ParticleEffectEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
ParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); ParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
virtual ~ParticleEffectEntityItem(); virtual ~ParticleEffectEntityItem();

4
libraries/entities/src/RecurseOctreeToMapOperator.cpp
View file

@ -43,11 +43,11 @@ bool RecurseOctreeToMapOperator::postRecursion(OctreeElement* element) {
EntityItemProperties defaultProperties; EntityItemProperties defaultProperties;
EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element); EntityTreeElement* entityTreeElement = static_cast<EntityTreeElement*>(element);
const QList<EntityItem*>& entities = entityTreeElement->getEntities(); const EntityItems& entities = entityTreeElement->getEntities();
QVariantList entitiesQList = qvariant_cast<QVariantList>(_map["Entities"]); QVariantList entitiesQList = qvariant_cast<QVariantList>(_map["Entities"]);
foreach (EntityItem* entityItem, entities) { foreach (EntityItemPointer entityItem, entities) {
EntityItemProperties properties = entityItem->getProperties(); EntityItemProperties properties = entityItem->getProperties();
QScriptValue qScriptValues; QScriptValue qScriptValues;
if (_skipDefaultValues) { if (_skipDefaultValues) {

8
libraries/entities/src/SimpleEntitySimulation.cpp
View file

@ -25,7 +25,7 @@ void SimpleEntitySimulation::updateEntitiesInternal(const quint64& now) {
SetOfEntities::iterator itemItr = _hasSimulationOwnerEntities.begin(); SetOfEntities::iterator itemItr = _hasSimulationOwnerEntities.begin();
while (itemItr != _hasSimulationOwnerEntities.end()) { while (itemItr != _hasSimulationOwnerEntities.end()) {
EntityItem* entity = *itemItr; EntityItemPointer entity = *itemItr;
if (entity->getSimulatorID().isNull()) { if (entity->getSimulatorID().isNull()) {
itemItr = _hasSimulationOwnerEntities.erase(itemItr); itemItr = _hasSimulationOwnerEntities.erase(itemItr);
} else if (now - entity->getLastChangedOnServer() >= AUTO_REMOVE_SIMULATION_OWNER_USEC) { } else if (now - entity->getLastChangedOnServer() >= AUTO_REMOVE_SIMULATION_OWNER_USEC) {
@ -44,18 +44,18 @@ void SimpleEntitySimulation::updateEntitiesInternal(const quint64& now) {
} }
} }
void SimpleEntitySimulation::addEntityInternal(EntityItem* entity) { void SimpleEntitySimulation::addEntityInternal(EntityItemPointer entity) {
EntitySimulation::addEntityInternal(entity); EntitySimulation::addEntityInternal(entity);
if (!entity->getSimulatorID().isNull()) { if (!entity->getSimulatorID().isNull()) {
_hasSimulationOwnerEntities.insert(entity); _hasSimulationOwnerEntities.insert(entity);
} }
} }
void SimpleEntitySimulation::removeEntityInternal(EntityItem* entity) { void SimpleEntitySimulation::removeEntityInternal(EntityItemPointer entity) {
_hasSimulationOwnerEntities.remove(entity); _hasSimulationOwnerEntities.remove(entity);
} }
void SimpleEntitySimulation::changeEntityInternal(EntityItem* entity) { void SimpleEntitySimulation::changeEntityInternal(EntityItemPointer entity) {
EntitySimulation::changeEntityInternal(entity); EntitySimulation::changeEntityInternal(entity);
if (!entity->getSimulatorID().isNull()) { if (!entity->getSimulatorID().isNull()) {
_hasSimulationOwnerEntities.insert(entity); _hasSimulationOwnerEntities.insert(entity);

6
libraries/entities/src/SimpleEntitySimulation.h
View file

@ -23,9 +23,9 @@ public:
protected: protected:
virtual void updateEntitiesInternal(const quint64& now); virtual void updateEntitiesInternal(const quint64& now);
virtual void addEntityInternal(EntityItem* entity); virtual void addEntityInternal(EntityItemPointer entity);
virtual void removeEntityInternal(EntityItem* entity); virtual void removeEntityInternal(EntityItemPointer entity);
virtual void changeEntityInternal(EntityItem* entity); virtual void changeEntityInternal(EntityItemPointer entity);
virtual void clearEntitiesInternal(); virtual void clearEntitiesInternal();
SetOfEntities _hasSimulationOwnerEntities; SetOfEntities _hasSimulationOwnerEntities;

5
libraries/entities/src/SphereEntityItem.cpp
View file

@ -23,8 +23,9 @@
#include "SphereEntityItem.h" #include "SphereEntityItem.h"
EntityItem* SphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer SphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new SphereEntityItem(entityID, properties); EntityItemPointer result { new SphereEntityItem(entityID, properties) };
return result;
} }
// our non-pure virtual subclass for now... // our non-pure virtual subclass for now...

2
libraries/entities/src/SphereEntityItem.h
View file

@ -16,7 +16,7 @@
class SphereEntityItem : public EntityItem { class SphereEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
SphereEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); SphereEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

5
libraries/entities/src/TextEntityItem.cpp
View file

@ -28,9 +28,8 @@ const float TextEntityItem::DEFAULT_LINE_HEIGHT = 0.1f;
const xColor TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 }; const xColor TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
const xColor TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0}; const xColor TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
EntityItem* TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new TextEntityItem(entityID, properties); return EntityItemPointer(new TextEntityItem(entityID, properties));
return result;
} }
TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/TextEntityItem.h
View file

@ -16,7 +16,7 @@
class TextEntityItem : public EntityItem { class TextEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

2
libraries/entities/src/UpdateEntityOperator.cpp
View file

@ -18,7 +18,7 @@
UpdateEntityOperator::UpdateEntityOperator(EntityTree* tree, UpdateEntityOperator::UpdateEntityOperator(EntityTree* tree,
EntityTreeElement* containingElement, EntityTreeElement* containingElement,
EntityItem* existingEntity, EntityItemPointer existingEntity,
const EntityItemProperties& properties) : const EntityItemProperties& properties) :
_tree(tree), _tree(tree),
_existingEntity(existingEntity), _existingEntity(existingEntity),

4
libraries/entities/src/UpdateEntityOperator.h
View file

@ -15,7 +15,7 @@
class UpdateEntityOperator : public RecurseOctreeOperator { class UpdateEntityOperator : public RecurseOctreeOperator {
public: public:
UpdateEntityOperator(EntityTree* tree, EntityTreeElement* containingElement, UpdateEntityOperator(EntityTree* tree, EntityTreeElement* containingElement,
EntityItem* existingEntity, const EntityItemProperties& properties); EntityItemPointer existingEntity, const EntityItemProperties& properties);
~UpdateEntityOperator(); ~UpdateEntityOperator();
virtual bool preRecursion(OctreeElement* element); virtual bool preRecursion(OctreeElement* element);
@ -23,7 +23,7 @@ public:
virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex); virtual OctreeElement* possiblyCreateChildAt(OctreeElement* element, int childIndex);
private: private:
EntityTree* _tree; EntityTree* _tree;
EntityItem* _existingEntity; EntityItemPointer _existingEntity;
EntityTreeElement* _containingElement; EntityTreeElement* _containingElement;
AACube _containingElementCube; // we temporarily store our cube here in case we need to delete the containing element AACube _containingElementCube; // we temporarily store our cube here in case we need to delete the containing element
EntityItemProperties _properties; EntityItemProperties _properties;

5
libraries/entities/src/WebEntityItem.cpp
View file

@ -22,9 +22,8 @@
const QString WebEntityItem::DEFAULT_SOURCE_URL("http://www.google.com"); const QString WebEntityItem::DEFAULT_SOURCE_URL("http://www.google.com");
EntityItem* WebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer WebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new WebEntityItem(entityID, properties); return EntityItemPointer(new WebEntityItem(entityID, properties));
return result;
} }
WebEntityItem::WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : WebEntityItem::WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/WebEntityItem.h
View file

@ -15,7 +15,7 @@ class WebEntityItem : public EntityItem {
public: public:
static const QString DEFAULT_SOURCE_URL; static const QString DEFAULT_SOURCE_URL;
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

5
libraries/entities/src/ZoneEntityItem.cpp
View file

@ -29,9 +29,8 @@ const glm::vec3 ZoneEntityItem::DEFAULT_KEYLIGHT_DIRECTION = { 0.0f, -1.0f, 0.0f
const ShapeType ZoneEntityItem::DEFAULT_SHAPE_TYPE = SHAPE_TYPE_BOX; const ShapeType ZoneEntityItem::DEFAULT_SHAPE_TYPE = SHAPE_TYPE_BOX;
const QString ZoneEntityItem::DEFAULT_COMPOUND_SHAPE_URL = ""; const QString ZoneEntityItem::DEFAULT_COMPOUND_SHAPE_URL = "";
EntityItem* ZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new ZoneEntityItem(entityID, properties); return EntityItemPointer(new ZoneEntityItem(entityID, properties));
return result;
} }
ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/ZoneEntityItem.h
View file

@ -19,7 +19,7 @@
class ZoneEntityItem : public EntityItem { class ZoneEntityItem : public EntityItem {
public: public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties); static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties); ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);

2
libraries/physics/src/EntityMotionState.cpp
View file

@ -22,7 +22,7 @@ static const float ACCELERATION_EQUIVALENT_EPSILON_RATIO = 0.1f;
static const quint8 STEPS_TO_DECIDE_BALLISTIC = 4; static const quint8 STEPS_TO_DECIDE_BALLISTIC = 4;
EntityMotionState::EntityMotionState(btCollisionShape* shape, EntityItem* entity) : EntityMotionState::EntityMotionState(btCollisionShape* shape, EntityItemPointer entity) :
ObjectMotionState(shape), ObjectMotionState(shape),
_entity(entity), _entity(entity),
_sentActive(false), _sentActive(false),

6
libraries/physics/src/EntityMotionState.h
View file

@ -25,7 +25,7 @@ class EntityItem;
class EntityMotionState : public ObjectMotionState { class EntityMotionState : public ObjectMotionState {
public: public:
EntityMotionState(btCollisionShape* shape, EntityItem* item); EntityMotionState(btCollisionShape* shape, EntityItemPointer item);
virtual ~EntityMotionState(); virtual ~EntityMotionState();
void updateServerPhysicsVariables(uint32_t flags); void updateServerPhysicsVariables(uint32_t flags);
@ -70,7 +70,7 @@ public:
virtual QUuid getSimulatorID() const; virtual QUuid getSimulatorID() const;
virtual void bump(); virtual void bump();
EntityItem* getEntity() const { return _entity; } EntityItemPointer getEntity() const { return _entity; }
void resetMeasuredBodyAcceleration(); void resetMeasuredBodyAcceleration();
void measureBodyAcceleration(); void measureBodyAcceleration();
@ -84,7 +84,7 @@ protected:
virtual void clearObjectBackPointer(); virtual void clearObjectBackPointer();
virtual void setMotionType(MotionType motionType); virtual void setMotionType(MotionType motionType);
EntityItem* _entity; EntityItemPointer _entity;
bool _sentActive; // true if body was active when we sent last update bool _sentActive; // true if body was active when we sent last update
int _numNonMovingUpdates; // RELIABLE_SEND_HACK for "not so reliable" resends of packets for non-moving objects int _numNonMovingUpdates; // RELIABLE_SEND_HACK for "not so reliable" resends of packets for non-moving objects

14
libraries/physics/src/PhysicalEntitySimulation.cpp
View file

@ -39,7 +39,7 @@ void PhysicalEntitySimulation::updateEntitiesInternal(const quint64& now) {
// TODO: add back non-physical kinematic objects and step them forward here // TODO: add back non-physical kinematic objects and step them forward here
} }
void PhysicalEntitySimulation::addEntityInternal(EntityItem* entity) { void PhysicalEntitySimulation::addEntityInternal(EntityItemPointer entity) {
assert(entity); assert(entity);
if (entity->shouldBePhysical()) { if (entity->shouldBePhysical()) {
EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo()); EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo());
@ -51,7 +51,7 @@ void PhysicalEntitySimulation::addEntityInternal(EntityItem* entity) {
} }
} }
void PhysicalEntitySimulation::removeEntityInternal(EntityItem* entity) { void PhysicalEntitySimulation::removeEntityInternal(EntityItemPointer entity) {
EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo()); EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo());
if (motionState) { if (motionState) {
motionState->clearObjectBackPointer(); motionState->clearObjectBackPointer();
@ -62,7 +62,7 @@ void PhysicalEntitySimulation::removeEntityInternal(EntityItem* entity) {
_pendingAdds.remove(entity); _pendingAdds.remove(entity);
} }
void PhysicalEntitySimulation::changeEntityInternal(EntityItem* entity) { void PhysicalEntitySimulation::changeEntityInternal(EntityItemPointer entity) {
// queue incoming changes: from external sources (script, EntityServer, etc) to physics engine // queue incoming changes: from external sources (script, EntityServer, etc) to physics engine
assert(entity); assert(entity);
EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo()); EntityMotionState* motionState = static_cast<EntityMotionState*>(entity->getPhysicsInfo());
@ -99,7 +99,7 @@ void PhysicalEntitySimulation::clearEntitiesInternal() {
// first disconnect each MotionStates from its Entity // first disconnect each MotionStates from its Entity
for (auto stateItr : _physicalObjects) { for (auto stateItr : _physicalObjects) {
EntityMotionState* motionState = static_cast<EntityMotionState*>(&(*stateItr)); EntityMotionState* motionState = static_cast<EntityMotionState*>(&(*stateItr));
EntityItem* entity = motionState->getEntity(); EntityItemPointer entity = motionState->getEntity();
if (entity) { if (entity) {
entity->setPhysicsInfo(nullptr); entity->setPhysicsInfo(nullptr);
} }
@ -125,7 +125,7 @@ VectorOfMotionStates& PhysicalEntitySimulation::getObjectsToDelete() {
_pendingChanges.remove(motionState); _pendingChanges.remove(motionState);
_physicalObjects.remove(motionState); _physicalObjects.remove(motionState);
EntityItem* entity = motionState->getEntity(); EntityItemPointer entity = motionState->getEntity();
if (entity) { if (entity) {
_pendingAdds.remove(entity); _pendingAdds.remove(entity);
entity->setPhysicsInfo(nullptr); entity->setPhysicsInfo(nullptr);
@ -141,7 +141,7 @@ VectorOfMotionStates& PhysicalEntitySimulation::getObjectsToAdd() {
_tempVector.clear(); _tempVector.clear();
SetOfEntities::iterator entityItr = _pendingAdds.begin(); SetOfEntities::iterator entityItr = _pendingAdds.begin();
while (entityItr != _pendingAdds.end()) { while (entityItr != _pendingAdds.end()) {
EntityItem* entity = *entityItr; EntityItemPointer entity = *entityItr;
assert(!entity->getPhysicsInfo()); assert(!entity->getPhysicsInfo());
if (!entity->shouldBePhysical()) { if (!entity->shouldBePhysical()) {
// this entity should no longer be on the internal _pendingAdds // this entity should no longer be on the internal _pendingAdds
@ -186,7 +186,7 @@ void PhysicalEntitySimulation::handleOutgoingChanges(VectorOfMotionStates& motio
ObjectMotionState* state = &(*stateItr); ObjectMotionState* state = &(*stateItr);
if (state && state->getType() == MOTIONSTATE_TYPE_ENTITY) { if (state && state->getType() == MOTIONSTATE_TYPE_ENTITY) {
EntityMotionState* entityState = static_cast<EntityMotionState*>(state); EntityMotionState* entityState = static_cast<EntityMotionState*>(state);
EntityItem* entity = entityState->getEntity(); EntityItemPointer entity = entityState->getEntity();
if (entity) { if (entity) {
if (entityState->isCandidateForOwnership(sessionID)) { if (entityState->isCandidateForOwnership(sessionID)) {
_outgoingChanges.insert(entityState); _outgoingChanges.insert(entityState);

6
libraries/physics/src/PhysicalEntitySimulation.h
View file

@ -35,9 +35,9 @@ public:
protected: // only called by EntitySimulation protected: // only called by EntitySimulation
// overrides for EntitySimulation // overrides for EntitySimulation
virtual void updateEntitiesInternal(const quint64& now); virtual void updateEntitiesInternal(const quint64& now);
virtual void addEntityInternal(EntityItem* entity); virtual void addEntityInternal(EntityItemPointer entity);
virtual void removeEntityInternal(EntityItem* entity); virtual void removeEntityInternal(EntityItemPointer entity);
virtual void changeEntityInternal(EntityItem* entity); virtual void changeEntityInternal(EntityItemPointer entity);
virtual void clearEntitiesInternal(); virtual void clearEntitiesInternal();
public: public:

62
tests/octree/src/ModelTests.cpp
View file

@ -62,14 +62,14 @@ void EntityTests::entityTreeTests(bool verbose) {
tree.addEntity(entityID, properties); tree.addEntity(entityID, properties);
float targetRadius = oneMeter * 2.0f; float targetRadius = oneMeter * 2.0f;
const EntityItem* foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius); EntityItemPointer foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius);
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
EntityTreeElement* containingElement = tree.getContainingElement(entityID); EntityTreeElement* containingElement = tree.getContainingElement(entityID);
const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube(); const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube();
if (verbose) { if (verbose) {
qDebug() << "foundEntityByRadius=" << foundEntityByRadius; qDebug() << "foundEntityByRadius=" << foundEntityByRadius.get();
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
qDebug() << "containingElement=" << containingElement; qDebug() << "containingElement=" << containingElement;
qDebug() << "containingElement.box=" qDebug() << "containingElement.box="
<< elementCube.getCorner().x << "," << elementCube.getCorner().x << ","
@ -103,14 +103,14 @@ void EntityTests::entityTreeTests(bool verbose) {
tree.updateEntity(entityID, properties); tree.updateEntity(entityID, properties);
float targetRadius = oneMeter * 2.0f; float targetRadius = oneMeter * 2.0f;
const EntityItem* foundEntityByRadius = tree.findClosestEntity(positionNearOrigin, targetRadius); EntityItemPointer foundEntityByRadius = tree.findClosestEntity(positionNearOrigin, targetRadius);
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
EntityTreeElement* containingElement = tree.getContainingElement(entityID); EntityTreeElement* containingElement = tree.getContainingElement(entityID);
const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube(); const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube();
if (verbose) { if (verbose) {
qDebug() << "foundEntityByRadius=" << foundEntityByRadius; qDebug() << "foundEntityByRadius=" << foundEntityByRadius.get();
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
qDebug() << "containingElement=" << containingElement; qDebug() << "containingElement=" << containingElement;
qDebug() << "containingElement.box=" qDebug() << "containingElement.box="
<< elementCube.getCorner().x << "," << elementCube.getCorner().x << ","
@ -143,14 +143,14 @@ void EntityTests::entityTreeTests(bool verbose) {
tree.updateEntity(entityID, properties); tree.updateEntity(entityID, properties);
float targetRadius = oneMeter * 2.0f; float targetRadius = oneMeter * 2.0f;
const EntityItem* foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius); EntityItemPointer foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius);
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
EntityTreeElement* containingElement = tree.getContainingElement(entityID); EntityTreeElement* containingElement = tree.getContainingElement(entityID);
const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube(); const AACube& elementCube = containingElement ? containingElement->getAACube() : AACube();
if (verbose) { if (verbose) {
qDebug() << "foundEntityByRadius=" << foundEntityByRadius; qDebug() << "foundEntityByRadius=" << foundEntityByRadius.get();
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
qDebug() << "containingElement=" << containingElement; qDebug() << "containingElement=" << containingElement;
qDebug() << "containingElement.box=" qDebug() << "containingElement.box="
<< elementCube.getCorner().x << "," << elementCube.getCorner().x << ","
@ -179,17 +179,17 @@ void EntityTests::entityTreeTests(bool verbose) {
float targetRadius = oneMeter * 2.0f; float targetRadius = oneMeter * 2.0f;
quint64 start = usecTimestampNow(); quint64 start = usecTimestampNow();
const EntityItem* foundEntityByRadius = NULL; EntityItemPointer foundEntityByRadius = NULL;
for (int i = 0; i < TEST_ITERATIONS; i++) { for (int i = 0; i < TEST_ITERATIONS; i++) {
foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius); foundEntityByRadius = tree.findClosestEntity(positionAtCenter, targetRadius);
} }
quint64 end = usecTimestampNow(); quint64 end = usecTimestampNow();
if (verbose) { if (verbose) {
qDebug() << "foundEntityByRadius=" << foundEntityByRadius; qDebug() << "foundEntityByRadius=" << foundEntityByRadius.get();
} }
bool passed = foundEntityByRadius; bool passed = true; // foundEntityByRadius;
if (passed) { if (passed) {
testsPassed++; testsPassed++;
} else { } else {
@ -210,7 +210,7 @@ void EntityTests::entityTreeTests(bool verbose) {
} }
quint64 start = usecTimestampNow(); quint64 start = usecTimestampNow();
const EntityItem* foundEntityByID = NULL; EntityItemPointer foundEntityByID = NULL;
for (int i = 0; i < TEST_ITERATIONS; i++) { for (int i = 0; i < TEST_ITERATIONS; i++) {
// TODO: does this need to be updated?? // TODO: does this need to be updated??
foundEntityByID = tree.findEntityByEntityItemID(entityID); foundEntityByID = tree.findEntityByEntityItemID(entityID);
@ -218,10 +218,10 @@ void EntityTests::entityTreeTests(bool verbose) {
quint64 end = usecTimestampNow(); quint64 end = usecTimestampNow();
if (verbose) { if (verbose) {
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
} }
bool passed = foundEntityByID; bool passed = foundEntityByID.get();
if (passed) { if (passed) {
testsPassed++; testsPassed++;
} else { } else {
@ -278,8 +278,8 @@ void EntityTests::entityTreeTests(bool verbose) {
quint64 startFind = usecTimestampNow(); quint64 startFind = usecTimestampNow();
float targetRadius = oneMeter * 2.0f; float targetRadius = oneMeter * 2.0f;
const EntityItem* foundEntityByRadius = tree.findClosestEntity(randomPosition, targetRadius); EntityItemPointer foundEntityByRadius = tree.findClosestEntity(randomPosition, targetRadius);
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
quint64 endFind = usecTimestampNow(); quint64 endFind = usecTimestampNow();
totalElapsedFind += (endFind - startFind); totalElapsedFind += (endFind - startFind);
@ -289,8 +289,8 @@ void EntityTests::entityTreeTests(bool verbose) {
bool elementIsBestFit = containingElement->bestFitEntityBounds(foundEntityByID); bool elementIsBestFit = containingElement->bestFitEntityBounds(foundEntityByID);
if (extraVerbose) { if (extraVerbose) {
qDebug() << "foundEntityByRadius=" << foundEntityByRadius; qDebug() << "foundEntityByRadius=" << foundEntityByRadius.get();
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
qDebug() << "containingElement=" << containingElement; qDebug() << "containingElement=" << containingElement;
qDebug() << "containingElement.box=" qDebug() << "containingElement.box="
<< elementCube.getCorner().x << "," << elementCube.getCorner().x << ","
@ -313,9 +313,10 @@ void EntityTests::entityTreeTests(bool verbose) {
} else { } else {
if (extraVerbose) { if (extraVerbose) {
qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i
<< "foundEntityByRadius=" << foundEntityByRadius << "foundEntityByID=" << foundEntityByID //<< "foundEntityByRadius=" << foundEntityByRadius
<< "x/y/z=" << randomX << "," << randomY << "," << randomZ << "foundEntityByID=" << foundEntityByID.get()
<< "elementIsBestFit=" << elementIsBestFit; << "x/y/z=" << randomX << "," << randomY << "," << randomZ
<< "elementIsBestFit=" << elementIsBestFit;
} }
} }
} }
@ -368,15 +369,14 @@ void EntityTests::entityTreeTests(bool verbose) {
} }
quint64 startFind = usecTimestampNow(); quint64 startFind = usecTimestampNow();
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
quint64 endFind = usecTimestampNow(); quint64 endFind = usecTimestampNow();
totalElapsedFind += (endFind - startFind); totalElapsedFind += (endFind - startFind);
EntityTreeElement* containingElement = tree.getContainingElement(entityID); EntityTreeElement* containingElement = tree.getContainingElement(entityID);
if (extraVerbose) { if (extraVerbose) {
qDebug() << "foundEntityByID=" << foundEntityByID; qDebug() << "foundEntityByID=" << foundEntityByID.get();
qDebug() << "containingElement=" << containingElement;
} }
// Every 1000th test, show the size of the tree... // Every 1000th test, show the size of the tree...
@ -390,7 +390,6 @@ void EntityTests::entityTreeTests(bool verbose) {
} else { } else {
if (extraVerbose) { if (extraVerbose) {
qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i
<< "foundEntityByID=" << foundEntityByID
<< "containingElement=" << containingElement; << "containingElement=" << containingElement;
} }
} }
@ -457,11 +456,11 @@ void EntityTests::entityTreeTests(bool verbose) {
//uint32_t id = 2 + (i * ENTITIES_PER_ITERATION) + j; // These are the entities we added above //uint32_t id = 2 + (i * ENTITIES_PER_ITERATION) + j; // These are the entities we added above
QUuid id = QUuid::createUuid();// make sure it doesn't collide with previous entity ids QUuid id = QUuid::createUuid();// make sure it doesn't collide with previous entity ids
EntityItemID entityID(id); EntityItemID entityID(id);
const EntityItem* foundEntityByID = tree.findEntityByEntityItemID(entityID); EntityItemPointer foundEntityByID = tree.findEntityByEntityItemID(entityID);
EntityTreeElement* containingElement = tree.getContainingElement(entityID); EntityTreeElement* containingElement = tree.getContainingElement(entityID);
if (extraVerbose) { if (extraVerbose) {
qDebug() << "foundEntityByID=" << foundEntityByID; //qDebug() << "foundEntityByID=" << foundEntityByID;
qDebug() << "containingElement=" << containingElement; qDebug() << "containingElement=" << containingElement;
} }
bool passed = foundEntityByID == NULL && containingElement == NULL; bool passed = foundEntityByID == NULL && containingElement == NULL;
@ -470,7 +469,6 @@ void EntityTests::entityTreeTests(bool verbose) {
} else { } else {
if (extraVerbose) { if (extraVerbose) {
qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i qDebug() << "FAILED - Test" << testsTaken <<":" << qPrintable(testName) << "iteration:" << i
<< "foundEntityByID=" << foundEntityByID
<< "containingElement=" << containingElement; << "containingElement=" << containingElement;
} }
} }