Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 23:16:50 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixes to most scripting-related warnings

Browse source
This commit is contained in:
ksuprynowicz 2022-08-19 14:10:54 +02:00
parent a14c6444f1
commit 6f32173025
35 changed files with 189 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/LODManager.cpp
View file

@ -22,11 +22,11 @@
#include "ui/DialogsManager.h" #include "ui/DialogsManager.h"
#include "InterfaceLogging.h" #include "InterfaceLogging.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, worldDetailQualityToScriptValue, worldDetailQualityFromScriptValue); scriptRegisterMetaType<WorldDetailQuality, worldDetailQualityToScriptValue, worldDetailQualityFromScriptValue>(scriptEngine);
}); }));
const QString LOD_SETTINGS_PREFIX { "lodManager/" }; const QString LOD_SETTINGS_PREFIX { "lodManager/" };

8
interface/src/RefreshRateManager.cpp
View file

@ -17,13 +17,13 @@
#include <ScriptEngineCast.h> #include <ScriptEngineCast.h>
#include <ScriptManager.h> #include <ScriptManager.h>
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<RefreshRateManager::RefreshRateRegime>, scriptValueToEnumClass<RefreshRateManager::RefreshRateRegime>, "RefreshRateRegime"); scriptRegisterMetaType<RefreshRateManager::RefreshRateRegime, scriptValueFromEnumClass<RefreshRateManager::RefreshRateRegime>, scriptValueToEnumClass<RefreshRateManager::RefreshRateRegime> >(scriptEngine, "RefreshRateRegime");
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<RefreshRateManager::UXMode>, scriptValueToEnumClass<RefreshRateManager::UXMode>, "UXMode"); scriptRegisterMetaType<RefreshRateManager::UXMode, scriptValueFromEnumClass<RefreshRateManager::UXMode>, scriptValueToEnumClass<RefreshRateManager::UXMode> >(scriptEngine, "UXMode");
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

4
interface/src/avatar/MyAvatar.cpp
View file

@ -452,8 +452,8 @@ void MyAvatar::enableHandTouchForID(const QUuid& entityID) {
} }
void MyAvatar::registerMetaTypes(ScriptEnginePointer engine) { void MyAvatar::registerMetaTypes(ScriptEnginePointer engine) {
scriptRegisterMetaType(engine.get(), audioListenModeToScriptValue, audioListenModeFromScriptValue); scriptRegisterMetaType<AudioListenerMode, audioListenModeToScriptValue, audioListenModeFromScriptValue>(engine.get());
scriptRegisterMetaType(engine.get(), driveKeysToScriptValue, driveKeysFromScriptValue); scriptRegisterMetaType<MyAvatar::DriveKeys, driveKeysToScriptValue, driveKeysFromScriptValue>(engine.get());
} }
void MyAvatar::registerProperties(ScriptEnginePointer engine) { void MyAvatar::registerProperties(ScriptEnginePointer engine) {

2
interface/src/raypick/PickScriptingInterface.cpp
View file

@ -464,7 +464,7 @@ bool pickTypesFromScriptValue(const ScriptValue& object, PickQuery::PickType& pi
} }
void PickScriptingInterface::registerMetaTypes(ScriptEngine* engine) { void PickScriptingInterface::registerMetaTypes(ScriptEngine* engine) {
scriptRegisterMetaType(engine, pickTypesToScriptValue, pickTypesFromScriptValue); scriptRegisterMetaType<PickQuery::PickType, pickTypesToScriptValue, pickTypesFromScriptValue>(engine);
} }
void PickScriptingInterface::registerProperties(ScriptEngine* engine) { void PickScriptingInterface::registerProperties(ScriptEngine* engine) {

6
interface/src/scripting/AccountServicesScriptingInterface.cpp
View file

@ -19,11 +19,11 @@
#include "DiscoverabilityManager.h" #include "DiscoverabilityManager.h"
#include "ResourceCache.h" #include "ResourceCache.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, DownloadInfoResultToScriptValue, DownloadInfoResultFromScriptValue); scriptRegisterMetaType<DownloadInfoResult, DownloadInfoResultToScriptValue, DownloadInfoResultFromScriptValue>(scriptEngine);
}); }));
AccountServicesScriptingInterface::AccountServicesScriptingInterface() { AccountServicesScriptingInterface::AccountServicesScriptingInterface() {
auto accountManager = DependencyManager::get<AccountManager>(); auto accountManager = DependencyManager::get<AccountManager>();

8
interface/src/scripting/PerformanceScriptingInterface.cpp
View file

@ -14,12 +14,12 @@
#include "../Application.h" #include "../Application.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<PerformanceScriptingInterface::PerformancePreset>, scriptValueToEnumClass<PerformanceScriptingInterface::PerformancePreset>, "PerformancePreset"); scriptRegisterMetaType<PerformanceScriptingInterface::PerformancePreset, scriptValueFromEnumClass<PerformanceScriptingInterface::PerformancePreset>, scriptValueToEnumClass<PerformanceScriptingInterface::PerformancePreset> >(scriptEngine, "PerformancePreset");
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, scriptValueToEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, "RefreshRateProfile"); scriptRegisterMetaType<PerformanceScriptingInterface::RefreshRateProfile, scriptValueFromEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, scriptValueToEnumClass<PerformanceScriptingInterface::RefreshRateProfile> >(scriptEngine, "RefreshRateProfile");
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

6
interface/src/scripting/PlatformInfoScriptingInterface.cpp
View file

@ -21,11 +21,11 @@
#include <sstream> #include <sstream>
#endif #endif
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<PlatformInfoScriptingInterface::PlatformTier>, scriptValueToEnumClass<PlatformInfoScriptingInterface::PlatformTier>, "PlatformTier"); scriptRegisterMetaType<PlatformInfoScriptingInterface::PlatformTier, scriptValueFromEnumClass<PlatformInfoScriptingInterface::PlatformTier>, scriptValueToEnumClass<PlatformInfoScriptingInterface::PlatformTier> >(scriptEngine, "PlatformTier");
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

8
interface/src/scripting/RenderScriptingInterface.cpp
View file

@ -14,12 +14,12 @@
#include <QScreen> #include <QScreen>
#include "ScreenName.h" #include "ScreenName.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod>, "RenderMethod"); scriptRegisterMetaType<RenderScriptingInterface::RenderMethod, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod> >(scriptEngine, "RenderMethod");
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode>, "Mode"); scriptRegisterMetaType<AntialiasingConfig::Mode, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode> >(scriptEngine, "Mode");
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

2
interface/src/ui/InteractiveWindow.cpp
View file

@ -101,7 +101,7 @@ static void dockWidgetDeleter(DockWidget* dockWidget) {
} }
void registerInteractiveWindowMetaType(ScriptEngine* engine) { void registerInteractiveWindowMetaType(ScriptEngine* engine) {
scriptRegisterMetaType(engine, interactiveWindowPointerToScriptValue, interactiveWindowPointerFromScriptValue); scriptRegisterMetaType<InteractiveWindowPointer, interactiveWindowPointerToScriptValue, interactiveWindowPointerFromScriptValue>(engine);
} }
ScriptValue interactiveWindowPointerToScriptValue(ScriptEngine* engine, const InteractiveWindowPointer& in) { ScriptValue interactiveWindowPointerToScriptValue(ScriptEngine* engine, const InteractiveWindowPointer& in) {

8
interface/src/ui/overlays/Overlays.cpp
View file

@ -43,12 +43,12 @@ Q_LOGGING_CATEGORY(trace_render_overlays, "trace.render.overlays")
std::unordered_map<QString, QString> Overlays::_entityToOverlayTypes; std::unordered_map<QString, QString> Overlays::_entityToOverlayTypes;
std::unordered_map<QString, QString> Overlays::_overlayToEntityTypes; std::unordered_map<QString, QString> Overlays::_overlayToEntityTypes;
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, RayToOverlayIntersectionResultToScriptValue, scriptRegisterMetaType<RayToOverlayIntersectionResult, RayToOverlayIntersectionResultToScriptValue,
RayToOverlayIntersectionResultFromScriptValue); RayToOverlayIntersectionResultFromScriptValue>(scriptEngine);
}); }));
Overlays::Overlays() : _scriptEngine(newScriptEngine()) { Overlays::Overlays() : _scriptEngine(newScriptEngine()) {
ADD_TYPE_MAP(Box, cube); ADD_TYPE_MAP(Box, cube);

6
libraries/audio/src/AudioEffectOptions.cpp
View file

@ -17,11 +17,11 @@
#include <ScriptValue.h> #include <ScriptValue.h>
#include <ScriptEngineCast.h> #include <ScriptEngineCast.h>
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, audioEffectOptionsToScriptValue, audioEffectOptionsFromScriptValue); scriptRegisterMetaType<AudioEffectOptions, audioEffectOptionsToScriptValue, audioEffectOptionsFromScriptValue>(scriptEngine);
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

4
libraries/audio/src/AudioScriptingInterface.cpp
View file

@ -35,8 +35,8 @@ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
}); });
void registerAudioMetaTypes(ScriptEngine* engine) { void registerAudioMetaTypes(ScriptEngine* engine) {
scriptRegisterMetaType(engine, injectorOptionsToScriptValue, injectorOptionsFromScriptValue); scriptRegisterMetaType<AudioInjectorOptions, injectorOptionsToScriptValue, injectorOptionsFromScriptValue>(engine);
scriptRegisterMetaType(engine, soundSharedPointerToScriptValue, soundSharedPointerFromScriptValue); scriptRegisterMetaType<SharedSoundPointer, soundSharedPointerToScriptValue, soundSharedPointerFromScriptValue>(engine);
} }

6
libraries/audio/src/ScriptAudioInjector.cpp
View file

@ -18,11 +18,11 @@
#include <ScriptManager.h> #include <ScriptManager.h>
#include <ScriptValue.h> #include <ScriptValue.h>
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, injectorToScriptValue, injectorFromScriptValue); scriptRegisterMetaType<ScriptAudioInjector*, injectorToScriptValue, injectorFromScriptValue>(scriptEngine);
}); }));
ScriptValue injectorToScriptValue(ScriptEngine* engine, ScriptAudioInjector* const& in) { ScriptValue injectorToScriptValue(ScriptEngine* engine, ScriptAudioInjector* const& in) {
// The AudioScriptingInterface::playSound method can return null, so we need to account for that. // The AudioScriptingInterface::playSound method can return null, so we need to account for that.

8
libraries/avatars/src/AvatarData.cpp
View file

@ -69,13 +69,13 @@ static const float DEFAULT_AVATAR_DENSITY = 1000.0f; // density of water
#define ASSERT(COND) do { if (!(COND)) { abort(); } } while(0) #define ASSERT(COND) do { if (!(COND)) { abort(); } } while(0)
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
registerAvatarTypes(scriptEngine); registerAvatarTypes(scriptEngine);
scriptRegisterMetaType(scriptEngine, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue); scriptRegisterMetaType<RayToAvatarIntersectionResult, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, AvatarEntityMapToScriptValue, AvatarEntityMapFromScriptValue); scriptRegisterMetaType<AvatarEntityMap, AvatarEntityMapToScriptValue, AvatarEntityMapFromScriptValue>(scriptEngine);
}); }));
STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();

6
libraries/avatars/src/ScriptAvatarData.cpp
View file

@ -26,11 +26,11 @@ bool avatarDataFromScriptValue(const ScriptValue& object, ScriptAvatarData*& out
return false; return false;
} }
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, avatarDataToScriptValue, avatarDataFromScriptValue); scriptRegisterMetaType<ScriptAvatarData*, avatarDataToScriptValue, avatarDataFromScriptValue>(scriptEngine);
}); }));
ScriptAvatarData::ScriptAvatarData(AvatarSharedPointer avatarData) : ScriptAvatarData::ScriptAvatarData(AvatarSharedPointer avatarData) :
_avatarData(avatarData) _avatarData(avatarData)

5
libraries/baking/src/MaterialBaker.cpp
View file

@ -4,6 +4,7 @@
// //
// Created by Sam Gondelman on 2/26/2019 // Created by Sam Gondelman on 2/26/2019
// Copyright 2019 High Fidelity, Inc. // Copyright 2019 High Fidelity, Inc.
// Copyright 2022 Overte e.V.
// //
// Distributed under the Apache License, Version 2.0. // Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@ -30,12 +31,12 @@ std::function<QThread*()> MaterialBaker::_getNextOvenWorkerThreadOperator;
static int materialNum = 0; static int materialNum = 0;
MaterialBaker::MaterialBaker(const QString& materialData, bool isURL, const QString& bakedOutputDir, QUrl destinationPath) : MaterialBaker::MaterialBaker(const QString& materialData, bool isURL, const QString& bakedOutputDir, QUrl destinationPath) :
_scriptEngine(newScriptEngine()),
_materialData(materialData), _materialData(materialData),
_isURL(isURL), _isURL(isURL),
_destinationPath(destinationPath), _destinationPath(destinationPath),
_bakedOutputDir(bakedOutputDir), _bakedOutputDir(bakedOutputDir),
_textureOutputDir(bakedOutputDir + "/materialTextures/" + QString::number(materialNum++)) _textureOutputDir(bakedOutputDir + "/materialTextures/" + QString::number(materialNum++)),
_scriptEngine(newScriptEngine())
{ {
} }

6
libraries/controllers/src/controllers/ScriptingInterface.cpp
View file

@ -41,11 +41,11 @@ bool inputControllerFromScriptValue(const ScriptValue& object, controller::Input
return true; return true;
} }
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) { STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, inputControllerToScriptValue, inputControllerFromScriptValue); scriptRegisterMetaType<controller::InputController*, inputControllerToScriptValue, inputControllerFromScriptValue>(scriptEngine);
}); }));
static QRegularExpression SANITIZE_NAME_EXPRESSION{ "[\\(\\)\\.\\s]" }; static QRegularExpression SANITIZE_NAME_EXPRESSION{ "[\\(\\)\\.\\s]" };

10
libraries/controllers/src/controllers/UserInputMapper.cpp
View file

@ -453,12 +453,12 @@ bool handFromScriptValue(const ScriptValue& object, controller::Hand& hand) {
void UserInputMapper::registerControllerTypes(ScriptEngine* engine) { void UserInputMapper::registerControllerTypes(ScriptEngine* engine) {
scriptRegisterSequenceMetaType<QVector<Action> >(engine); scriptRegisterSequenceMetaType<QVector<Action> >(engine);
scriptRegisterSequenceMetaType<Input::NamedVector>(engine); scriptRegisterSequenceMetaType<Input::NamedVector>(engine);
scriptRegisterMetaType(engine, actionToScriptValue, actionFromScriptValue); scriptRegisterMetaType<controller::Action, actionToScriptValue, actionFromScriptValue>(engine);
scriptRegisterMetaType(engine, inputToScriptValue, inputFromScriptValue); scriptRegisterMetaType<controller::Input, inputToScriptValue, inputFromScriptValue>(engine);
scriptRegisterMetaType(engine, inputPairToScriptValue, inputPairFromScriptValue); scriptRegisterMetaType<controller::Input::NamedPair, inputPairToScriptValue, inputPairFromScriptValue>(engine);
scriptRegisterMetaType(engine, handToScriptValue, handFromScriptValue); scriptRegisterMetaType<controller::Hand, handToScriptValue, handFromScriptValue>(engine);
scriptRegisterMetaType(engine, Pose::toScriptValue, Pose::fromScriptValue); scriptRegisterMetaType<Pose, Pose::toScriptValue, Pose::fromScriptValue>(engine);
} }
Input UserInputMapper::makeStandardInput(controller::StandardButtonChannel button) { Input UserInputMapper::makeStandardInput(controller::StandardButtonChannel button) {

5
libraries/entities-renderer/src/ModelScriptingInterface.cpp
View file

@ -4,6 +4,7 @@
// //
// Created by Seth Alves on 2017-1-27. // Created by Seth Alves on 2017-1-27.
// Copyright 2017 High Fidelity, Inc. // Copyright 2017 High Fidelity, Inc.
// Copyright 2022 Overte e.V.
// //
// Distributed under the Apache License, Version 2.0. // Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@ -28,8 +29,8 @@ ModelScriptingInterface::ModelScriptingInterface(QObject* parent) : QObject(pare
_modelScriptEngine = qobject_cast<ScriptManager*>(parent)->engine(); _modelScriptEngine = qobject_cast<ScriptManager*>(parent)->engine();
scriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine.get()); scriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine.get());
scriptRegisterMetaType(_modelScriptEngine.get(), meshFaceToScriptValue, meshFaceFromScriptValue); scriptRegisterMetaType<MeshFace, meshFaceToScriptValue, meshFaceFromScriptValue>(_modelScriptEngine.get());
scriptRegisterMetaType(_modelScriptEngine.get(), qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue); scriptRegisterMetaType<QVector< MeshFace >, qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue>(_modelScriptEngine.get());
} }
QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) { QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) {

10
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -54,11 +54,11 @@ void staticEntityScriptTypesInitializer(ScriptManager* manager) {
registerMetaTypes(scriptEngine); registerMetaTypes(scriptEngine);
scriptRegisterMetaType(scriptEngine, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue); scriptRegisterMetaType<EntityPropertyFlags, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly); scriptRegisterMetaType<EntityItemProperties, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly>(scriptEngine);
scriptRegisterMetaType(scriptEngine, EntityPropertyInfoToScriptValue, EntityPropertyInfoFromScriptValue); scriptRegisterMetaType<EntityPropertyInfo, EntityPropertyInfoToScriptValue, EntityPropertyInfoFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue); scriptRegisterMetaType<EntityItemID, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue); scriptRegisterMetaType<RayToEntityIntersectionResult, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue>(scriptEngine);
} }
STATIC_SCRIPT_TYPES_INITIALIZER(staticEntityScriptTypesInitializer); STATIC_SCRIPT_TYPES_INITIALIZER(staticEntityScriptTypesInitializer);

22
libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
View file

@ -326,7 +326,7 @@ namespace {
namespace scriptable { namespace scriptable {
template <typename T> int registerQPointerMetaType(ScriptEngine* engine) { template <typename T> int registerQPointerMetaType(ScriptEngine* engine) {
scriptRegisterSequenceMetaType<QVector<QPointer<T>>>(engine); scriptRegisterSequenceMetaType<QVector<QPointer<T>>>(engine);
return scriptRegisterMetaType<QPointer<T>>( return scriptRegisterMetaTypeWithLambdas<QPointer<T>>(
engine, engine,
[](ScriptEngine* engine, const QPointer<T>& object) -> ScriptValue { [](ScriptEngine* engine, const QPointer<T>& object) -> ScriptValue {
if (!object) { if (!object) {
@ -668,7 +668,7 @@ namespace scriptable {
template <typename T> int registerDebugEnum(ScriptEngine* engine, const DebugEnums<T>& debugEnums) { template <typename T> int registerDebugEnum(ScriptEngine* engine, const DebugEnums<T>& debugEnums) {
static const DebugEnums<T>& instance = debugEnums; static const DebugEnums<T>& instance = debugEnums;
return scriptRegisterMetaType<T>( return scriptRegisterMetaTypeWithLambdas<T>(
engine, engine,
[](ScriptEngine* engine, const T& topology) -> ScriptValue { [](ScriptEngine* engine, const T& topology) -> ScriptValue {
return engine->newValue(instance.value(topology)); return engine->newValue(instance.value(topology));
@ -678,6 +678,16 @@ namespace scriptable {
return true; return true;
} }
); );
//return scriptRegisterMetaType<T>(
// engine,
// [](ScriptEngine* engine, const T& topology) -> ScriptValue {
// return engine->newValue(instance.value(topology));
// },
// [](const ScriptValue& value, T& topology) -> bool {
// topology = instance.key(value.toString());
// return true;
// }
//);
} }
} }
@ -693,10 +703,10 @@ void GraphicsScriptingInterface::registerMetaTypes(ScriptEngine* engine) {
scriptable::registerDebugEnum<gpu::Semantic>(engine, gpu::SEMANTICS); scriptable::registerDebugEnum<gpu::Semantic>(engine, gpu::SEMANTICS);
scriptable::registerDebugEnum<gpu::Dimension>(engine, gpu::DIMENSIONS); scriptable::registerDebugEnum<gpu::Dimension>(engine, gpu::DIMENSIONS);
scriptRegisterMetaType(engine, scriptable::scriptableMaterialToScriptValue, scriptable::scriptableMaterialFromScriptValue); scriptRegisterMetaType<scriptable::ScriptableMaterial, scriptable::scriptableMaterialToScriptValue, scriptable::scriptableMaterialFromScriptValue>(engine);
scriptRegisterMetaType(engine, scriptable::scriptableMaterialLayerToScriptValue, scriptable::scriptableMaterialLayerFromScriptValue); scriptRegisterMetaType<scriptable::ScriptableMaterialLayer, scriptable::scriptableMaterialLayerToScriptValue, scriptable::scriptableMaterialLayerFromScriptValue>(engine);
scriptRegisterMetaType(engine, scriptable::qVectorScriptableMaterialLayerToScriptValue, scriptable::qVectorScriptableMaterialLayerFromScriptValue); scriptRegisterMetaType<QVector< scriptable::ScriptableMaterialLayer >, scriptable::qVectorScriptableMaterialLayerToScriptValue, scriptable::qVectorScriptableMaterialLayerFromScriptValue>(engine);
scriptRegisterMetaType(engine, scriptable::multiMaterialMapToScriptValue, scriptable::multiMaterialMapFromScriptValue); scriptRegisterMetaType<scriptable::MultiMaterialMap, scriptable::multiMaterialMapToScriptValue, scriptable::multiMaterialMapFromScriptValue>(engine);
Q_UNUSED(metaTypeIds); Q_UNUSED(metaTypeIds);
} }

10
libraries/script-engine/src/AssetScriptingInterface.cpp
View file

@ -4,6 +4,7 @@
// //
// Created by Stephen Birarda on 2016-03-08. // Created by Stephen Birarda on 2016-03-08.
// Copyright 2016 High Fidelity, Inc. // Copyright 2016 High Fidelity, Inc.
// Copyright 2022 Overte e.V.
// //
// Distributed under the Apache License, Version 2.0. // Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@ -34,12 +35,15 @@
#include <future> #include <future>
using Promise = MiniPromise::Promise; using Promise = MiniPromise::Promise;
STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get();
scriptRegisterMetaType<std::shared_ptr< MiniPromise >, promiseToScriptValue, promiseFromScriptValue>(scriptEngine);
}));
AssetScriptingInterface::AssetScriptingInterface(QObject* parent) : BaseAssetScriptingInterface(parent) { AssetScriptingInterface::AssetScriptingInterface(QObject* parent) : BaseAssetScriptingInterface(parent) {
qCDebug(scriptengine) << "AssetScriptingInterface::AssetScriptingInterface" << parent; qCDebug(scriptengine) << "AssetScriptingInterface::AssetScriptingInterface" << parent;
auto scriptManager = qobject_cast<ScriptManager*>(parent);
scriptRegisterMetaType(scriptManager->engine().get(), promiseToScriptValue, promiseFromScriptValue);
} }
#define JS_VERIFY(cond, error) { if (!this->jsVerify(cond, error)) { return; } } #define JS_VERIFY(cond, error) { if (!this->jsVerify(cond, error)) { return; } }

12
libraries/script-engine/src/EventTypes.cpp
View file

@ -22,10 +22,10 @@
#include "WheelEvent.h" #include "WheelEvent.h"
void registerEventTypes(ScriptEngine* engine) { void registerEventTypes(ScriptEngine* engine) {
scriptRegisterMetaType(engine, KeyEvent::toScriptValue, KeyEvent::fromScriptValue, "KeyEvent"); scriptRegisterMetaType<KeyEvent, KeyEvent::toScriptValue, KeyEvent::fromScriptValue>(engine, "KeyEvent");
scriptRegisterMetaType(engine, MouseEvent::toScriptValue, MouseEvent::fromScriptValue, "MouseEvent"); scriptRegisterMetaType<MouseEvent, MouseEvent::toScriptValue, MouseEvent::fromScriptValue>(engine, "MouseEvent");
scriptRegisterMetaType(engine, PointerEvent::toScriptValue, PointerEvent::fromScriptValue, "PointerEvent"); scriptRegisterMetaType<PointerEvent, PointerEvent::toScriptValue, PointerEvent::fromScriptValue>(engine, "PointerEvent");
scriptRegisterMetaType(engine, TouchEvent::toScriptValue, TouchEvent::fromScriptValue, "TouchEvent"); scriptRegisterMetaType<TouchEvent, TouchEvent::toScriptValue, TouchEvent::fromScriptValue>(engine, "TouchEvent");
scriptRegisterMetaType(engine, WheelEvent::toScriptValue, WheelEvent::fromScriptValue, "WheelEvent"); scriptRegisterMetaType<WheelEvent, WheelEvent::toScriptValue, WheelEvent::fromScriptValue>(engine, "WheelEvent");
scriptRegisterMetaType(engine, SpatialEvent::toScriptValue, SpatialEvent::fromScriptValue, "SpatialEvent"); scriptRegisterMetaType<SpatialEvent, SpatialEvent::toScriptValue, SpatialEvent::fromScriptValue>(engine, "SpatialEvent");
} }

2
libraries/script-engine/src/KeyEvent.cpp
View file

@ -4,6 +4,7 @@
// //
// Created by Stephen Birarda on 2014-10-27. // Created by Stephen Birarda on 2014-10-27.
// Copyright 2014 High Fidelity, Inc. // Copyright 2014 High Fidelity, Inc.
// Copyright 2022 Overte e.V.
// //
// Distributed under the Apache License, Version 2.0. // Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@ -311,5 +312,6 @@ bool KeyEvent::fromScriptValue(const ScriptValue& object, KeyEvent& event) {
<< " event.isKeypad=" << event.isKeypad << " event.isKeypad=" << event.isKeypad
<< " event.isAutoRepeat=" << event.isAutoRepeat; << " event.isAutoRepeat=" << event.isAutoRepeat;
} }
return event.isValid;
} }

2
libraries/script-engine/src/MIDIEvent.cpp
View file

@ -19,7 +19,7 @@
#include "ScriptValue.h" #include "ScriptValue.h"
void registerMIDIMetaTypes(ScriptEngine* engine) { void registerMIDIMetaTypes(ScriptEngine* engine) {
scriptRegisterMetaType(engine, midiEventToScriptValue, midiEventFromScriptValue, "MIDIEvent"); scriptRegisterMetaType<MIDIEvent, midiEventToScriptValue, midiEventFromScriptValue>(engine, "MIDIEvent");
} }
const QString MIDI_DELTA_TIME_PROP_NAME = "deltaTime"; const QString MIDI_DELTA_TIME_PROP_NAME = "deltaTime";

2
libraries/script-engine/src/MenuItemProperties.cpp
View file

@ -45,7 +45,7 @@ MenuItemProperties::MenuItemProperties(const QString& menuName, const QString& m
} }
void registerMenuItemProperties(ScriptEngine* engine) { void registerMenuItemProperties(ScriptEngine* engine) {
scriptRegisterMetaType(engine, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue, "MenuItemProperties"); scriptRegisterMetaType<MenuItemProperties, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue>(engine, "MenuItemProperties");
} }
ScriptValue menuItemPropertiesToScriptValue(ScriptEngine* engine, const MenuItemProperties& properties) { ScriptValue menuItemPropertiesToScriptValue(ScriptEngine* engine, const MenuItemProperties& properties) {

6
libraries/script-engine/src/ResourceScriptingInterface.cpp
View file

@ -17,8 +17,8 @@
#include "ScriptEngineCast.h" #include "ScriptEngineCast.h"
#include "ScriptManager.h" #include "ScriptManager.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<ScriptableResource::State>, scriptValueToEnumClass<ScriptableResource::State>, "State"); scriptRegisterMetaType<ScriptableResource::State, scriptValueFromEnumClass<ScriptableResource::State>, scriptValueToEnumClass<ScriptableResource::State> >(scriptEngine, "State");
}); }));

42
libraries/script-engine/src/ScriptEngineCast.h
View file

@ -66,8 +66,39 @@ inline QVariant scriptvalue_cast<QVariant>(const ScriptValue& value) {
return value.toVariant(); return value.toVariant();
} }
//#define MARSHAL_MACRO(FUNCTION, TYPE) +[FUNCTION](ScriptEngine* engine, const void* p) -> ScriptValue { FUNCTION(engine, *(static_cast<const TYPE*>(p)) ); }
template <typename T, ScriptValue (*f)(ScriptEngine*, const T&)>
ScriptValue toScriptValueWrapper(ScriptEngine* engine, const void *p) {
Q_ASSERT(p != NULL);
auto &src = *(reinterpret_cast<const T*>(p));
return f(engine, src);
}
template <typename T, bool (*f)(const ScriptValue&, T&)>
bool fromScriptValueWrapper(const ScriptValue& val, void* p) {
Q_ASSERT(p != NULL);
auto &dest = *(reinterpret_cast<T*>(p));
return f(val, dest);
}
template <typename T, ScriptValue (*toScriptValue)(ScriptEngine*, const T&), bool (*fromScriptValue)(const ScriptValue&, T&)>
int scriptRegisterMetaType(ScriptEngine* eng, const char* name = "",
T* = 0)
{
int id;
if (strlen(name) > 0) { // make sure it's registered
id = qRegisterMetaType<T>(name);
} else {
id = qRegisterMetaType<T>();
}
eng->registerCustomType(id, toScriptValueWrapper<T, toScriptValue>,
fromScriptValueWrapper<T, fromScriptValue>);
return id;
}
template <typename T> template <typename T>
int scriptRegisterMetaType(ScriptEngine* eng, int scriptRegisterMetaTypeWithLambdas(ScriptEngine* eng,
ScriptValue (*toScriptValue)(ScriptEngine*, const T& t), ScriptValue (*toScriptValue)(ScriptEngine*, const T& t),
bool (*fromScriptValue)(const ScriptValue&, T& t), const char* name = "", bool (*fromScriptValue)(const ScriptValue&, T& t), const char* name = "",
T* = 0) T* = 0)
@ -76,12 +107,7 @@ int scriptRegisterMetaType(ScriptEngine* eng,
if (strlen(name) > 0) { // make sure it's registered if (strlen(name) > 0) { // make sure it's registered
id = qRegisterMetaType<T>(name); id = qRegisterMetaType<T>(name);
} else { } else {
//if (!QMetaType::fromType<T>().name().isNull()) { id = qRegisterMetaType<T>();
//qDebug() << "scriptRegisterMetaType: " << QMetaType::fromType<T>().name();
//id = qRegisterMetaType<T>(QMetaType::fromType<T>().name());
//}else{
id = qRegisterMetaType<T>();
//}
} }
eng->registerCustomType(id, reinterpret_cast<ScriptEngine::MarshalFunction>(toScriptValue), eng->registerCustomType(id, reinterpret_cast<ScriptEngine::MarshalFunction>(toScriptValue),
reinterpret_cast<ScriptEngine::DemarshalFunction>(fromScriptValue)); reinterpret_cast<ScriptEngine::DemarshalFunction>(fromScriptValue));
@ -148,7 +174,7 @@ bool scriptValueToEnumClass(const ScriptValue& value, T& enumValue) {
template <typename T> template <typename T>
int scriptRegisterSequenceMetaType(ScriptEngine* engine, int scriptRegisterSequenceMetaType(ScriptEngine* engine,
T* = 0) { T* = 0) {
return scriptRegisterMetaType<T>(engine, scriptValueFromSequence, scriptValueToSequence); return scriptRegisterMetaType<T, scriptValueFromSequence, scriptValueToSequence>(engine);
} }
#endif // hifi_ScriptEngineCast_h #endif // hifi_ScriptEngineCast_h

20
libraries/script-engine/src/ScriptManager.cpp
View file

@ -233,11 +233,11 @@ int ScriptManager::processLevelMaxRetries { ScriptRequest::MAX_RETRIES };
ScriptManager::ScriptManager(Context context, const QString& scriptContents, const QString& fileNameString) : ScriptManager::ScriptManager(Context context, const QString& scriptContents, const QString& fileNameString) :
QObject(), QObject(),
_context(context), _context(context),
_engine(newScriptEngine(this)),
_scriptContents(scriptContents), _scriptContents(scriptContents),
_timerFunctionMap(), _timerFunctionMap(),
_fileNameString(fileNameString), _fileNameString(fileNameString),
_assetScriptingInterface(new AssetScriptingInterface(this)), _assetScriptingInterface(new AssetScriptingInterface(this))
_engine(newScriptEngine(this))
{ {
switch (_context) { switch (_context) {
case Context::CLIENT_SCRIPT: case Context::CLIENT_SCRIPT:
@ -647,17 +647,17 @@ void ScriptManager::initMetaTypes() {
scriptRegisterSequenceMetaType<QVector<glm::quat>>(scriptEngine); scriptRegisterSequenceMetaType<QVector<glm::quat>>(scriptEngine);
scriptRegisterSequenceMetaType<QVector<QString>>(scriptEngine); scriptRegisterSequenceMetaType<QVector<QString>>(scriptEngine);
scriptRegisterMetaType(scriptEngine, animationDetailsToScriptValue, animationDetailsFromScriptValue); scriptRegisterMetaType<AnimationDetails, animationDetailsToScriptValue, animationDetailsFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, webSocketToScriptValue, webSocketFromScriptValue); scriptRegisterMetaType<WebSocketClass*, webSocketToScriptValue, webSocketFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue); scriptRegisterMetaType<QWebSocketProtocol::CloseCode, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, wscReadyStateToScriptValue, wscReadyStateFromScriptValue); scriptRegisterMetaType<WebSocketClass::ReadyState, wscReadyStateToScriptValue, wscReadyStateFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, externalResourceBucketToScriptValue, externalResourceBucketFromScriptValue); scriptRegisterMetaType<ExternalResource::Bucket, externalResourceBucketToScriptValue, externalResourceBucketFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, scriptableResourceToScriptValue, scriptableResourceFromScriptValue); scriptRegisterMetaType<ScriptableResourceRawPtr, scriptableResourceToScriptValue, scriptableResourceFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, meshToScriptValue, meshFromScriptValue); scriptRegisterMetaType<MeshProxy*, meshToScriptValue, meshFromScriptValue>(scriptEngine);
scriptRegisterMetaType(scriptEngine, meshesToScriptValue, meshesFromScriptValue); scriptRegisterMetaType<MeshProxyList, meshesToScriptValue, meshesFromScriptValue>(scriptEngine);
} }
void ScriptManager::init() { void ScriptManager::init() {

47
libraries/script-engine/src/ScriptValueUtils.cpp
View file

@ -4,6 +4,7 @@
// //
// Created by Anthony Thibault on 4/15/16. // Created by Anthony Thibault on 4/15/16.
// Copyright 2016 High Fidelity, Inc. // Copyright 2016 High Fidelity, Inc.
// Copyright 2022 Overte e.V.
// //
// Utilities for working with QtScriptValues // Utilities for working with QtScriptValues
// //
@ -49,35 +50,35 @@ bool isListOfStrings(const ScriptValue& arg) {
} }
void registerMetaTypes(ScriptEngine* engine) { void registerMetaTypes(ScriptEngine* engine) {
scriptRegisterMetaType(engine, vec2ToScriptValue, vec2FromScriptValue); scriptRegisterMetaType<glm::vec2, vec2ToScriptValue, vec2FromScriptValue>(engine);
scriptRegisterMetaType(engine, vec3ToScriptValue, vec3FromScriptValue); scriptRegisterMetaType<glm::vec3, vec3ToScriptValue, vec3FromScriptValue>(engine);
scriptRegisterMetaType(engine, u8vec3ToScriptValue, u8vec3FromScriptValue); scriptRegisterMetaType<glm::u8vec3, u8vec3ToScriptValue, u8vec3FromScriptValue>(engine);
scriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue); scriptRegisterMetaType<glm::vec4, vec4toScriptValue, vec4FromScriptValue>(engine);
scriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue); scriptRegisterMetaType<glm::quat, quatToScriptValue, quatFromScriptValue>(engine);
scriptRegisterMetaType(engine, mat4toScriptValue, mat4FromScriptValue); scriptRegisterMetaType<glm::mat4, mat4toScriptValue, mat4FromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue); scriptRegisterMetaType<QVector< glm::vec3 >, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorQuatToScriptValue, qVectorQuatFromScriptValue); scriptRegisterMetaType<QVector< glm::quat >, qVectorQuatToScriptValue, qVectorQuatFromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorBoolToScriptValue, qVectorBoolFromScriptValue); scriptRegisterMetaType<QVector< bool >, qVectorBoolToScriptValue, qVectorBoolFromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue); scriptRegisterMetaType<QVector< float >, qVectorFloatToScriptValue, qVectorFloatFromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorIntToScriptValue, qVectorIntFromScriptValue); scriptRegisterMetaType<QVector< uint32_t >, qVectorIntToScriptValue, qVectorIntFromScriptValue>(engine);
scriptRegisterMetaType(engine, qVectorQUuidToScriptValue, qVectorQUuidFromScriptValue); scriptRegisterMetaType<QVector< QUuid >, qVectorQUuidToScriptValue, qVectorQUuidFromScriptValue>(engine);
scriptRegisterMetaType(engine, qSizeFToScriptValue, qSizeFFromScriptValue); scriptRegisterMetaType<QSizeF, qSizeFToScriptValue, qSizeFFromScriptValue>(engine);
scriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue); scriptRegisterMetaType<QRect, qRectToScriptValue, qRectFromScriptValue>(engine);
scriptRegisterMetaType(engine, qURLToScriptValue, qURLFromScriptValue); scriptRegisterMetaType<QUrl, qURLToScriptValue, qURLFromScriptValue>(engine);
scriptRegisterMetaType(engine, qColorToScriptValue, qColorFromScriptValue); scriptRegisterMetaType<QColor, qColorToScriptValue, qColorFromScriptValue>(engine);
scriptRegisterMetaType(engine, pickRayToScriptValue, pickRayFromScriptValue); scriptRegisterMetaType<PickRay, pickRayToScriptValue, pickRayFromScriptValue>(engine);
scriptRegisterMetaType(engine, collisionToScriptValue, collisionFromScriptValue); scriptRegisterMetaType<Collision, collisionToScriptValue, collisionFromScriptValue>(engine);
scriptRegisterMetaType(engine, quuidToScriptValue, quuidFromScriptValue); scriptRegisterMetaType<QUuid, quuidToScriptValue, quuidFromScriptValue>(engine);
scriptRegisterMetaType(engine, aaCubeToScriptValue, aaCubeFromScriptValue); scriptRegisterMetaType<AACube, aaCubeToScriptValue, aaCubeFromScriptValue>(engine);
scriptRegisterMetaType(engine, stencilMaskModeToScriptValue, stencilMaskModeFromScriptValue); scriptRegisterMetaType<StencilMaskMode, stencilMaskModeToScriptValue, stencilMaskModeFromScriptValue>(engine);
scriptRegisterMetaType(engine, promiseToScriptValue, promiseFromScriptValue); scriptRegisterMetaType<std::shared_ptr< MiniPromise >, promiseToScriptValue, promiseFromScriptValue>(engine);
scriptRegisterSequenceMetaType<QVector<unsigned int>>(engine); scriptRegisterSequenceMetaType<QVector<unsigned int> >(engine);
} }
ScriptValue vec2ToScriptValue(ScriptEngine* engine, const glm::vec2& vec2) { ScriptValue vec2ToScriptValue(ScriptEngine* engine, const glm::vec2& vec2) {

14
libraries/script-engine/src/qtscript/ScriptEngineQtScript_cast.cpp
View file

@ -186,13 +186,13 @@ static bool JsonArrayFromScriptValue(const ScriptValue& src, QJsonArray& dest) {
void ScriptEngineQtScript::registerSystemTypes() { void ScriptEngineQtScript::registerSystemTypes() {
qScriptRegisterMetaType(this, ScriptValueToQScriptValue, ScriptValueFromQScriptValue); qScriptRegisterMetaType(this, ScriptValueToQScriptValue, ScriptValueFromQScriptValue);
scriptRegisterMetaType(this, StringListToScriptValue, StringListFromScriptValue); scriptRegisterMetaType<QStringList, StringListToScriptValue, StringListFromScriptValue>(this);
scriptRegisterMetaType(this, VariantListToScriptValue, VariantListFromScriptValue); scriptRegisterMetaType<QVariantList, VariantListToScriptValue, VariantListFromScriptValue>(this);
scriptRegisterMetaType(this, VariantMapToScriptValue, VariantMapFromScriptValue); scriptRegisterMetaType<QVariantMap, VariantMapToScriptValue, VariantMapFromScriptValue>(this);
scriptRegisterMetaType(this, VariantHashToScriptValue, VariantHashFromScriptValue); scriptRegisterMetaType<QVariantHash, VariantHashToScriptValue, VariantHashFromScriptValue>(this);
scriptRegisterMetaType(this, JsonValueToScriptValue, JsonValueFromScriptValue); scriptRegisterMetaType<QJsonValue, JsonValueToScriptValue, JsonValueFromScriptValue>(this);
scriptRegisterMetaType(this, JsonObjectToScriptValue, JsonObjectFromScriptValue); scriptRegisterMetaType<QJsonObject, JsonObjectToScriptValue, JsonObjectFromScriptValue>(this);
scriptRegisterMetaType(this, JsonArrayToScriptValue, JsonArrayFromScriptValue); scriptRegisterMetaType<QJsonArray, JsonArrayToScriptValue, JsonArrayFromScriptValue>(this);
} }
bool ScriptEngineQtScript::castValueToVariant(const QScriptValue& val, QVariant& dest, int destTypeId) { bool ScriptEngineQtScript::castValueToVariant(const QScriptValue& val, QVariant& dest, int destTypeId) {

5
libraries/script-engine/src/qtscript/ScriptObjectQtProxy.cpp
View file

@ -77,6 +77,10 @@ QScriptValue ScriptObjectQtProxy::newQObject(ScriptEngineQtScript* engine, QObje
case ScriptEngine::AutoOwnership: case ScriptEngine::AutoOwnership:
ownsObject = !object->parent(); ownsObject = !object->parent();
break; break;
default:
ownsObject = false;
qCritical() << "Wrong ScriptEngine::ValueOwnership value: " << ownership;
break;
} }
// create the wrapper // create the wrapper
@ -312,7 +316,6 @@ QScriptValue ScriptObjectQtProxy::property(const QScriptValue& object, const QSc
int propId = id & ~TYPE_MASK; int propId = id & ~TYPE_MASK;
PropertyDefMap::const_iterator lookup = _props.find(propId); PropertyDefMap::const_iterator lookup = _props.find(propId);
if (lookup == _props.cend()) return QScriptValue(); if (lookup == _props.cend()) return QScriptValue();
const PropertyDef& propDef = lookup.value();
QMetaProperty prop = metaObject->property(propId); QMetaProperty prop = metaObject->property(propId);
ScriptValue scriptThis = ScriptValue(new ScriptValueQtWrapper(_engine, object)); ScriptValue scriptThis = ScriptValue(new ScriptValueQtWrapper(_engine, object));

6
libraries/script-engine/src/qtscript/ScriptObjectQtProxy.h
View file

@ -63,7 +63,7 @@ private: // implementation
public: // construction public: // construction
inline ScriptObjectQtProxy(ScriptEngineQtScript* engine, QObject* object, bool ownsObject, const ScriptEngine::QObjectWrapOptions& options) : inline ScriptObjectQtProxy(ScriptEngineQtScript* engine, QObject* object, bool ownsObject, const ScriptEngine::QObjectWrapOptions& options) :
QScriptClass(engine), _engine(engine), _object(object), _wrapOptions(options), _ownsObject(ownsObject) { QScriptClass(engine), _engine(engine), _wrapOptions(options), _ownsObject(ownsObject), _object(object) {
investigate(); investigate();
} }
virtual ~ScriptObjectQtProxy(); virtual ~ScriptObjectQtProxy();
@ -144,7 +144,7 @@ public: // construction
inline ScriptMethodQtProxy(ScriptEngineQtScript* engine, QObject* object, QScriptValue lifetime, inline ScriptMethodQtProxy(ScriptEngineQtScript* engine, QObject* object, QScriptValue lifetime,
const QList<QMetaMethod>& metas, int numMaxParms) : const QList<QMetaMethod>& metas, int numMaxParms) :
QScriptClass(engine), QScriptClass(engine),
_engine(engine), _object(object), _objectLifetime(lifetime), _metas(metas), _numMaxParms(numMaxParms) {} _numMaxParms(numMaxParms), _engine(engine), _object(object), _objectLifetime(lifetime), _metas(metas) {}
public: // QScriptClass implementation public: // QScriptClass implementation
virtual QString name() const override { return fullName(); } virtual QString name() const override { return fullName(); }
@ -187,7 +187,7 @@ public: // construction
_engine(engine), _object(object), _objectLifetime(lifetime), _meta(meta), _metaCallId(discoverMetaCallIdx()) {} _engine(engine), _object(object), _objectLifetime(lifetime), _meta(meta), _metaCallId(discoverMetaCallIdx()) {}
private: // implementation private: // implementation
virtual int qt_metacall(QMetaObject::Call call, int id, void** arguments); virtual int qt_metacall(QMetaObject::Call call, int id, void** arguments) override;
int discoverMetaCallIdx(); int discoverMetaCallIdx();
ConnectionList::iterator findConnection(QScriptValue thisObject, QScriptValue callback); ConnectionList::iterator findConnection(QScriptValue thisObject, QScriptValue callback);
QString fullName() const; QString fullName() const;

9
libraries/ui/src/ui/TabletScriptingInterface.cpp
View file

@ -31,13 +31,12 @@
#include "SettingHandle.h" #include "SettingHandle.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, wrapperToScriptValue<TabletProxy>, wrapperFromScriptValue<TabletProxy>); scriptRegisterMetaType<TabletProxy*, wrapperToScriptValue<TabletProxy>, wrapperFromScriptValue<TabletProxy> >(scriptEngine);
scriptRegisterMetaType(scriptEngine, scriptRegisterMetaType<TabletButtonProxy*, wrapperToScriptValue<TabletButtonProxy>, wrapperFromScriptValue<TabletButtonProxy> >(scriptEngine);
wrapperToScriptValue<TabletButtonProxy>, wrapperFromScriptValue<TabletButtonProxy>); }));
});
// FIXME move to global app properties // FIXME move to global app properties
const QString SYSTEM_TOOLBAR = "com.highfidelity.interface.toolbar.system"; const QString SYSTEM_TOOLBAR = "com.highfidelity.interface.toolbar.system";

9
libraries/ui/src/ui/ToolbarScriptingInterface.cpp
View file

@ -19,13 +19,12 @@
#include <shared/QtHelpers.h> #include <shared/QtHelpers.h>
#include "../OffscreenUi.h" #include "../OffscreenUi.h"
STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){ STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
auto scriptEngine = manager->engine().get(); auto scriptEngine = manager->engine().get();
scriptRegisterMetaType(scriptEngine, wrapperToScriptValue<ToolbarProxy>, wrapperFromScriptValue<ToolbarProxy>); scriptRegisterMetaType<ToolbarProxy*, wrapperToScriptValue<ToolbarProxy>, wrapperFromScriptValue<ToolbarProxy> >(scriptEngine);
scriptRegisterMetaType(scriptEngine, scriptRegisterMetaType<ToolbarButtonProxy*, wrapperToScriptValue<ToolbarButtonProxy>, wrapperFromScriptValue<ToolbarButtonProxy> >(scriptEngine);
wrapperToScriptValue<ToolbarButtonProxy>, wrapperFromScriptValue<ToolbarButtonProxy>); }));
});
ScriptValue toolbarToScriptValue(ScriptEngine* engine, ToolbarProxy* const &in) { ScriptValue toolbarToScriptValue(ScriptEngine* engine, ToolbarProxy* const &in) {
if (!in) { if (!in) {