remove overlays from application.cpp

SamGondelman committed 7 years ago

Commit 0bfcde61 parent a75fe4b13 files · +585 −544Browse files

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

Unified · Split

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

     return addEntity(properties);
 }
-QUuid EntityScriptingInterface::cloneEntity(QUuid entityIDToClone) {
+QUuid EntityScriptingInterface::cloneEntity(const QUuid& entityIDToClone) {
     EntityItemID newEntityID;
     EntityItemProperties properties = getEntityProperties(entityIDToClone);
     bool cloneAvatarEntity = properties.getCloneAvatarEntity();
     }
 }
-EntityItemProperties EntityScriptingInterface::getEntityProperties(QUuid entityID) {
+EntityItemProperties EntityScriptingInterface::getEntityProperties(const QUuid& entityID) {
     const EntityPropertyFlags noSpecificProperties;
     return getEntityProperties(entityID, noSpecificProperties);
 }
-EntityItemProperties EntityScriptingInterface::getEntityProperties(QUuid entityID, EntityPropertyFlags desiredProperties) {
+EntityItemProperties EntityScriptingInterface::getEntityProperties(const QUuid& entityID, EntityPropertyFlags desiredProperties) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     bool scalesWithParent { false };
     return finalResult;
 }
-QUuid EntityScriptingInterface::editEntity(QUuid id, const EntityItemProperties& scriptSideProperties) {
+QUuid EntityScriptingInterface::editEntity(const QUuid& id, const EntityItemProperties& scriptSideProperties) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     _activityTracking.editedEntityCount++;
     return id;
 }
-void EntityScriptingInterface::deleteEntity(QUuid id) {
+void EntityScriptingInterface::deleteEntity(const QUuid& id) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     _activityTracking.deletedEntityCount++;
     }
 }
+QString EntityScriptingInterface::getEntityType(const QUuid& entityID) {
+    QString toReturn;
+    _entityTree->withReadLock([&] {
+        EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
+        if (entity) {
+            toReturn = EntityTypes::getEntityTypeName(entity->getType());
+        }
+    });
+    return toReturn;
+}
+QObject* EntityScriptingInterface::getEntityObject(const QUuid& id) {
+    QObject* toReturn { nullptr };
+    _entityTree->withReadLock([&] {
+        EntityItemPointer entity = _entityTree->findEntityByEntityItemID(id);
+        if (entity) {
+            toReturn = qobject_cast<QObject*>(&(*entity));
+        }
+    });
+    return toReturn;
+}
+bool EntityScriptingInterface::isLoaded(const QUuid& id) {
+    bool toReturn = false;
+    _entityTree->withReadLock([&] {
+        EntityItemPointer entity = _entityTree->findEntityByEntityItemID(id);
+        if (entity) {
+            toReturn = entity->isVisuallyReady();
+        }
+    });
+    return toReturn;
+}
+QSizeF EntityScriptingInterface::textSize(const QUuid& id, const QString& text) {
+    return EntityTree::textSize(id, text);
+}
 void EntityScriptingInterface::setEntitiesScriptEngine(QSharedPointer<EntitiesScriptEngineProvider> engine) {
     std::lock_guard<std::recursive_mutex> lock(_entitiesScriptEngineLock);
     _entitiesScriptEngine = engine;
 }
-void EntityScriptingInterface::callEntityMethod(QUuid id, const QString& method, const QStringList& params) {
+void EntityScriptingInterface::callEntityMethod(const QUuid& id, const QString& method, const QStringList& params) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     std::lock_guard<std::recursive_mutex> lock(_entitiesScriptEngineLock);
     }
 }
-void EntityScriptingInterface::callEntityServerMethod(QUuid id, const QString& method, const QStringList& params) {
+void EntityScriptingInterface::callEntityServerMethod(const QUuid& id, const QString& method, const QStringList& params) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     DependencyManager::get<EntityScriptClient>()->callEntityServerMethod(id, method, params);
 }
-void EntityScriptingInterface::callEntityClientMethod(QUuid clientSessionID, QUuid entityID, const QString& method, const QStringList& params) {
+void EntityScriptingInterface::callEntityClientMethod(const QUuid& clientSessionID, const QUuid& entityID, const QString& method, const QStringList& params) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     auto scriptServerServices = DependencyManager::get<EntityScriptServerServices>();
     return result;
 }
-bool EntityScriptingInterface::reloadServerScripts(QUuid entityID) {
+bool EntityScriptingInterface::reloadServerScripts(const QUuid& entityID) {
     auto client = DependencyManager::get<EntityScriptClient>();
     return client->reloadServerScript(entityID);
 }
     return true;
 }
-bool EntityScriptingInterface::queryPropertyMetadata(QUuid entityID, QScriptValue property, QScriptValue scopeOrCallback, QScriptValue methodOrName) {
+bool EntityScriptingInterface::queryPropertyMetadata(const QUuid& entityID, QScriptValue property, QScriptValue scopeOrCallback, QScriptValue methodOrName) {
     auto name = property.toString();
     auto handler = makeScopedHandlerObject(scopeOrCallback, methodOrName);
     QPointer<BaseScriptEngine> engine = dynamic_cast<BaseScriptEngine*>(handler.engine());
     }
 }
-bool EntityScriptingInterface::getServerScriptStatus(QUuid entityID, QScriptValue callback) {
+bool EntityScriptingInterface::getServerScriptStatus(const QUuid& entityID, QScriptValue callback) {
     auto client = DependencyManager::get<EntityScriptClient>();
     auto request = client->createScriptStatusRequest(entityID);
     connect(request, &GetScriptStatusRequest::finished, callback.engine(), [callback](GetScriptStatusRequest* request) mutable {
     return success;
 }
-bool EntityScriptingInterface::setVoxelSphere(QUuid entityID, const glm::vec3& center, float radius, int value) {
+bool EntityScriptingInterface::setVoxelSphere(const 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::setVoxelCapsule(QUuid entityID,
+bool EntityScriptingInterface::setVoxelCapsule(const QUuid& entityID,
                                                const glm::vec3& start, const glm::vec3& end,
                                                float radius, int value) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     });
 }
-bool EntityScriptingInterface::setVoxel(QUuid entityID, const glm::vec3& position, int value) {
+bool EntityScriptingInterface::setVoxel(const QUuid& entityID, const glm::vec3& position, int value) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [position, value](PolyVoxEntityItem& polyVoxEntity) {
     });
 }
-bool EntityScriptingInterface::setAllVoxels(QUuid entityID, int value) {
+bool EntityScriptingInterface::setAllVoxels(const QUuid& entityID, int value) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     return polyVoxWorker(entityID, [value](PolyVoxEntityItem& polyVoxEntity) {
     });
 }
-bool EntityScriptingInterface::setVoxelsInCuboid(QUuid entityID, const glm::vec3& lowPosition,
+bool EntityScriptingInterface::setVoxelsInCuboid(const QUuid& entityID, const glm::vec3& lowPosition,
                                                  const glm::vec3& cuboidSize, int value) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     });
 }
-bool EntityScriptingInterface::setAllPoints(QUuid entityID, const QVector<glm::vec3>& points) {
+bool EntityScriptingInterface::setAllPoints(const QUuid& entityID, const QVector<glm::vec3>& points) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
     return false;
 }
-bool EntityScriptingInterface::appendPoint(QUuid entityID, const glm::vec3& point) {
+bool EntityScriptingInterface::appendPoint(const QUuid& entityID, const glm::vec3& point) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));
     return result;
 }
-bool EntityScriptingInterface::isChildOfParent(QUuid childID, QUuid parentID) {
+bool EntityScriptingInterface::isChildOfParent(const QUuid& childID, const QUuid& parentID) {
     bool isChild = false;
     if (!_entityTree) {
     return isChild;
 }
-QString EntityScriptingInterface::getNestableType(QUuid id) {
+QString EntityScriptingInterface::getNestableType(const QUuid& id) {
     QSharedPointer<SpatialParentFinder> parentFinder = DependencyManager::get<SpatialParentFinder>();
     if (!parentFinder) {
         return "unknown";
     emit hoverLeaveEntity(id, event);
 }
-bool EntityScriptingInterface::wantsHandControllerPointerEvents(QUuid id) {
+bool EntityScriptingInterface::wantsHandControllerPointerEvents(const QUuid& id) {
     bool result = false;
     if (_entityTree) {
         _entityTree->withReadLock([&] {
     return aaBox.findCapsulePenetration(start, end, radius, penetration);
 }
-void EntityScriptingInterface::getMeshes(QUuid entityID, QScriptValue callback) {
+void EntityScriptingInterface::getMeshes(const QUuid& entityID, QScriptValue callback) {
     PROFILE_RANGE(script_entities, __FUNCTION__);
     EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID));