From 6f321730255fab4e516fd6a41ae9ffdcf16b2ed2 Mon Sep 17 00:00:00 2001
From: ksuprynowicz <ksuprynowicz@post.pl>
Date: Fri, 19 Aug 2022 14:10:54 +0200
Subject: [PATCH] Fixes to most scripting-related warnings

---
 interface/src/LODManager.cpp                  |  6 +--
 interface/src/RefreshRateManager.cpp          |  8 ++--
 interface/src/avatar/MyAvatar.cpp             |  4 +-
 .../src/raypick/PickScriptingInterface.cpp    |  2 +-
 .../AccountServicesScriptingInterface.cpp     |  6 +--
 .../PerformanceScriptingInterface.cpp         |  8 ++--
 .../PlatformInfoScriptingInterface.cpp        |  6 +--
 .../scripting/RenderScriptingInterface.cpp    |  8 ++--
 interface/src/ui/InteractiveWindow.cpp        |  2 +-
 interface/src/ui/overlays/Overlays.cpp        |  8 ++--
 libraries/audio/src/AudioEffectOptions.cpp    |  6 +--
 .../audio/src/AudioScriptingInterface.cpp     |  4 +-
 libraries/audio/src/ScriptAudioInjector.cpp   |  6 +--
 libraries/avatars/src/AvatarData.cpp          |  8 ++--
 libraries/avatars/src/ScriptAvatarData.cpp    |  6 +--
 libraries/baking/src/MaterialBaker.cpp        |  5 +-
 .../src/controllers/ScriptingInterface.cpp    |  6 +--
 .../src/controllers/UserInputMapper.cpp       | 10 ++--
 .../src/ModelScriptingInterface.cpp           |  5 +-
 .../entities/src/EntityScriptingInterface.cpp | 10 ++--
 .../GraphicsScriptingInterface.cpp            | 22 ++++++---
 .../src/AssetScriptingInterface.cpp           | 10 ++--
 libraries/script-engine/src/EventTypes.cpp    | 12 ++---
 libraries/script-engine/src/KeyEvent.cpp      |  2 +
 libraries/script-engine/src/MIDIEvent.cpp     |  2 +-
 .../script-engine/src/MenuItemProperties.cpp  |  2 +-
 .../src/ResourceScriptingInterface.cpp        |  6 +--
 .../script-engine/src/ScriptEngineCast.h      | 42 +++++++++++++----
 libraries/script-engine/src/ScriptManager.cpp | 20 ++++----
 .../script-engine/src/ScriptValueUtils.cpp    | 47 ++++++++++---------
 .../qtscript/ScriptEngineQtScript_cast.cpp    | 14 +++---
 .../src/qtscript/ScriptObjectQtProxy.cpp      |  5 +-
 .../src/qtscript/ScriptObjectQtProxy.h        |  6 +--
 .../ui/src/ui/TabletScriptingInterface.cpp    |  9 ++--
 .../ui/src/ui/ToolbarScriptingInterface.cpp   |  9 ++--
 35 files changed, 189 insertions(+), 143 deletions(-)

diff --git a/interface/src/LODManager.cpp b/interface/src/LODManager.cpp
index 26f0ea5293..16b62af6fc 100644
--- a/interface/src/LODManager.cpp
+++ b/interface/src/LODManager.cpp
@@ -22,11 +22,11 @@
 #include "ui/DialogsManager.h"
 #include "InterfaceLogging.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, worldDetailQualityToScriptValue, worldDetailQualityFromScriptValue);
-});
+    scriptRegisterMetaType<WorldDetailQuality, worldDetailQualityToScriptValue, worldDetailQualityFromScriptValue>(scriptEngine);
+}));
 
 const QString LOD_SETTINGS_PREFIX { "lodManager/" };
 
diff --git a/interface/src/RefreshRateManager.cpp b/interface/src/RefreshRateManager.cpp
index ec8c9c3b78..ab652159d5 100644
--- a/interface/src/RefreshRateManager.cpp
+++ b/interface/src/RefreshRateManager.cpp
@@ -17,13 +17,13 @@
 #include <ScriptEngineCast.h>
 #include <ScriptManager.h>
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     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){
     auto scriptEngine = manager->engine().get();
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 4748053196..a29246650f 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -452,8 +452,8 @@ void MyAvatar::enableHandTouchForID(const QUuid& entityID) {
 }
 
 void MyAvatar::registerMetaTypes(ScriptEnginePointer engine) {
-    scriptRegisterMetaType(engine.get(), audioListenModeToScriptValue, audioListenModeFromScriptValue);
-    scriptRegisterMetaType(engine.get(), driveKeysToScriptValue, driveKeysFromScriptValue);
+    scriptRegisterMetaType<AudioListenerMode, audioListenModeToScriptValue, audioListenModeFromScriptValue>(engine.get());
+    scriptRegisterMetaType<MyAvatar::DriveKeys, driveKeysToScriptValue, driveKeysFromScriptValue>(engine.get());
 }
 
 void MyAvatar::registerProperties(ScriptEnginePointer engine) {
diff --git a/interface/src/raypick/PickScriptingInterface.cpp b/interface/src/raypick/PickScriptingInterface.cpp
index afaff075f5..1365ef0aa2 100644
--- a/interface/src/raypick/PickScriptingInterface.cpp
+++ b/interface/src/raypick/PickScriptingInterface.cpp
@@ -464,7 +464,7 @@ bool pickTypesFromScriptValue(const ScriptValue& object, PickQuery::PickType& pi
 }
 
 void PickScriptingInterface::registerMetaTypes(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, pickTypesToScriptValue, pickTypesFromScriptValue);
+    scriptRegisterMetaType<PickQuery::PickType, pickTypesToScriptValue, pickTypesFromScriptValue>(engine);
 }
 
 void PickScriptingInterface::registerProperties(ScriptEngine* engine) {
diff --git a/interface/src/scripting/AccountServicesScriptingInterface.cpp b/interface/src/scripting/AccountServicesScriptingInterface.cpp
index 051581a7ae..48a8189639 100644
--- a/interface/src/scripting/AccountServicesScriptingInterface.cpp
+++ b/interface/src/scripting/AccountServicesScriptingInterface.cpp
@@ -19,11 +19,11 @@
 #include "DiscoverabilityManager.h"
 #include "ResourceCache.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, DownloadInfoResultToScriptValue, DownloadInfoResultFromScriptValue);
-});
+    scriptRegisterMetaType<DownloadInfoResult, DownloadInfoResultToScriptValue, DownloadInfoResultFromScriptValue>(scriptEngine);
+}));
 
 AccountServicesScriptingInterface::AccountServicesScriptingInterface() {
     auto accountManager = DependencyManager::get<AccountManager>();
diff --git a/interface/src/scripting/PerformanceScriptingInterface.cpp b/interface/src/scripting/PerformanceScriptingInterface.cpp
index 2b7cc6f89b..82d2606401 100644
--- a/interface/src/scripting/PerformanceScriptingInterface.cpp
+++ b/interface/src/scripting/PerformanceScriptingInterface.cpp
@@ -14,12 +14,12 @@
 
 #include "../Application.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<PerformanceScriptingInterface::PerformancePreset>, scriptValueToEnumClass<PerformanceScriptingInterface::PerformancePreset>, "PerformancePreset");
-    scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, scriptValueToEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, "RefreshRateProfile");
-});
+    scriptRegisterMetaType<PerformanceScriptingInterface::PerformancePreset, scriptValueFromEnumClass<PerformanceScriptingInterface::PerformancePreset>, scriptValueToEnumClass<PerformanceScriptingInterface::PerformancePreset> >(scriptEngine, "PerformancePreset");
+    scriptRegisterMetaType<PerformanceScriptingInterface::RefreshRateProfile, scriptValueFromEnumClass<PerformanceScriptingInterface::RefreshRateProfile>, scriptValueToEnumClass<PerformanceScriptingInterface::RefreshRateProfile> >(scriptEngine, "RefreshRateProfile");
+}));
 
 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
diff --git a/interface/src/scripting/PlatformInfoScriptingInterface.cpp b/interface/src/scripting/PlatformInfoScriptingInterface.cpp
index 85fb4f15d9..c9a6c5b31a 100644
--- a/interface/src/scripting/PlatformInfoScriptingInterface.cpp
+++ b/interface/src/scripting/PlatformInfoScriptingInterface.cpp
@@ -21,11 +21,11 @@
 #include <sstream>
 #endif
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     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){
     auto scriptEngine = manager->engine().get();
diff --git a/interface/src/scripting/RenderScriptingInterface.cpp b/interface/src/scripting/RenderScriptingInterface.cpp
index 5867466335..db8a5fdf57 100644
--- a/interface/src/scripting/RenderScriptingInterface.cpp
+++ b/interface/src/scripting/RenderScriptingInterface.cpp
@@ -14,12 +14,12 @@
 #include <QScreen>
 #include "ScreenName.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod>, "RenderMethod");
-    scriptRegisterMetaType(scriptEngine, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode>, "Mode");
-});
+    scriptRegisterMetaType<RenderScriptingInterface::RenderMethod, scriptValueFromEnumClass<RenderScriptingInterface::RenderMethod>, scriptValueToEnumClass<RenderScriptingInterface::RenderMethod> >(scriptEngine, "RenderMethod");
+    scriptRegisterMetaType<AntialiasingConfig::Mode, scriptValueFromEnumClass<AntialiasingConfig::Mode>, scriptValueToEnumClass<AntialiasingConfig::Mode> >(scriptEngine, "Mode");
+}));
 
 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
diff --git a/interface/src/ui/InteractiveWindow.cpp b/interface/src/ui/InteractiveWindow.cpp
index bca8f9c0fc..fd171c497b 100644
--- a/interface/src/ui/InteractiveWindow.cpp
+++ b/interface/src/ui/InteractiveWindow.cpp
@@ -101,7 +101,7 @@ static void dockWidgetDeleter(DockWidget* dockWidget) {
 }
 
 void registerInteractiveWindowMetaType(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, interactiveWindowPointerToScriptValue, interactiveWindowPointerFromScriptValue);
+    scriptRegisterMetaType<InteractiveWindowPointer, interactiveWindowPointerToScriptValue, interactiveWindowPointerFromScriptValue>(engine);
 }
 
 ScriptValue interactiveWindowPointerToScriptValue(ScriptEngine* engine, const InteractiveWindowPointer& in) {
diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index 9268c17c88..299a5a26a3 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -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::_overlayToEntityTypes;
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, RayToOverlayIntersectionResultToScriptValue,
-                            RayToOverlayIntersectionResultFromScriptValue);
-});
+    scriptRegisterMetaType<RayToOverlayIntersectionResult, RayToOverlayIntersectionResultToScriptValue,
+                            RayToOverlayIntersectionResultFromScriptValue>(scriptEngine);
+}));
 
 Overlays::Overlays() : _scriptEngine(newScriptEngine()) {
     ADD_TYPE_MAP(Box, cube);
diff --git a/libraries/audio/src/AudioEffectOptions.cpp b/libraries/audio/src/AudioEffectOptions.cpp
index b6b722b324..abed1a08f9 100644
--- a/libraries/audio/src/AudioEffectOptions.cpp
+++ b/libraries/audio/src/AudioEffectOptions.cpp
@@ -17,11 +17,11 @@
 #include <ScriptValue.h>
 #include <ScriptEngineCast.h>
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) {
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, audioEffectOptionsToScriptValue, audioEffectOptionsFromScriptValue);
-});
+    scriptRegisterMetaType<AudioEffectOptions, audioEffectOptionsToScriptValue, audioEffectOptionsFromScriptValue>(scriptEngine);
+}));
 
 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
diff --git a/libraries/audio/src/AudioScriptingInterface.cpp b/libraries/audio/src/AudioScriptingInterface.cpp
index 96bdcfbf71..e780d56756 100644
--- a/libraries/audio/src/AudioScriptingInterface.cpp
+++ b/libraries/audio/src/AudioScriptingInterface.cpp
@@ -35,8 +35,8 @@ STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager){
 });
 
 void registerAudioMetaTypes(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, injectorOptionsToScriptValue, injectorOptionsFromScriptValue);
-    scriptRegisterMetaType(engine, soundSharedPointerToScriptValue, soundSharedPointerFromScriptValue);
+    scriptRegisterMetaType<AudioInjectorOptions, injectorOptionsToScriptValue, injectorOptionsFromScriptValue>(engine);
+    scriptRegisterMetaType<SharedSoundPointer, soundSharedPointerToScriptValue, soundSharedPointerFromScriptValue>(engine);
 }
 
 
diff --git a/libraries/audio/src/ScriptAudioInjector.cpp b/libraries/audio/src/ScriptAudioInjector.cpp
index 30f84de839..eb1cb1dd0a 100644
--- a/libraries/audio/src/ScriptAudioInjector.cpp
+++ b/libraries/audio/src/ScriptAudioInjector.cpp
@@ -18,11 +18,11 @@
 #include <ScriptManager.h>
 #include <ScriptValue.h>
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) {
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, injectorToScriptValue, injectorFromScriptValue);
-});
+    scriptRegisterMetaType<ScriptAudioInjector*, injectorToScriptValue, injectorFromScriptValue>(scriptEngine);
+}));
 
 ScriptValue injectorToScriptValue(ScriptEngine* engine, ScriptAudioInjector* const& in) {
     // The AudioScriptingInterface::playSound method can return null, so we need to account for that.
diff --git a/libraries/avatars/src/AvatarData.cpp b/libraries/avatars/src/AvatarData.cpp
index 8035b0b291..ec1735ab37 100644
--- a/libraries/avatars/src/AvatarData.cpp
+++ b/libraries/avatars/src/AvatarData.cpp
@@ -69,13 +69,13 @@ static const float DEFAULT_AVATAR_DENSITY = 1000.0f; // density of water
 
 #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();
 
     registerAvatarTypes(scriptEngine);
-    scriptRegisterMetaType(scriptEngine, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, AvatarEntityMapToScriptValue, AvatarEntityMapFromScriptValue);
-});
+    scriptRegisterMetaType<RayToAvatarIntersectionResult, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<AvatarEntityMap, AvatarEntityMapToScriptValue, AvatarEntityMapFromScriptValue>(scriptEngine);
+}));
 
 STATIC_SCRIPT_INITIALIZER(+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
diff --git a/libraries/avatars/src/ScriptAvatarData.cpp b/libraries/avatars/src/ScriptAvatarData.cpp
index 717aa19278..0ca1143aa7 100644
--- a/libraries/avatars/src/ScriptAvatarData.cpp
+++ b/libraries/avatars/src/ScriptAvatarData.cpp
@@ -26,11 +26,11 @@ bool avatarDataFromScriptValue(const ScriptValue& object, ScriptAvatarData*& out
     return false;
 }
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) {
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, avatarDataToScriptValue, avatarDataFromScriptValue);
-});
+    scriptRegisterMetaType<ScriptAvatarData*, avatarDataToScriptValue, avatarDataFromScriptValue>(scriptEngine);
+}));
 
 ScriptAvatarData::ScriptAvatarData(AvatarSharedPointer avatarData) :
     _avatarData(avatarData)
diff --git a/libraries/baking/src/MaterialBaker.cpp b/libraries/baking/src/MaterialBaker.cpp
index 68ca7316c4..9db9c8a00a 100644
--- a/libraries/baking/src/MaterialBaker.cpp
+++ b/libraries/baking/src/MaterialBaker.cpp
@@ -4,6 +4,7 @@
 //
 //  Created by Sam Gondelman on 2/26/2019
 //  Copyright 2019 High Fidelity, Inc.
+//  Copyright 2022 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
@@ -30,12 +31,12 @@ std::function<QThread*()> MaterialBaker::_getNextOvenWorkerThreadOperator;
 static int materialNum = 0;
 
 MaterialBaker::MaterialBaker(const QString& materialData, bool isURL, const QString& bakedOutputDir, QUrl destinationPath) :
-    _scriptEngine(newScriptEngine()),
     _materialData(materialData),
     _isURL(isURL),
     _destinationPath(destinationPath),
     _bakedOutputDir(bakedOutputDir),
-    _textureOutputDir(bakedOutputDir + "/materialTextures/" + QString::number(materialNum++))
+    _textureOutputDir(bakedOutputDir + "/materialTextures/" + QString::number(materialNum++)),
+    _scriptEngine(newScriptEngine())
 {
 }
 
diff --git a/libraries/controllers/src/controllers/ScriptingInterface.cpp b/libraries/controllers/src/controllers/ScriptingInterface.cpp
index cb5c18a5f9..6884552762 100644
--- a/libraries/controllers/src/controllers/ScriptingInterface.cpp
+++ b/libraries/controllers/src/controllers/ScriptingInterface.cpp
@@ -41,11 +41,11 @@ bool inputControllerFromScriptValue(const ScriptValue& object, controller::Input
     return true;
 }
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager) {
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager) {
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, inputControllerToScriptValue, inputControllerFromScriptValue);
-});
+    scriptRegisterMetaType<controller::InputController*, inputControllerToScriptValue, inputControllerFromScriptValue>(scriptEngine);
+}));
 
 static QRegularExpression SANITIZE_NAME_EXPRESSION{ "[\\(\\)\\.\\s]" };
 
diff --git a/libraries/controllers/src/controllers/UserInputMapper.cpp b/libraries/controllers/src/controllers/UserInputMapper.cpp
index cc62f584fa..eb3ca38aa6 100644
--- a/libraries/controllers/src/controllers/UserInputMapper.cpp
+++ b/libraries/controllers/src/controllers/UserInputMapper.cpp
@@ -453,12 +453,12 @@ bool handFromScriptValue(const ScriptValue& object, controller::Hand& hand) {
 void UserInputMapper::registerControllerTypes(ScriptEngine* engine) {
     scriptRegisterSequenceMetaType<QVector<Action> >(engine);
     scriptRegisterSequenceMetaType<Input::NamedVector>(engine);
-    scriptRegisterMetaType(engine, actionToScriptValue, actionFromScriptValue);
-    scriptRegisterMetaType(engine, inputToScriptValue, inputFromScriptValue);
-    scriptRegisterMetaType(engine, inputPairToScriptValue, inputPairFromScriptValue);
-    scriptRegisterMetaType(engine, handToScriptValue, handFromScriptValue);
+    scriptRegisterMetaType<controller::Action, actionToScriptValue, actionFromScriptValue>(engine);
+    scriptRegisterMetaType<controller::Input, inputToScriptValue, inputFromScriptValue>(engine);
+    scriptRegisterMetaType<controller::Input::NamedPair, inputPairToScriptValue, inputPairFromScriptValue>(engine);
+    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) {
diff --git a/libraries/entities-renderer/src/ModelScriptingInterface.cpp b/libraries/entities-renderer/src/ModelScriptingInterface.cpp
index 0b152b56c5..696c5c73f4 100644
--- a/libraries/entities-renderer/src/ModelScriptingInterface.cpp
+++ b/libraries/entities-renderer/src/ModelScriptingInterface.cpp
@@ -4,6 +4,7 @@
 //
 //  Created by Seth Alves on 2017-1-27.
 //  Copyright 2017 High Fidelity, Inc.
+//  Copyright 2022 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
@@ -28,8 +29,8 @@ ModelScriptingInterface::ModelScriptingInterface(QObject* parent) : QObject(pare
     _modelScriptEngine = qobject_cast<ScriptManager*>(parent)->engine();
 
     scriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine.get());
-    scriptRegisterMetaType(_modelScriptEngine.get(), meshFaceToScriptValue, meshFaceFromScriptValue);
-    scriptRegisterMetaType(_modelScriptEngine.get(), qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue);
+    scriptRegisterMetaType<MeshFace, meshFaceToScriptValue, meshFaceFromScriptValue>(_modelScriptEngine.get());
+    scriptRegisterMetaType<QVector< MeshFace >, qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue>(_modelScriptEngine.get());
 }
 
 QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) {
diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp
index 38361f757d..e62625f8ab 100644
--- a/libraries/entities/src/EntityScriptingInterface.cpp
+++ b/libraries/entities/src/EntityScriptingInterface.cpp
@@ -54,11 +54,11 @@ void staticEntityScriptTypesInitializer(ScriptManager* manager) {
 
     registerMetaTypes(scriptEngine);
 
-    scriptRegisterMetaType(scriptEngine, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);
-    scriptRegisterMetaType(scriptEngine, EntityPropertyInfoToScriptValue, EntityPropertyInfoFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);
-    scriptRegisterMetaType(scriptEngine, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue);
+    scriptRegisterMetaType<EntityPropertyFlags, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<EntityItemProperties, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly>(scriptEngine);
+    scriptRegisterMetaType<EntityPropertyInfo, EntityPropertyInfoToScriptValue, EntityPropertyInfoFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<EntityItemID, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<RayToEntityIntersectionResult, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue>(scriptEngine);
 }
 STATIC_SCRIPT_TYPES_INITIALIZER(staticEntityScriptTypesInitializer);
 
diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
index 586a22e48f..efd85b657e 100644
--- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
+++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
@@ -326,7 +326,7 @@ namespace {
 namespace scriptable {
     template <typename T> int registerQPointerMetaType(ScriptEngine* engine) {
         scriptRegisterSequenceMetaType<QVector<QPointer<T>>>(engine);
-        return scriptRegisterMetaType<QPointer<T>>(
+        return scriptRegisterMetaTypeWithLambdas<QPointer<T>>(
             engine,
             [](ScriptEngine* engine, const QPointer<T>& object) -> ScriptValue {
                 if (!object) {
@@ -668,7 +668,7 @@ namespace scriptable {
 
     template <typename T> int registerDebugEnum(ScriptEngine* engine, const DebugEnums<T>& debugEnums) {
         static const DebugEnums<T>& instance = debugEnums;
-        return scriptRegisterMetaType<T>(
+        return scriptRegisterMetaTypeWithLambdas<T>(
             engine,
             [](ScriptEngine* engine, const T& topology) -> ScriptValue {
                 return engine->newValue(instance.value(topology));
@@ -678,6 +678,16 @@ namespace scriptable {
                 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::Dimension>(engine, gpu::DIMENSIONS);
 
-    scriptRegisterMetaType(engine, scriptable::scriptableMaterialToScriptValue, scriptable::scriptableMaterialFromScriptValue);
-    scriptRegisterMetaType(engine, scriptable::scriptableMaterialLayerToScriptValue, scriptable::scriptableMaterialLayerFromScriptValue);
-    scriptRegisterMetaType(engine, scriptable::qVectorScriptableMaterialLayerToScriptValue, scriptable::qVectorScriptableMaterialLayerFromScriptValue);
-    scriptRegisterMetaType(engine, scriptable::multiMaterialMapToScriptValue, scriptable::multiMaterialMapFromScriptValue);
+    scriptRegisterMetaType<scriptable::ScriptableMaterial, scriptable::scriptableMaterialToScriptValue, scriptable::scriptableMaterialFromScriptValue>(engine);
+    scriptRegisterMetaType<scriptable::ScriptableMaterialLayer, scriptable::scriptableMaterialLayerToScriptValue, scriptable::scriptableMaterialLayerFromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< scriptable::ScriptableMaterialLayer >, scriptable::qVectorScriptableMaterialLayerToScriptValue, scriptable::qVectorScriptableMaterialLayerFromScriptValue>(engine);
+    scriptRegisterMetaType<scriptable::MultiMaterialMap, scriptable::multiMaterialMapToScriptValue, scriptable::multiMaterialMapFromScriptValue>(engine);
 
     Q_UNUSED(metaTypeIds);
 }
diff --git a/libraries/script-engine/src/AssetScriptingInterface.cpp b/libraries/script-engine/src/AssetScriptingInterface.cpp
index 99ef12ab62..5231223eb5 100644
--- a/libraries/script-engine/src/AssetScriptingInterface.cpp
+++ b/libraries/script-engine/src/AssetScriptingInterface.cpp
@@ -4,6 +4,7 @@
 //
 //  Created by Stephen Birarda on 2016-03-08.
 //  Copyright 2016 High Fidelity, Inc.
+//  Copyright 2022 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
@@ -34,12 +35,15 @@
 #include <future>
 
 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) {
     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; } }
diff --git a/libraries/script-engine/src/EventTypes.cpp b/libraries/script-engine/src/EventTypes.cpp
index e4083f2b80..4990067f2a 100644
--- a/libraries/script-engine/src/EventTypes.cpp
+++ b/libraries/script-engine/src/EventTypes.cpp
@@ -22,10 +22,10 @@
 #include "WheelEvent.h"
 
 void registerEventTypes(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, KeyEvent::toScriptValue, KeyEvent::fromScriptValue, "KeyEvent");
-    scriptRegisterMetaType(engine, MouseEvent::toScriptValue, MouseEvent::fromScriptValue, "MouseEvent");
-    scriptRegisterMetaType(engine, PointerEvent::toScriptValue, PointerEvent::fromScriptValue, "PointerEvent");
-    scriptRegisterMetaType(engine, TouchEvent::toScriptValue, TouchEvent::fromScriptValue, "TouchEvent");
-    scriptRegisterMetaType(engine, WheelEvent::toScriptValue, WheelEvent::fromScriptValue, "WheelEvent");
-    scriptRegisterMetaType(engine, SpatialEvent::toScriptValue, SpatialEvent::fromScriptValue, "SpatialEvent");
+    scriptRegisterMetaType<KeyEvent, KeyEvent::toScriptValue, KeyEvent::fromScriptValue>(engine, "KeyEvent");
+    scriptRegisterMetaType<MouseEvent, MouseEvent::toScriptValue, MouseEvent::fromScriptValue>(engine, "MouseEvent");
+    scriptRegisterMetaType<PointerEvent, PointerEvent::toScriptValue, PointerEvent::fromScriptValue>(engine, "PointerEvent");
+    scriptRegisterMetaType<TouchEvent, TouchEvent::toScriptValue, TouchEvent::fromScriptValue>(engine, "TouchEvent");
+    scriptRegisterMetaType<WheelEvent, WheelEvent::toScriptValue, WheelEvent::fromScriptValue>(engine, "WheelEvent");
+    scriptRegisterMetaType<SpatialEvent, SpatialEvent::toScriptValue, SpatialEvent::fromScriptValue>(engine, "SpatialEvent");
 }
diff --git a/libraries/script-engine/src/KeyEvent.cpp b/libraries/script-engine/src/KeyEvent.cpp
index 1c60ba7e1e..3453731a2f 100644
--- a/libraries/script-engine/src/KeyEvent.cpp
+++ b/libraries/script-engine/src/KeyEvent.cpp
@@ -4,6 +4,7 @@
 //
 //  Created by Stephen Birarda on 2014-10-27.
 //  Copyright 2014 High Fidelity, Inc.
+//  Copyright 2022 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
@@ -311,5 +312,6 @@ bool KeyEvent::fromScriptValue(const ScriptValue& object, KeyEvent& event) {
         << " event.isKeypad=" << event.isKeypad
         << " event.isAutoRepeat=" << event.isAutoRepeat;
     }
+    return event.isValid;
 }
 
diff --git a/libraries/script-engine/src/MIDIEvent.cpp b/libraries/script-engine/src/MIDIEvent.cpp
index 361877d80c..f7a6ec3382 100644
--- a/libraries/script-engine/src/MIDIEvent.cpp
+++ b/libraries/script-engine/src/MIDIEvent.cpp
@@ -19,7 +19,7 @@
 #include "ScriptValue.h"
 
 void registerMIDIMetaTypes(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, midiEventToScriptValue, midiEventFromScriptValue, "MIDIEvent");
+    scriptRegisterMetaType<MIDIEvent, midiEventToScriptValue, midiEventFromScriptValue>(engine, "MIDIEvent");
 }
 
 const QString MIDI_DELTA_TIME_PROP_NAME = "deltaTime";
diff --git a/libraries/script-engine/src/MenuItemProperties.cpp b/libraries/script-engine/src/MenuItemProperties.cpp
index f2f335253b..9b30c4a33e 100644
--- a/libraries/script-engine/src/MenuItemProperties.cpp
+++ b/libraries/script-engine/src/MenuItemProperties.cpp
@@ -45,7 +45,7 @@ MenuItemProperties::MenuItemProperties(const QString& menuName, const QString& m
 }
 
 void registerMenuItemProperties(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue, "MenuItemProperties");
+    scriptRegisterMetaType<MenuItemProperties, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue>(engine, "MenuItemProperties");
 }
 
 ScriptValue menuItemPropertiesToScriptValue(ScriptEngine* engine, const MenuItemProperties& properties) {
diff --git a/libraries/script-engine/src/ResourceScriptingInterface.cpp b/libraries/script-engine/src/ResourceScriptingInterface.cpp
index 1adbb85392..f39f3fa6c7 100644
--- a/libraries/script-engine/src/ResourceScriptingInterface.cpp
+++ b/libraries/script-engine/src/ResourceScriptingInterface.cpp
@@ -17,8 +17,8 @@
 #include "ScriptEngineCast.h"
 #include "ScriptManager.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     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");
+}));
diff --git a/libraries/script-engine/src/ScriptEngineCast.h b/libraries/script-engine/src/ScriptEngineCast.h
index a75b635b4b..f8ca6c411a 100644
--- a/libraries/script-engine/src/ScriptEngineCast.h
+++ b/libraries/script-engine/src/ScriptEngineCast.h
@@ -66,8 +66,39 @@ inline QVariant scriptvalue_cast<QVariant>(const ScriptValue& value) {
     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>
-int scriptRegisterMetaType(ScriptEngine* eng,
+int scriptRegisterMetaTypeWithLambdas(ScriptEngine* eng,
                            ScriptValue (*toScriptValue)(ScriptEngine*, const T& t),
                            bool (*fromScriptValue)(const ScriptValue&, T& t), const char* name = "",
                            T* = 0)
@@ -76,12 +107,7 @@ int scriptRegisterMetaType(ScriptEngine* eng,
     if (strlen(name) > 0) { // make sure it's registered
         id = qRegisterMetaType<T>(name);
     } else {
-        //if (!QMetaType::fromType<T>().name().isNull()) {
-            //qDebug() << "scriptRegisterMetaType: " << QMetaType::fromType<T>().name();
-            //id = qRegisterMetaType<T>(QMetaType::fromType<T>().name());
-        //}else{
-            id = qRegisterMetaType<T>();
-        //}
+        id = qRegisterMetaType<T>();
     }
     eng->registerCustomType(id, reinterpret_cast<ScriptEngine::MarshalFunction>(toScriptValue),
                             reinterpret_cast<ScriptEngine::DemarshalFunction>(fromScriptValue));
@@ -148,7 +174,7 @@ bool scriptValueToEnumClass(const ScriptValue& value, T& enumValue) {
 template <typename T>
 int scriptRegisterSequenceMetaType(ScriptEngine* engine,
                                    T* = 0) {
-    return scriptRegisterMetaType<T>(engine, scriptValueFromSequence, scriptValueToSequence);
+    return scriptRegisterMetaType<T, scriptValueFromSequence, scriptValueToSequence>(engine);
 }
 
 #endif // hifi_ScriptEngineCast_h
diff --git a/libraries/script-engine/src/ScriptManager.cpp b/libraries/script-engine/src/ScriptManager.cpp
index 93c547277b..a5a5e21b96 100644
--- a/libraries/script-engine/src/ScriptManager.cpp
+++ b/libraries/script-engine/src/ScriptManager.cpp
@@ -233,11 +233,11 @@ int ScriptManager::processLevelMaxRetries { ScriptRequest::MAX_RETRIES };
 ScriptManager::ScriptManager(Context context, const QString& scriptContents, const QString& fileNameString) :
     QObject(),
     _context(context),
+    _engine(newScriptEngine(this)),
     _scriptContents(scriptContents),
     _timerFunctionMap(),
     _fileNameString(fileNameString),
-    _assetScriptingInterface(new AssetScriptingInterface(this)),
-    _engine(newScriptEngine(this))
+    _assetScriptingInterface(new AssetScriptingInterface(this))
 {
     switch (_context) {
         case Context::CLIENT_SCRIPT:
@@ -647,17 +647,17 @@ void ScriptManager::initMetaTypes() {
     scriptRegisterSequenceMetaType<QVector<glm::quat>>(scriptEngine);
     scriptRegisterSequenceMetaType<QVector<QString>>(scriptEngine);
     
-    scriptRegisterMetaType(scriptEngine, animationDetailsToScriptValue, animationDetailsFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, webSocketToScriptValue, webSocketFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue);
-    scriptRegisterMetaType(scriptEngine, wscReadyStateToScriptValue, wscReadyStateFromScriptValue);
+    scriptRegisterMetaType<AnimationDetails, animationDetailsToScriptValue, animationDetailsFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<WebSocketClass*, webSocketToScriptValue, webSocketFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<QWebSocketProtocol::CloseCode, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue>(scriptEngine);
+    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(scriptEngine, meshesToScriptValue, meshesFromScriptValue);
+    scriptRegisterMetaType<MeshProxy*, meshToScriptValue, meshFromScriptValue>(scriptEngine);
+    scriptRegisterMetaType<MeshProxyList, meshesToScriptValue, meshesFromScriptValue>(scriptEngine);
 }
 
 void ScriptManager::init() {
diff --git a/libraries/script-engine/src/ScriptValueUtils.cpp b/libraries/script-engine/src/ScriptValueUtils.cpp
index e428c06bff..e22e59829b 100644
--- a/libraries/script-engine/src/ScriptValueUtils.cpp
+++ b/libraries/script-engine/src/ScriptValueUtils.cpp
@@ -4,6 +4,7 @@
 //
 //  Created by Anthony Thibault on 4/15/16.
 //  Copyright 2016 High Fidelity, Inc.
+//  Copyright 2022 Overte e.V.
 //
 //  Utilities for working with QtScriptValues
 //
@@ -49,35 +50,35 @@ bool isListOfStrings(const ScriptValue& arg) {
 }
 
 void registerMetaTypes(ScriptEngine* engine) {
-    scriptRegisterMetaType(engine, vec2ToScriptValue, vec2FromScriptValue);
-    scriptRegisterMetaType(engine, vec3ToScriptValue, vec3FromScriptValue);
-    scriptRegisterMetaType(engine, u8vec3ToScriptValue, u8vec3FromScriptValue);
-    scriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue);
-    scriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
-    scriptRegisterMetaType(engine, mat4toScriptValue, mat4FromScriptValue);
+    scriptRegisterMetaType<glm::vec2, vec2ToScriptValue, vec2FromScriptValue>(engine);
+    scriptRegisterMetaType<glm::vec3, vec3ToScriptValue, vec3FromScriptValue>(engine);
+    scriptRegisterMetaType<glm::u8vec3, u8vec3ToScriptValue, u8vec3FromScriptValue>(engine);
+    scriptRegisterMetaType<glm::vec4, vec4toScriptValue, vec4FromScriptValue>(engine);
+    scriptRegisterMetaType<glm::quat, quatToScriptValue, quatFromScriptValue>(engine);
+    scriptRegisterMetaType<glm::mat4, mat4toScriptValue, mat4FromScriptValue>(engine);
 
-    scriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue);
-    scriptRegisterMetaType(engine, qVectorQuatToScriptValue, qVectorQuatFromScriptValue);
-    scriptRegisterMetaType(engine, qVectorBoolToScriptValue, qVectorBoolFromScriptValue);
-    scriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue);
-    scriptRegisterMetaType(engine, qVectorIntToScriptValue, qVectorIntFromScriptValue);
-    scriptRegisterMetaType(engine, qVectorQUuidToScriptValue, qVectorQUuidFromScriptValue);
+    scriptRegisterMetaType<QVector< glm::vec3 >, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< glm::quat >, qVectorQuatToScriptValue, qVectorQuatFromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< bool >, qVectorBoolToScriptValue, qVectorBoolFromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< float >, qVectorFloatToScriptValue, qVectorFloatFromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< uint32_t >, qVectorIntToScriptValue, qVectorIntFromScriptValue>(engine);
+    scriptRegisterMetaType<QVector< QUuid >, qVectorQUuidToScriptValue, qVectorQUuidFromScriptValue>(engine);
 
-    scriptRegisterMetaType(engine, qSizeFToScriptValue, qSizeFFromScriptValue);
-    scriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
-    scriptRegisterMetaType(engine, qURLToScriptValue, qURLFromScriptValue);
-    scriptRegisterMetaType(engine, qColorToScriptValue, qColorFromScriptValue);
+    scriptRegisterMetaType<QSizeF, qSizeFToScriptValue, qSizeFFromScriptValue>(engine);
+    scriptRegisterMetaType<QRect, qRectToScriptValue, qRectFromScriptValue>(engine);
+    scriptRegisterMetaType<QUrl, qURLToScriptValue, qURLFromScriptValue>(engine);
+    scriptRegisterMetaType<QColor, qColorToScriptValue, qColorFromScriptValue>(engine);
 
-    scriptRegisterMetaType(engine, pickRayToScriptValue, pickRayFromScriptValue);
-    scriptRegisterMetaType(engine, collisionToScriptValue, collisionFromScriptValue);
-    scriptRegisterMetaType(engine, quuidToScriptValue, quuidFromScriptValue);
-    scriptRegisterMetaType(engine, aaCubeToScriptValue, aaCubeFromScriptValue);
+    scriptRegisterMetaType<PickRay, pickRayToScriptValue, pickRayFromScriptValue>(engine);
+    scriptRegisterMetaType<Collision, collisionToScriptValue, collisionFromScriptValue>(engine);
+    scriptRegisterMetaType<QUuid, quuidToScriptValue, quuidFromScriptValue>(engine);
+    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) {
diff --git a/libraries/script-engine/src/qtscript/ScriptEngineQtScript_cast.cpp b/libraries/script-engine/src/qtscript/ScriptEngineQtScript_cast.cpp
index e57bead0ed..99f2732fa0 100644
--- a/libraries/script-engine/src/qtscript/ScriptEngineQtScript_cast.cpp
+++ b/libraries/script-engine/src/qtscript/ScriptEngineQtScript_cast.cpp
@@ -186,13 +186,13 @@ static bool JsonArrayFromScriptValue(const ScriptValue& src, QJsonArray& dest) {
 void ScriptEngineQtScript::registerSystemTypes() {
     qScriptRegisterMetaType(this, ScriptValueToQScriptValue, ScriptValueFromQScriptValue);
 
-    scriptRegisterMetaType(this, StringListToScriptValue, StringListFromScriptValue);
-    scriptRegisterMetaType(this, VariantListToScriptValue, VariantListFromScriptValue);
-    scriptRegisterMetaType(this, VariantMapToScriptValue, VariantMapFromScriptValue);
-    scriptRegisterMetaType(this, VariantHashToScriptValue, VariantHashFromScriptValue);
-    scriptRegisterMetaType(this, JsonValueToScriptValue, JsonValueFromScriptValue);
-    scriptRegisterMetaType(this, JsonObjectToScriptValue, JsonObjectFromScriptValue);
-    scriptRegisterMetaType(this, JsonArrayToScriptValue, JsonArrayFromScriptValue);
+    scriptRegisterMetaType<QStringList, StringListToScriptValue, StringListFromScriptValue>(this);
+    scriptRegisterMetaType<QVariantList, VariantListToScriptValue, VariantListFromScriptValue>(this);
+    scriptRegisterMetaType<QVariantMap, VariantMapToScriptValue, VariantMapFromScriptValue>(this);
+    scriptRegisterMetaType<QVariantHash, VariantHashToScriptValue, VariantHashFromScriptValue>(this);
+    scriptRegisterMetaType<QJsonValue, JsonValueToScriptValue, JsonValueFromScriptValue>(this);
+    scriptRegisterMetaType<QJsonObject, JsonObjectToScriptValue, JsonObjectFromScriptValue>(this);
+    scriptRegisterMetaType<QJsonArray, JsonArrayToScriptValue, JsonArrayFromScriptValue>(this);
 }
 
 bool ScriptEngineQtScript::castValueToVariant(const QScriptValue& val, QVariant& dest, int destTypeId) {
diff --git a/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.cpp b/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.cpp
index c551920ac2..b89825426d 100644
--- a/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.cpp
+++ b/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.cpp
@@ -77,6 +77,10 @@ QScriptValue ScriptObjectQtProxy::newQObject(ScriptEngineQtScript* engine, QObje
         case ScriptEngine::AutoOwnership:
             ownsObject = !object->parent();
             break;
+        default:
+            ownsObject = false;
+            qCritical() << "Wrong ScriptEngine::ValueOwnership value: " << ownership;
+            break;
     }
 
     // create the wrapper
@@ -312,7 +316,6 @@ QScriptValue ScriptObjectQtProxy::property(const QScriptValue& object, const QSc
             int propId = id & ~TYPE_MASK;
             PropertyDefMap::const_iterator lookup = _props.find(propId);
             if (lookup == _props.cend()) return QScriptValue();
-            const PropertyDef& propDef = lookup.value();
 
             QMetaProperty prop = metaObject->property(propId);
             ScriptValue scriptThis = ScriptValue(new ScriptValueQtWrapper(_engine, object));
diff --git a/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.h b/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.h
index aa23595627..e102bdd97a 100644
--- a/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.h
+++ b/libraries/script-engine/src/qtscript/ScriptObjectQtProxy.h
@@ -63,7 +63,7 @@ private:  // implementation
 
 public:  // construction
     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();
     }
     virtual ~ScriptObjectQtProxy();
@@ -144,7 +144,7 @@ public:  // construction
     inline ScriptMethodQtProxy(ScriptEngineQtScript* engine, QObject* object, QScriptValue lifetime,
                                const QList<QMetaMethod>& metas, int numMaxParms) :
         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
     virtual QString name() const override { return fullName(); }
@@ -187,7 +187,7 @@ public:  // construction
         _engine(engine), _object(object), _objectLifetime(lifetime), _meta(meta), _metaCallId(discoverMetaCallIdx()) {}
 
 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();
     ConnectionList::iterator findConnection(QScriptValue thisObject, QScriptValue callback);
     QString fullName() const;
diff --git a/libraries/ui/src/ui/TabletScriptingInterface.cpp b/libraries/ui/src/ui/TabletScriptingInterface.cpp
index a4141cdbad..f8a2b17821 100644
--- a/libraries/ui/src/ui/TabletScriptingInterface.cpp
+++ b/libraries/ui/src/ui/TabletScriptingInterface.cpp
@@ -31,13 +31,12 @@
 
 #include "SettingHandle.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, wrapperToScriptValue<TabletProxy>, wrapperFromScriptValue<TabletProxy>);
-    scriptRegisterMetaType(scriptEngine,
-                            wrapperToScriptValue<TabletButtonProxy>, wrapperFromScriptValue<TabletButtonProxy>);
-});
+    scriptRegisterMetaType<TabletProxy*, wrapperToScriptValue<TabletProxy>, wrapperFromScriptValue<TabletProxy> >(scriptEngine);
+    scriptRegisterMetaType<TabletButtonProxy*, wrapperToScriptValue<TabletButtonProxy>, wrapperFromScriptValue<TabletButtonProxy> >(scriptEngine);
+}));
 
 // FIXME move to global app properties
 const QString SYSTEM_TOOLBAR = "com.highfidelity.interface.toolbar.system";
diff --git a/libraries/ui/src/ui/ToolbarScriptingInterface.cpp b/libraries/ui/src/ui/ToolbarScriptingInterface.cpp
index c68e765ca8..833b49de01 100644
--- a/libraries/ui/src/ui/ToolbarScriptingInterface.cpp
+++ b/libraries/ui/src/ui/ToolbarScriptingInterface.cpp
@@ -19,13 +19,12 @@
 #include <shared/QtHelpers.h>
 #include "../OffscreenUi.h"
 
-STATIC_SCRIPT_TYPES_INITIALIZER(+[](ScriptManager* manager){
+STATIC_SCRIPT_TYPES_INITIALIZER((+[](ScriptManager* manager){
     auto scriptEngine = manager->engine().get();
 
-    scriptRegisterMetaType(scriptEngine, wrapperToScriptValue<ToolbarProxy>, wrapperFromScriptValue<ToolbarProxy>);
-    scriptRegisterMetaType(scriptEngine,
-                            wrapperToScriptValue<ToolbarButtonProxy>, wrapperFromScriptValue<ToolbarButtonProxy>);
-});
+    scriptRegisterMetaType<ToolbarProxy*, wrapperToScriptValue<ToolbarProxy>, wrapperFromScriptValue<ToolbarProxy> >(scriptEngine);
+    scriptRegisterMetaType<ToolbarButtonProxy*, wrapperToScriptValue<ToolbarButtonProxy>, wrapperFromScriptValue<ToolbarButtonProxy> >(scriptEngine);
+}));
 
 ScriptValue toolbarToScriptValue(ScriptEngine* engine, ToolbarProxy* const &in) {
     if (!in) {