qCWarning(scriptengine) << "NOTE: ScriptEngine for " << QUrl(url).fileName() << " will be launched in debug mode";                _debuggable = true;            }        }        emit scriptLoaded(url);    }, reload, maxRetries);} void ScriptEngine::scriptErrorMessage(const QString& message) {    qCCritical(scriptengine, "[%s] %s", qUtf8Printable(getFilename()), qUtf8Printable(message));    emit errorMessage(message, getFilename());} void ScriptEngine::scriptWarningMessage(const QString& message) {    qCWarning(scriptengine, "[%s] %s", qUtf8Printable(getFilename()), qUtf8Printable(message));    emit warningMessage(message, getFilename());} void ScriptEngine::scriptInfoMessage(const QString& message) {    qCInfo(scriptengine, "[%s] %s", qUtf8Printable(getFilename()), qUtf8Printable(message));    emit infoMessage(message, getFilename());} void ScriptEngine::scriptPrintedMessage(const QString& message) {    qCDebug(scriptengine, "[%s] %s", qUtf8Printable(getFilename()), qUtf8Printable(message));    emit printedMessage(message, getFilename());} void ScriptEngine::clearDebugLogWindow() {    emit clearDebugWindow();} // Even though we never pass AnimVariantMap directly to and from javascript, the queued invokeMethod of// callAnimationStateHandler requires that the type be registered.// These two are meaningful, if we ever do want to use them...static QScriptValue animVarMapToScriptValue(QScriptEngine* engine, const AnimVariantMap& parameters) {    QStringList unused;    return parameters.animVariantMapToScriptValue(engine, unused, false);}static void animVarMapFromScriptValue(const QScriptValue& value, AnimVariantMap& parameters) {    parameters.animVariantMapFromScriptValue(value);}// ... while these two are not. But none of the four are ever used.static QScriptValue resultHandlerToScriptValue(QScriptEngine* engine,                                               const AnimVariantResultHandler& resultHandler) {    qCCritical(scriptengine) << "Attempt to marshall result handler to javascript";    assert(false);    return QScriptValue();}static void resultHandlerFromScriptValue(const QScriptValue& value, AnimVariantResultHandler& resultHandler) {    qCCritical(scriptengine) << "Attempt to marshall result handler from javascript";    assert(false);} // Templated qScriptRegisterMetaType fails to compile with raw pointersusing ScriptableResourceRawPtr = ScriptableResource*; static QScriptValue scriptableResourceToScriptValue(QScriptEngine* engine,                                                    const ScriptableResourceRawPtr& resource) {    // The first script to encounter this resource will track its memory.    // In this way, it will be more likely to GC.    // This fails in the case that the resource is used across many scripts, but    // in that case it would be too difficult to tell which one should track the memory, and    // this serves the common case (use in a single script).    auto data = resource->getResource();    if (data && !resource->isInScript()) {        resource->setInScript(true);        QObject::connect(data.data(), SIGNAL(updateSize(qint64)), engine, SLOT(updateMemoryCost(qint64)));    }     auto object = engine->newQObject(        const_cast<ScriptableResourceRawPtr>(resource),        QScriptEngine::ScriptOwnership,        DEFAULT_QOBJECT_WRAP_OPTIONS);    return object;} static void scriptableResourceFromScriptValue(const QScriptValue& value, ScriptableResourceRawPtr& resource) {    resource = static_cast<ScriptableResourceRawPtr>(value.toQObject());} /**jsdoc * @namespace Resource * * @hifi-interface * @hifi-client-entity * @hifi-server-entity * @hifi-assignment-client * * @property {Resource.State} State */static QScriptValue createScriptableResourcePrototype(ScriptEnginePointer engine) {    auto prototype = engine->newObject();     // Expose enum State to JS/QML via properties    QObject* state = new QObject(engine.data());    state->setObjectName("ResourceState");    auto metaEnum = QMetaEnum::fromType<ScriptableResource::State>();    for (int i = 0; i < metaEnum.keyCount(); ++i) {        state->setProperty(metaEnum.key(i), metaEnum.value(i));    }     auto prototypeState = engine->newQObject(state, QScriptEngine::QtOwnership,       QScriptEngine::ExcludeDeleteLater | QScriptEngine::ExcludeSlots | QScriptEngine::ExcludeSuperClassMethods);    prototype.setProperty("State", prototypeState);     return prototype;} QScriptValue avatarDataToScriptValue(QScriptEngine* engine, ScriptAvatarData* const& in) {    return engine->newQObject(in, QScriptEngine::ScriptOwnership, DEFAULT_QOBJECT_WRAP_OPTIONS);} void avatarDataFromScriptValue(const QScriptValue& object, ScriptAvatarData*& out) {    // This is not implemented because there are no slots/properties that take an AvatarSharedPointer from a script    assert(false);    out = nullptr;} void ScriptEngine::resetModuleCache(bool deleteScriptCache) {    if (QThread::currentThread() != thread()) {        executeOnScriptThread([=]() { resetModuleCache(deleteScriptCache); });        return;    }    auto jsRequire = globalObject().property("Script").property("require");    auto cache = jsRequire.property("cache");    auto cacheMeta = jsRequire.data();     if (deleteScriptCache) {        QScriptValueIterator it(cache);        while (it.hasNext()) {            it.next();            if (it.flags() & QScriptValue::SkipInEnumeration) {                continue;            }            qCDebug(scriptengine) << "resetModuleCache(true) -- staging " << it.name() << " for cache reset at next require";            cacheMeta.setProperty(it.name(), true);        }    }    cache = newObject();    if (!cacheMeta.isObject()) {        cacheMeta = newObject();        cacheMeta.setProperty("id", "Script.require.cacheMeta");        cacheMeta.setProperty("type", "cacheMeta");        jsRequire.setData(cacheMeta);    }    cache.setProperty("__created__", (double)QDateTime::currentMSecsSinceEpoch(), QScriptValue::SkipInEnumeration);#if DEBUG_JS_MODULES    cache.setProperty("__meta__", cacheMeta, READONLY_HIDDEN_PROP_FLAGS);#endif    jsRequire.setProperty("cache", cache, READONLY_PROP_FLAGS);} void ScriptEngine::init() {    if (_isInitialized) {        return; // only initialize once    }     _isInitialized = true;     auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();    entityScriptingInterface->init();     // register various meta-types    registerMetaTypes(this);    registerMIDIMetaTypes(this);    registerEventTypes(this);    registerMenuItemProperties(this);    registerAnimationTypes(this);    registerAvatarTypes(this);    registerAudioMetaTypes(this);     qScriptRegisterMetaType(this, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue);    qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);    qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);    qScriptRegisterMetaType(this, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue);    qScriptRegisterMetaType(this, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue);    qScriptRegisterMetaType(this, AvatarEntityMapToScriptValue, AvatarEntityMapFromScriptValue);    qScriptRegisterSequenceMetaType<QVector<QUuid>>(this);    qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this);     qScriptRegisterSequenceMetaType<QVector<glm::vec2> >(this);    qScriptRegisterSequenceMetaType<QVector<glm::quat> >(this);    qScriptRegisterSequenceMetaType<QVector<QString> >(this);     QScriptValue xmlHttpRequestConstructorValue = newFunction(XMLHttpRequestClass::constructor);    globalObject().setProperty("XMLHttpRequest", xmlHttpRequestConstructorValue);     QScriptValue webSocketConstructorValue = newFunction(WebSocketClass::constructor);    globalObject().setProperty("WebSocket", webSocketConstructorValue);     globalObject().setProperty("print", newFunction(debugPrint));     QScriptValue audioEffectOptionsConstructorValue = newFunction(AudioEffectOptions::constructor);    globalObject().setProperty("AudioEffectOptions", audioEffectOptionsConstructorValue);     qScriptRegisterMetaType(this, injectorToScriptValue, injectorFromScriptValue);    qScriptRegisterMetaType(this, inputControllerToScriptValue, inputControllerFromScriptValue);    qScriptRegisterMetaType(this, avatarDataToScriptValue, avatarDataFromScriptValue);    qScriptRegisterMetaType(this, animationDetailsToScriptValue, animationDetailsFromScriptValue);    qScriptRegisterMetaType(this, webSocketToScriptValue, webSocketFromScriptValue);    qScriptRegisterMetaType(this, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue);    qScriptRegisterMetaType(this, wscReadyStateToScriptValue, wscReadyStateFromScriptValue);     // NOTE: You do not want to end up creating new instances of singletons here. They will be on the ScriptEngine thread    // and are likely to be unusable if we "reset" the ScriptEngine by creating a new one (on a whole new thread).     registerGlobalObject("Script", this);     {        // set up Script.require.resolve and Script.require.cache        auto Script = globalObject().property("Script");        auto require = Script.property("require");        auto resolve = Script.property("_requireResolve");        require.setProperty("resolve", resolve, READONLY_PROP_FLAGS);        resetModuleCache();    }     registerGlobalObject("Audio", DependencyManager::get<AudioScriptingInterface>().data());     registerGlobalObject("Midi", DependencyManager::get<Midi>().data());     registerGlobalObject("Entities", entityScriptingInterface.data());    registerGlobalObject("Quat", &_quatLibrary);    registerGlobalObject("Vec3", &_vec3Library);    registerGlobalObject("Mat4", &_mat4Library);    registerGlobalObject("Uuid", &_uuidLibrary);    registerGlobalObject("Messages", DependencyManager::get<MessagesClient>().data());    registerGlobalObject("File", new FileScriptingInterface(this));    registerGlobalObject("console", &_consoleScriptingInterface);    registerFunction("console", "info", ConsoleScriptingInterface::info, currentContext()->argumentCount());    registerFunction("console", "log", ConsoleScriptingInterface::log, currentContext()->argumentCount());    registerFunction("console", "debug", ConsoleScriptingInterface::debug, currentContext()->argumentCount());    registerFunction("console", "warn", ConsoleScriptingInterface::warn, currentContext()->argumentCount());    registerFunction("console", "error", ConsoleScriptingInterface::error, currentContext()->argumentCount());    registerFunction("console", "exception", ConsoleScriptingInterface::exception, currentContext()->argumentCount());    registerFunction("console", "assert", ConsoleScriptingInterface::assertion, currentContext()->argumentCount());    registerFunction("console", "group", ConsoleScriptingInterface::group, 1);    registerFunction("console", "groupCollapsed", ConsoleScriptingInterface::groupCollapsed, 1);    registerFunction("console", "groupEnd", ConsoleScriptingInterface::groupEnd, 0);     qScriptRegisterMetaType(this, animVarMapToScriptValue, animVarMapFromScriptValue);    qScriptRegisterMetaType(this, resultHandlerToScriptValue, resultHandlerFromScriptValue);     // Scriptable cache access    auto resourcePrototype = createScriptableResourcePrototype(qSharedPointerCast<ScriptEngine>(sharedFromThis()));    globalObject().setProperty("Resource", resourcePrototype);    setDefaultPrototype(qMetaTypeId<ScriptableResource*>(), resourcePrototype);    qScriptRegisterMetaType(this, scriptableResourceToScriptValue, scriptableResourceFromScriptValue);     // constants    globalObject().setProperty("TREE_SCALE", newVariant(QVariant(TREE_SCALE)));     registerGlobalObject("Assets", _assetScriptingInterface);    registerGlobalObject("Resources", DependencyManager::get<ResourceScriptingInterface>().data());     registerGlobalObject("DebugDraw", &DebugDraw::getInstance());     registerGlobalObject("Model", new ModelScriptingInterface(this));    qScriptRegisterMetaType(this, meshToScriptValue, meshFromScriptValue);    qScriptRegisterMetaType(this, meshesToScriptValue, meshesFromScriptValue);     registerGlobalObject("UserActivityLogger", DependencyManager::get<UserActivityLoggerScriptingInterface>().data()); #if DEV_BUILD || PR_BUILD    registerGlobalObject("StackTest", new StackTestScriptingInterface(this));#endif} void ScriptEngine::registerValue(const QString& valueName, QScriptValue value) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::registerValue() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]";#endif        QMetaObject::invokeMethod(this, "registerValue",                                  Q_ARG(const QString&, valueName),                                  Q_ARG(QScriptValue, value));        return;    }     QStringList pathToValue = valueName.split(".");    int partsToGo = pathToValue.length();    QScriptValue partObject = globalObject();     for (const auto& pathPart : pathToValue) {        partsToGo--;        if (!partObject.property(pathPart).isValid()) {            if (partsToGo > 0) {                //QObject *object = new QObject;                QScriptValue partValue = newArray(); //newQObject(object, QScriptEngine::ScriptOwnership);                partObject.setProperty(pathPart, partValue);            } else {                partObject.setProperty(pathPart, value);            }        }        partObject = partObject.property(pathPart);    }} void ScriptEngine::registerGlobalObject(const QString& name, QObject* object) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::registerGlobalObject() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]  name:" << name;#endif        QMetaObject::invokeMethod(this, "registerGlobalObject",                                  Q_ARG(const QString&, name),                                  Q_ARG(QObject*, object));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::registerGlobalObject() called on thread [" << QThread::currentThread() << "] name:" << name;#endif     if (!globalObject().property(name).isValid()) {        if (object) {            QScriptValue value = newQObject(object, QScriptEngine::QtOwnership, DEFAULT_QOBJECT_WRAP_OPTIONS);            globalObject().setProperty(name, value);        } else {            globalObject().setProperty(name, QScriptValue());        }    }} void ScriptEngine::registerFunction(const QString& name, QScriptEngine::FunctionSignature functionSignature, int numArguments) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::registerFunction() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] name:" << name;#endif        QMetaObject::invokeMethod(this, "registerFunction",                                  Q_ARG(const QString&, name),                                  Q_ARG(QScriptEngine::FunctionSignature, functionSignature),                                  Q_ARG(int, numArguments));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::registerFunction() called on thread [" << QThread::currentThread() << "] name:" << name;#endif     QScriptValue scriptFun = newFunction(functionSignature, numArguments);    globalObject().setProperty(name, scriptFun);} void ScriptEngine::registerFunction(const QString& parent, const QString& name, QScriptEngine::FunctionSignature functionSignature, int numArguments) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::registerFunction() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] parent:" << parent << "name:" << name;#endif        QMetaObject::invokeMethod(this, "registerFunction",                                  Q_ARG(const QString&, name),                                  Q_ARG(QScriptEngine::FunctionSignature, functionSignature),                                  Q_ARG(int, numArguments));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::registerFunction() called on thread [" << QThread::currentThread() << "] parent:" << parent << "name:" << name;#endif     QScriptValue object = globalObject().property(parent);    if (object.isValid()) {        QScriptValue scriptFun = newFunction(functionSignature, numArguments);        object.setProperty(name, scriptFun);    }} void ScriptEngine::registerGetterSetter(const QString& name, QScriptEngine::FunctionSignature getter,                                        QScriptEngine::FunctionSignature setter, const QString& parent) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::registerGetterSetter() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] "            " name:" << name << "parent:" << parent;#endif        QMetaObject::invokeMethod(this, "registerGetterSetter",                                  Q_ARG(const QString&, name),                                  Q_ARG(QScriptEngine::FunctionSignature, getter),                                  Q_ARG(QScriptEngine::FunctionSignature, setter),                                  Q_ARG(const QString&, parent));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::registerGetterSetter() called on thread [" << QThread::currentThread() << "] name:" << name << "parent:" << parent;#endif     QScriptValue setterFunction = newFunction(setter, 1);    QScriptValue getterFunction = newFunction(getter);     if (!parent.isNull() && !parent.isEmpty()) {        QScriptValue object = globalObject().property(parent);        if (object.isValid()) {            object.setProperty(name, setterFunction, QScriptValue::PropertySetter);            object.setProperty(name, getterFunction, QScriptValue::PropertyGetter);        }    } else {        globalObject().setProperty(name, setterFunction, QScriptValue::PropertySetter);        globalObject().setProperty(name, getterFunction, QScriptValue::PropertyGetter);    }} // Unregister the handlers for this eventName and entityID.void ScriptEngine::removeEventHandler(const EntityItemID& entityID, const QString& eventName, QScriptValue handler) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::removeEventHandler() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] "            "entityID:" << entityID << " eventName:" << eventName;#endif        QMetaObject::invokeMethod(this, "removeEventHandler",                                  Q_ARG(const EntityItemID&, entityID),                                  Q_ARG(const QString&, eventName),                                  Q_ARG(QScriptValue, handler));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::removeEventHandler() called on thread [" << QThread::currentThread() << "] entityID:" << entityID << " eventName : " << eventName;#endif     if (!_registeredHandlers.contains(entityID)) {        return;    }    RegisteredEventHandlers& handlersOnEntity = _registeredHandlers[entityID];    CallbackList& handlersForEvent = handlersOnEntity[eventName];    // QScriptValue does not have operator==(), so we can't use QList::removeOne and friends. So iterate.    for (int i = 0; i < handlersForEvent.count(); ++i) {        if (handlersForEvent[i].function.equals(handler)) {            handlersForEvent.removeAt(i);            return; // Design choice: since comparison is relatively expensive, just remove the first matching handler.        }    }}// Register the handler.void ScriptEngine::addEventHandler(const EntityItemID& entityID, const QString& eventName, QScriptValue handler) {    if (QThread::currentThread() != thread()) {#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::addEventHandler() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] "        "entityID:" << entityID << " eventName:" << eventName;#endif         QMetaObject::invokeMethod(this, "addEventHandler",                                  Q_ARG(const EntityItemID&, entityID),                                  Q_ARG(const QString&, eventName),                                  Q_ARG(QScriptValue, handler));        return;    }#ifdef THREAD_DEBUGGING    qCDebug(scriptengine) << "ScriptEngine::addEventHandler() called on thread [" << QThread::currentThread() << "] entityID:" << entityID << " eventName : " << eventName;#endif     if (_registeredHandlers.count() == 0) { // First time any per-entity handler has been added in this script...        // Connect up ALL the handlers to the global entities object's signals.        // (We could go signal by signal, or even handler by handler, but I don't think the efficiency is worth the complexity.)        auto entities = DependencyManager::get<EntityScriptingInterface>();        // Bug? These handlers are deleted when entityID is deleted, which is nice.        // But if they are created by an entity script on a different entity, should they also be deleted when the entity script unloads?        // E.g., suppose a bow has an entity script that causes arrows to be created with a potential lifetime greater than the bow,        // and that the entity script adds (e.g., collision) handlers to the arrows. Should those handlers fire if the bow is unloaded?        // Also, what about when the entity script is REloaded?        // For now, we are leaving them around. Changing that would require some non-trivial digging around to find the        // handlers that were added while a given currentEntityIdentifier was in place. I don't think this is dangerous. Just perhaps unexpected. -HRS        connect(entities.data(), &EntityScriptingInterface::deletingEntity, this, [this](const EntityItemID& entityID) {            _registeredHandlers.remove(entityID);        });         // Two common cases of event handler, differing only in argument signature.        using SingleEntityHandler = std::function<void(const EntityItemID&)>;        auto makeSingleEntityHandler = [this](QString eventName) -> SingleEntityHandler {            return [this, eventName](const EntityItemID& entityItemID) {                forwardHandlerCall(entityItemID, eventName, { entityItemID.toScriptValue(this) });            };        };         using PointerHandler = std::function<void(const EntityItemID&, const PointerEvent&)>;        auto makePointerHandler = [this](QString eventName) -> PointerHandler {            return [this, eventName](const EntityItemID& entityItemID, const PointerEvent& event) {                forwardHandlerCall(entityItemID, eventName, { entityItemID.toScriptValue(this), event.toScriptValue(this) });            };        };         using CollisionHandler = std::function<void(const EntityItemID&, const EntityItemID&, const Collision&)>;        auto makeCollisionHandler = [this](QString eventName) -> CollisionHandler {            return [this, eventName](const EntityItemID& idA, const EntityItemID& idB, const Collision& collision) {                forwardHandlerCall(idA, eventName, { idA.toScriptValue(this), idB.toScriptValue(this),                    collisionToScriptValue(this, collision) });            };        };         connect(entities.data(), &EntityScriptingInterface::enterEntity, this, makeSingleEntityHandler("enterEntity"));        connect(entities.data(), &EntityScriptingInterface::leaveEntity, this, makeSingleEntityHandler("leaveEntity"));         connect(entities.data(), &EntityScriptingInterface::mousePressOnEntity, this, makePointerHandler("mousePressOnEntity"));        connect(entities.data(), &EntityScriptingInterface::mouseMoveOnEntity, this, makePointerHandler("mouseMoveOnEntity"));        connect(entities.data(), &EntityScriptingInterface::mouseReleaseOnEntity, this, makePointerHandler("mouseReleaseOnEntity"));         connect(entities.data(), &EntityScriptingInterface::clickDownOnEntity, this, makePointerHandler("clickDownOnEntity"));        connect(entities.data(), &EntityScriptingInterface::holdingClickOnEntity, this, makePointerHandler("holdingClickOnEntity"));        connect(entities.data(), &EntityScriptingInterface::clickReleaseOnEntity, this, makePointerHandler("clickReleaseOnEntity"));         connect(entities.data(), &EntityScriptingInterface::hoverEnterEntity, this, makePointerHandler("hoverEnterEntity"));        connect(entities.data(), &EntityScriptingInterface::hoverOverEntity, this, makePointerHandler("hoverOverEntity"));        connect(entities.data(), &EntityScriptingInterface::hoverLeaveEntity, this, makePointerHandler("hoverLeaveEntity"));         connect(entities.data(), &EntityScriptingInterface::collisionWithEntity, this, makeCollisionHandler("collisionWithEntity"));    }

Lines 501–1000 of 2746. Previous lines Load more