// 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);    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);     QScriptValue printConstructorValue = newFunction(debugPrint);    globalObject().setProperty("print", printConstructorValue);     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);     registerGlobalObject("Script", this);    registerGlobalObject("Audio", &AudioScriptingInterface::getInstance());    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));        qScriptRegisterMetaType(this, animVarMapToScriptValue, animVarMapFromScriptValue);    qScriptRegisterMetaType(this, resultHandlerToScriptValue, resultHandlerFromScriptValue);     // Scriptable cache access    auto resourcePrototype = createScriptableResourcePrototype(this);    globalObject().setProperty("Resource", resourcePrototype);    setDefaultPrototype(qMetaTypeId<ScriptableResource*>(), resourcePrototype);    qScriptRegisterMetaType(this, scriptableResourceToScriptValue, scriptableResourceFromScriptValue);     // constants    globalObject().setProperty("TREE_SCALE", newVariant(QVariant(TREE_SCALE)));     auto recordingInterface = DependencyManager::get<RecordingScriptingInterface>();    registerGlobalObject("Recording", recordingInterface.data());     registerGlobalObject("Tablet", DependencyManager::get<TabletScriptingInterface>().data());     registerGlobalObject("Assets", &_assetScriptingInterface);    registerGlobalObject("Resources", DependencyManager::get<ResourceScriptingInterface>().data());} 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"));    }    if (!_registeredHandlers.contains(entityID)) {        _registeredHandlers[entityID] = RegisteredEventHandlers();    }    CallbackList& handlersForEvent = _registeredHandlers[entityID][eventName];    CallbackData handlerData = { handler, currentEntityIdentifier, currentSandboxURL };    handlersForEvent << handlerData; // Note that the same handler can be added many times. See removeEntityEventHandler().}  QScriptValue ScriptEngine::evaluate(const QString& sourceCode, const QString& fileName, int lineNumber) {    if (DependencyManager::get<ScriptEngines>()->isStopped()) {        return QScriptValue(); // bail early    }     if (QThread::currentThread() != thread()) {        QScriptValue result;#ifdef THREAD_DEBUGGING        qCDebug(scriptengine) << "*** WARNING *** ScriptEngine::evaluate() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "] "            "sourceCode:" << sourceCode << " fileName:" << fileName << "lineNumber:" << lineNumber;#endif        QMetaObject::invokeMethod(this, "evaluate", Qt::BlockingQueuedConnection,                                  Q_RETURN_ARG(QScriptValue, result),                                  Q_ARG(const QString&, sourceCode),                                  Q_ARG(const QString&, fileName),                                  Q_ARG(int, lineNumber));        return result;    }     // Check syntax    const QScriptProgram program(sourceCode, fileName, lineNumber);    if (!hasCorrectSyntax(program, this)) {        return QScriptValue();    }     ++_evaluatesPending;    const auto result = QScriptEngine::evaluate(program);    --_evaluatesPending;     const auto hadUncaughtException = hadUncaughtExceptions(*this, program.fileName(), this);    emit evaluationFinished(result, hadUncaughtException);    return result;} void ScriptEngine::run() {    if (DependencyManager::get<ScriptEngines>()->isStopped()) {        return; // bail early - avoid setting state in init(), as evaluate() will bail too    }     if (!_isInitialized) {        init();    }     _isRunning = true;    emit runningStateChanged();     QScriptValue result = evaluate(_scriptContents, _fileNameString); #ifdef _WIN32    // VS13 does not sleep_until unless it uses the system_clock, see:    // https://www.reddit.com/r/cpp_questions/comments/3o71ic/sleep_until_not_working_with_a_time_pointsteady/    using clock = std::chrono::system_clock;#else    using clock = std::chrono::high_resolution_clock;#endif     clock::time_point startTime = clock::now();    int thisFrame = 0;     auto nodeList = DependencyManager::get<NodeList>();    auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();     _lastUpdate = usecTimestampNow();     std::chrono::microseconds totalUpdates(0);     // TODO: Integrate this with signals/slots instead of reimplementing throttling for ScriptEngine    while (!_isFinished) {        auto beforeSleep = clock::now();         // Throttle to SCRIPT_FPS        // We'd like to try to keep the script at a solid SCRIPT_FPS update rate. And so we will         // calculate a sleepUntil to be the time from our start time until the original target        // sleepUntil for this frame. This approach will allow us to "catch up" in the event         // that some of our script udpates/frames take a little bit longer than the target average         // to execute.        // NOTE: if we go to variable SCRIPT_FPS, then we will need to reconsider this approach        const std::chrono::microseconds TARGET_SCRIPT_FRAME_DURATION(USECS_PER_SECOND / SCRIPT_FPS + 1);        clock::time_point targetSleepUntil(startTime + (thisFrame++ * TARGET_SCRIPT_FRAME_DURATION));         // However, if our sleepUntil is not at least our average update and timer execution time         // into the future it means our script is taking too long in its updates, and we want to         // punish the script a little bit. So we will force the sleepUntil to be at least our         // averageUpdate + averageTimerPerFrame time into the future.        auto averageUpdate = totalUpdates / thisFrame;        auto averageTimerPerFrame = _totalTimerExecution / thisFrame;        auto averageTimerAndUpdate = averageUpdate + averageTimerPerFrame;        auto sleepUntil = std::max(targetSleepUntil, beforeSleep + averageTimerAndUpdate);         // We don't want to actually sleep for too long, because it causes our scripts to hang         // on shutdown and stop... so we want to loop and sleep until we've spent our time in         // purgatory, constantly checking to see if our script was asked to end        bool processedEvents = false;        while (!_isFinished && clock::now() < sleepUntil) {             QCoreApplication::processEvents(); // before we sleep again, give events a chance to process            processedEvents = true;             // If after processing events, we're past due, exit asap            if (clock::now() >= sleepUntil) {                break;            }             // We only want to sleep a small amount so that any pending events (like timers or invokeMethod events)            // will be able to process quickly.            static const int SMALL_SLEEP_AMOUNT = 100;            auto smallSleepUntil = clock::now() + static_cast<std::chrono::microseconds>(SMALL_SLEEP_AMOUNT);            std::this_thread::sleep_until(smallSleepUntil);        } #ifdef SCRIPT_DELAY_DEBUG        {            auto actuallySleptUntil = clock::now();            uint64_t seconds = std::chrono::duration_cast<std::chrono::seconds>(actuallySleptUntil - startTime).count();            if (seconds > 0) { // avoid division by zero and time travel                uint64_t fps = thisFrame / seconds;                // Overreporting artificially reduces the reported rate                if (thisFrame % SCRIPT_FPS == 0) {                    qCDebug(scriptengine) <<                        "Frame:" << thisFrame <<                        "Slept (us):" << std::chrono::duration_cast<std::chrono::microseconds>(actuallySleptUntil - beforeSleep).count() <<                        "Avg Updates (us):" << averageUpdate.count() <<                        "FPS:" << fps;                }            }        }#endif        if (_isFinished) {            break;        }         // Only call this if we didn't processEvents as part of waiting for next frame        if (!processedEvents) {            QCoreApplication::processEvents();        }         if (_isFinished) {            break;        }         if (!_isFinished && entityScriptingInterface->getEntityPacketSender()->serversExist()) {            // release the queue of edit entity messages.            entityScriptingInterface->getEntityPacketSender()->releaseQueuedMessages();             // since we're in non-threaded mode, call process so that the packets are sent            if (!entityScriptingInterface->getEntityPacketSender()->isThreaded()) {                entityScriptingInterface->getEntityPacketSender()->process();            }        }         qint64 now = usecTimestampNow();         // we check for 'now' in the past in case people set their clock back        if (_emitScriptUpdates() && _lastUpdate < now) {            float deltaTime = (float) (now - _lastUpdate) / (float) USECS_PER_SECOND;            if (!_isFinished) {                auto preUpdate = clock::now();                emit update(deltaTime);                auto postUpdate = clock::now();                auto elapsed = (postUpdate - preUpdate);                totalUpdates += std::chrono::duration_cast<std::chrono::microseconds>(elapsed);            }        }        _lastUpdate = now;         // Debug and clear exceptions        hadUncaughtExceptions(*this, _fileNameString, this);    }     scriptInfoMessage("Script Engine stopping:" + getFilename());     stopAllTimers(); // make sure all our timers are stopped if the script is ending    emit scriptEnding();     if (entityScriptingInterface->getEntityPacketSender()->serversExist()) {        // release the queue of edit entity messages.        entityScriptingInterface->getEntityPacketSender()->releaseQueuedMessages();         // since we're in non-threaded mode, call process so that the packets are sent        if (!entityScriptingInterface->getEntityPacketSender()->isThreaded()) {            // wait here till the edit packet sender is completely done sending            while (entityScriptingInterface->getEntityPacketSender()->hasPacketsToSend()) {                entityScriptingInterface->getEntityPacketSender()->process();                QCoreApplication::processEvents();            }        } else {

Lines 501–1000 of 1715. Previous lines Load more