merge from upstream

Seth Alves committed 9 years ago

Commit e8a9ff82 parents 9881dd2 546f324463 files · +21986 −6894Browse files

Showing the changes to libraries/entities/src/EntityScriptingInterface.cpp (1 of 463 files). Show all

Unified · Split

libraries/entities/src/EntityScriptingInterface.cpp+121−59

 #include "ZoneEntityItem.h"
 #include "WebEntityItem.h"
 #include <EntityScriptClient.h>
+#include <Profile.h>
 EntityScriptingInterface::EntityScriptingInterface(bool bidOnSimulationOwnership) :
 QUuid EntityScriptingInterface::addEntity(const EntityItemProperties& properties, bool clientOnly) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     _activityTracking.addedEntityCount++;
     EntityItemProperties propertiesWithSimID = convertLocationFromScriptSemantics(properties);
 }
 EntityItemProperties EntityScriptingInterface::getEntityProperties(QUuid identity, EntityPropertyFlags desiredProperties) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemProperties results;
     if (_entityTree) {
         _entityTree->withReadLock([&] {
                     desiredProperties = entity->getEntityProperties(params);
                     desiredProperties.setHasProperty(PROP_LOCAL_POSITION);
                     desiredProperties.setHasProperty(PROP_LOCAL_ROTATION);
-                 }
+                }
                 results = entity->getProperties(desiredProperties);
 }
 QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties& scriptSideProperties) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     _activityTracking.editedEntityCount++;
     EntityItemProperties properties = scriptSideProperties;
 }
 void EntityScriptingInterface::deleteEntity(QUuid id) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     _activityTracking.deletedEntityCount++;
     EntityItemID entityID(id);
 }
 void EntityScriptingInterface::callEntityMethod(QUuid id, const QString& method, const QStringList& params) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     std::lock_guard<std::recursive_mutex> lock(_entitiesScriptEngineLock);
     if (_entitiesScriptEngine) {
         EntityItemID entityID{ id };
 }
 QUuid EntityScriptingInterface::findClosestEntity(const glm::vec3& center, float radius) const {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemID result;
     if (_entityTree) {
         EntityItemPointer closestEntity;
 }
 QVector<QUuid> EntityScriptingInterface::findEntities(const glm::vec3& center, float radius) const {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVector<QUuid> result;
     if (_entityTree) {
         QVector<EntityItemPointer> entities;
 }
 QVector<QUuid> EntityScriptingInterface::findEntitiesInBox(const glm::vec3& corner, const glm::vec3& dimensions) const {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVector<QUuid> result;
     if (_entityTree) {
         QVector<EntityItemPointer> entities;
 }
 QVector<QUuid> EntityScriptingInterface::findEntitiesInFrustum(QVariantMap frustum) const {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVector<QUuid> result;
     const QString POSITION_PROPERTY = "position";
 RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, bool precisionPicking,
                 const QScriptValue& entityIdsToInclude, const QScriptValue& entityIdsToDiscard, bool visibleOnly, bool collidableOnly) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVector<EntityItemID> entitiesToInclude = qVectorEntityItemIDFromScriptValue(entityIdsToInclude);
     QVector<EntityItemID> entitiesToDiscard = qVectorEntityItemIDFromScriptValue(entityIdsToDiscard);
     auto client = DependencyManager::get<EntityScriptClient>();
     auto request = client->createScriptStatusRequest(entityID);
     connect(request, &GetScriptStatusRequest::finished, callback.engine(), [callback](GetScriptStatusRequest* request) mutable {
-        QString statusString;
+        QString statusString = EntityScriptStatus_::valueToKey(request->getStatus());;
-        switch (request->getStatus()) {
+        QScriptValueList args { request->getResponseReceived(), request->getIsRunning(), statusString.toLower(), request->getErrorInfo() };
-            case RUNNING:
-                statusString = "running";
-                break;
-            case ERROR_LOADING_SCRIPT:
-                statusString = "error_loading_script";
-                break;
-            case ERROR_RUNNING_SCRIPT:
-                statusString = "error_running_script";
-                break;
-            default:
-                statusString = "";
-                break;
-        }
-        QScriptValueList args { request->getResponseReceived(), request->getIsRunning(), statusString, request->getErrorInfo() };
         callback.call(QScriptValue(), args);
         request->deleteLater();
     });
 }
 QScriptValue RayToEntityIntersectionResultToScriptValue(QScriptEngine* engine, const RayToEntityIntersectionResult& value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QScriptValue obj = engine->newObject();
     obj.setProperty("intersects", value.intersects);
     obj.setProperty("accurate", value.accurate);
 }
 void RayToEntityIntersectionResultFromScriptValue(const QScriptValue& object, RayToEntityIntersectionResult& value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     value.intersects = object.property("intersects").toVariant().toBool();
     value.accurate = object.property("accurate").toVariant().toBool();
     QScriptValue entityIDValue = object.property("entityID");
 }
 bool EntityScriptingInterface::polyVoxWorker(QUuid entityID, std::function<bool(PolyVoxEntityItem&)> actor) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     if (!_entityTree) {
         return false;
     }
     EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
     if (!entity) {
-        qCDebug(entities) << "EntityScriptingInterface::setVoxelSphere no entity with ID" << entityID;
+        qCDebug(entities) << "EntityScriptingInterface::setVoxels no entity with ID" << entityID;
         return false;
     }
 }
 bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     if (!_entityTree) {
         return false;
     }
 bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [center, radius, value](PolyVoxEntityItem& polyVoxEntity) {
         return polyVoxEntity.setSphere(center, radius, value);
     });
 }
 bool EntityScriptingInterface::setVoxel(QUuid entityID, const glm::vec3& position, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [position, value](PolyVoxEntityItem& polyVoxEntity) {
+        return polyVoxEntity.setSphere(center, radius, value);
+    });
+}
+bool EntityScriptingInterface::setVoxelCapsule(QUuid entityID,
+                                               const glm::vec3& start, const glm::vec3& end,
+                                               float radius, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
+    return setVoxels(entityID, [start, end, radius, value](PolyVoxEntityItem& polyVoxEntity) {
+        return polyVoxEntity.setCapsule(start, end, radius, value);
+    });
+}
+bool EntityScriptingInterface::setVoxel(QUuid entityID, const glm::vec3& position, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
+    return setVoxels(entityID, [position, value](PolyVoxEntityItem& polyVoxEntity) {
         return polyVoxEntity.setVoxelInVolume(position, value);
     });
 }
 bool EntityScriptingInterface::setAllVoxels(QUuid entityID, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [value](PolyVoxEntityItem& polyVoxEntity) {
         return polyVoxEntity.setAll(value);
     });
 bool EntityScriptingInterface::setVoxelsInCuboid(QUuid entityID, const glm::vec3& lowPosition,
                                                  const glm::vec3& cuboidSize, int value) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [lowPosition, cuboidSize, value](PolyVoxEntityItem& polyVoxEntity) {
         return polyVoxEntity.setCuboid(lowPosition, cuboidSize, value);
     });
 }
 void EntityScriptingInterface::voxelsToMesh(QUuid entityID, QScriptValue callback) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     polyVoxWorker(entityID, [callback](PolyVoxEntityItem& polyVoxEntity) mutable {
         QScriptValue mesh;
         polyVoxEntity.getMeshAsScriptValue(callback.engine(), mesh);
 }
 bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<glm::vec3>& points) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
     if (!entity) {
         qCDebug(entities) << "EntityScriptingInterface::setPoints no entity with ID" << entityID;
 }
 bool EntityScriptingInterface::appendPoint(QUuid entityID, const glm::vec3& point) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
     if (!entity) {
         qCDebug(entities) << "EntityScriptingInterface::setPoints no entity with ID" << entityID;
 QUuid EntityScriptingInterface::addAction(const QString& actionTypeString,
                                           const QUuid& entityID,
                                           const QVariantMap& arguments) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QUuid actionID = QUuid::createUuid();
     auto actionFactory = DependencyManager::get<EntityActionFactoryInterface>();
     bool success = false;
     actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
-            // create this action even if the entity doesn't have physics info.  it will often be the
+        // create this action even if the entity doesn't have physics info.  it will often be the
-            // case that a script adds an action immediately after an object is created, and the physicsInfo
+        // case that a script adds an action immediately after an object is created, and the physicsInfo
-            // is computed asynchronously.
+        // is computed asynchronously.
-            // if (!entity->getPhysicsInfo()) {
+        // if (!entity->getPhysicsInfo()) {
-            //     return false;
+        //     return false;
-            // }
+        // }
-            EntityActionType actionType = EntityActionInterface::actionTypeFromString(actionTypeString);
+        EntityActionType actionType = EntityActionInterface::actionTypeFromString(actionTypeString);
-            if (actionType == ACTION_TYPE_NONE) {
+        if (actionType == ACTION_TYPE_NONE) {
-                return false;
+            return false;
-            }
+        }
-            EntityActionPointer action = actionFactory->factory(actionType, actionID, entity, arguments);
+        EntityActionPointer action = actionFactory->factory(actionType, actionID, entity, arguments);
-            if (!action) {
+        if (!action) {
-                return false;
+            return false;
-            }
+        }
-            action->setIsMine(true);
+        action->setIsMine(true);
-            success = entity->addAction(simulation, action);
+        success = entity->addAction(simulation, action);
-            entity->grabSimulationOwnership();
+        entity->grabSimulationOwnership();
-            return false; // Physics will cause a packet to be sent, so don't send from here.
+        return false; // Physics will cause a packet to be sent, so don't send from here.
-        });
+    });
     if (success) {
         return actionID;
     }
 bool EntityScriptingInterface::updateAction(const QUuid& entityID, const QUuid& actionID, const QVariantMap& arguments) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     return actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
-            bool success = entity->updateAction(simulation, actionID, arguments);
+        bool success = entity->updateAction(simulation, actionID, arguments);
-            if (success) {
+        if (success) {
-                entity->grabSimulationOwnership();
+            entity->grabSimulationOwnership();
-            }
+        }
-            return success;
+        return success;
-        });
+    });
 }
 bool EntityScriptingInterface::deleteAction(const QUuid& entityID, const QUuid& actionID) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     bool success = false;
     actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
-            success = entity->removeAction(simulation, actionID);
+        success = entity->removeAction(simulation, actionID);
-            if (success) {
+        if (success) {
-                // reduce from grab to poke
+            // reduce from grab to poke
-                entity->pokeSimulationOwnership();
+            entity->pokeSimulationOwnership();
-            }
+        }
-            return false; // Physics will cause a packet to be sent, so don't send from here.
+        return false; // Physics will cause a packet to be sent, so don't send from here.
-        });
+    });
     return success;
 }
 QVector<QUuid> EntityScriptingInterface::getActionIDs(const QUuid& entityID) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVector<QUuid> result;
     actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
-            QList<QUuid> actionIDs = entity->getActionIDs();
+        QList<QUuid> actionIDs = entity->getActionIDs();
-            result = QVector<QUuid>::fromList(actionIDs);
+        result = QVector<QUuid>::fromList(actionIDs);
-            return false; // don't send an edit packet
+        return false; // don't send an edit packet
-        });
+    });
     return result;
 }
 QVariantMap EntityScriptingInterface::getActionArguments(const QUuid& entityID, const QUuid& actionID) {
+    PROFILE_RANGE(script_entities, __FUNCTION__);
     QVariantMap result;
     actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
-            result = entity->getActionArguments(actionID);
+        result = entity->getActionArguments(actionID);
-            return false; // don't send an edit packet
+        return false; // don't send an edit packet
-        });
+    });
     return result;
 }
             return;
         }
         parent->forEachChild([&](SpatiallyNestablePointer child) {
-            if (child->getParentJointIndex() == jointIndex &&
+            if (child->getParentJointIndex() == jointIndex) {
-                child->getNestableType() != NestableType::Overlay) {
                 result.push_back(child->getID());
             }
         });
         return nullptr;
     }
 }
+// TODO move this someplace that makes more sense...
+bool EntityScriptingInterface::AABoxIntersectsCapsule(const glm::vec3& low, const glm::vec3& dimensions,
+                                                      const glm::vec3& start, const glm::vec3& end, float radius) {
+    glm::vec3 penetration;
+    AABox aaBox(low, dimensions);
+    return aaBox.findCapsulePenetration(start, end, radius, penetration);
+}

merge from upstream

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code