////  AnimVariant.cpp//  library/animation////  Created by Howard Stearns on 10/15/15.//  Copyright (c) 2015 High Fidelity, Inc. All rights reserved.//  Copyright 2023 Overte e.V.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html//  SPDX-License-Identifier: Apache-2.0// #include "AnimVariant.h" // which has AnimVariant/AnimVariantMap #include <ScriptEngine.h>#include <QThread>#include <ScriptValueIterator.h>#include <ScriptValueUtils.h> const AnimVariant AnimVariant::False = AnimVariant(); ScriptValue AnimVariantMap::animVariantMapToScriptValue(ScriptEngine* engine, const QStringList& names, bool useNames) const {    if (QThread::currentThread() != engine->thread()) {        qCWarning(animation) << "Cannot create Javacript object from non-script thread" << QThread::currentThread();        Q_ASSERT(false);        return ScriptValue();    }    ScriptValue target = engine->newObject();    auto setOne = [&] (const QString& name, const AnimVariant& value) {        switch (value.getType()) {            case AnimVariant::Type::Bool:                target.setProperty(name, value.getBool());                break;            case AnimVariant::Type::Int:                target.setProperty(name, value.getInt());                break;            case AnimVariant::Type::Float:                target.setProperty(name, value.getFloat());                break;            case AnimVariant::Type::String:                target.setProperty(name, value.getString());                break;            case AnimVariant::Type::Vec3:                target.setProperty(name, vec3ToScriptValue(engine, value.getVec3()));                break;            case AnimVariant::Type::Quat:                target.setProperty(name, quatToScriptValue(engine, value.getQuat()));                break;            default:                // Unknown type                assert(QString("AnimVariant::Type") == QString("valid"));        }    };    if (useNames) { // copy only the requested names        for (const QString& name : names) {            auto search = _map.find(name);            if (search != _map.end()) {                setOne(name, search->second);            } else if (_triggers.count(name) == 1) {                target.setProperty(name, true);            } // scripts are allowed to request names that do not exist        }     } else {  // copy all of them        for (auto& pair : _map) {            setOne(pair.first, pair.second);        }    }    return target;} void AnimVariantMap::copyVariantsFrom(const AnimVariantMap& other) {    for (auto& pair : other._map) {        _map[pair.first] = pair.second;    }} void AnimVariantMap::animVariantMapFromScriptValue(const ScriptValue& source) {    if (QThread::currentThread() != source.engine()->thread()) {        qCWarning(animation) << "Cannot examine Javacript object from non-script thread" << QThread::currentThread();        Q_ASSERT(false);        return;    }    // This was here before, but marking as V8TODO    // POTENTIAL OPTIMIZATION: cache the types we've seen. I.e, keep a dictionary mapping property names to an enumeration of types.    // Whenever we identify a new outbound type in animVariantMapToScriptValue above, or a new inbound type in the code that follows here,    // we would enter it into the dictionary. Then switch on that type here, with the code that follow being executed only if    // the type is not known. One problem with that is that there is no checking that two different script use the same name differently.    ScriptValueIteratorPointer property(source.newIterator());    // Note: ScriptValueIterator iterates only over source's own properties. It does not follow the prototype chain.    while (property->hasNext()) {        property->next();        ScriptValue value = property->value();        if (value.isBool()) {            set(property->name(), value.toBool());        } else if (value.isString()) {            set(property->name(), value.toString());        } else if (value.isNumber()) {            int asInteger = value.toInt32();            float asFloat = value.toNumber();            if (asInteger == asFloat) {                set(property->name(), asInteger);            } else {                set(property->name(), asFloat);            }        } else { // Try to get x,y,z and possibly w            if (value.isObject()) {                ScriptValue x = value.property("x");                if (x.isNumber()) {                    ScriptValue y = value.property("y");                    if (y.isNumber()) {                        ScriptValue z = value.property("z");                        if (z.isNumber()) {                            ScriptValue w = value.property("w");                            if (w.isNumber()) {                                set(property->name(), glm::quat(w.toNumber(), x.toNumber(), y.toNumber(), z.toNumber()));                            } else {                                set(property->name(), glm::vec3(x.toNumber(), y.toNumber(), z.toNumber()));                            }                            continue; // we got either a vector or quaternion object, so don't fall through to warning                        }                    }                }            }            qCWarning(animation) << "Ignoring unrecognized data " << value.toString() << " for animation property " << property->name();            //Q_ASSERT(false);        }    }} std::map<QString, QString> AnimVariantMap::toDebugMap() const {    std::map<QString, QString> result;    for (auto& pair : _map) {        switch (pair.second.getType()) {        case AnimVariant::Type::Bool:            result[pair.first] = QString("%1").arg(pair.second.getBool());            break;        case AnimVariant::Type::Int:            result[pair.first] = QString("%1").arg(pair.second.getInt());            break;        case AnimVariant::Type::Float:            result[pair.first] = QString::number(pair.second.getFloat(), 'f', 3);            break;        case AnimVariant::Type::Vec3: {            // To prevent filling up debug stats, don't show vec3 values            glm::vec3 value = pair.second.getVec3();            result[pair.first] = QString("(%1, %2, %3)").                arg(QString::number(value.x, 'f', 3)).                arg(QString::number(value.y, 'f', 3)).                arg(QString::number(value.z, 'f', 3));            break;        }        case AnimVariant::Type::Quat: {            // To prevent filling up the anim stats, don't show quat values            glm::quat value = pair.second.getQuat();            result[pair.first] = QString("(%1, %2, %3, %4)").                arg(QString::number(value.x, 'f', 3)).                arg(QString::number(value.y, 'f', 3)).                arg(QString::number(value.z, 'f', 3)).                arg(QString::number(value.w, 'f', 3));            break;        }        case AnimVariant::Type::String:            // To prevent filling up anim stats, don't show string values            result[pair.first] = pair.second.getString();            break;        default:            // invalid AnimVariant::Type            assert(false);        }    }    return result;}