Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-04-07 04:53:28 +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 "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/" };

8
interface/src/RefreshRateManager.cpp
View file

@ -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();

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

@ -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) {

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) {
scriptRegisterMetaType(engine, pickTypesToScriptValue, pickTypesFromScriptValue);
scriptRegisterMetaType<PickQuery::PickType, pickTypesToScriptValue, pickTypesFromScriptValue>(engine);
}
void PickScriptingInterface::registerProperties(ScriptEngine* engine) {

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

@ -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>();

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

@ -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();

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

@ -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();

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

@ -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();

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

@ -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) {

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::_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);

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

@ -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();

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

@ -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);
}

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

@ -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.

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)
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();

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

@ -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)

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

@ -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())
{
}

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

@ -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]" };

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) {
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) {

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

@ -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) {

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

@ -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);

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

@ -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);
}

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

@ -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; } }

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

@ -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");
}

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

@ -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;
}

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

@ -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";

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) {
scriptRegisterMetaType(engine, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue, "MenuItemProperties");
scriptRegisterMetaType<MenuItemProperties, menuItemPropertiesToScriptValue, menuItemPropertiesFromScriptValue>(engine, "MenuItemProperties");
}
ScriptValue menuItemPropertiesToScriptValue(ScriptEngine* engine, const MenuItemProperties& properties) {

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

@ -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");
}));

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

@ -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

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) :
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() {

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

@ -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) {

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() {
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) {

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

@ -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));

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

@ -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;

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

@ -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";

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

@ -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) {