diff --git a/examples/defaultScripts.js b/examples/defaultScripts.js index 2c3ee65c92..a4c8c36169 100644 --- a/examples/defaultScripts.js +++ b/examples/defaultScripts.js @@ -14,11 +14,9 @@ Script.load("edit.js"); Script.load("examples.js"); Script.load("selectAudioDevice.js"); Script.load("notifications.js"); -Script.load("users.js"); Script.load("controllers/handControllerGrab.js"); Script.load("controllers/squeezeHands.js"); Script.load("grab.js"); Script.load("directory.js"); Script.load("dialTone.js"); -// Script.load("attachedEntitiesManager.js"); Script.load("depthReticle.js"); diff --git a/examples/libraries/toolBars.js b/examples/libraries/toolBars.js index 3b712e2ea0..6e54c0276c 100644 --- a/examples/libraries/toolBars.js +++ b/examples/libraries/toolBars.js @@ -355,20 +355,36 @@ ToolBar = function(x, y, direction, optionalPersistenceKey, optionalInitialPosit }); } }; - that.windowDimensions = Controller.getViewportDimensions(); + + function clamp(value, min, max) { + return Math.min(Math.max(value, min), max); + } + + var recommendedRect = Controller.getRecommendedOverlayRect(); + var recommendedDimmensions = { x: recommendedRect.width, y: recommendedRect.height }; + that.windowDimensions = recommendedDimmensions; // Controller.getViewportDimensions(); + that.origin = { x: recommendedRect.x, y: recommendedRect.y }; // Maybe fixme: Keeping the same percent of the window size isn't always the right thing. // For example, maybe we want "keep the same percentage to whatever two edges are closest to the edge of screen". // If we change that, the places to do so are onResizeViewport, save (maybe), and the initial move based on Settings, below. that.onResizeViewport = function (newSize) { // Can be overridden or extended by clients. - var fractionX = that.x / that.windowDimensions.x; - var fractionY = that.y / that.windowDimensions.y; - that.windowDimensions = newSize || Controller.getViewportDimensions(); - that.move(fractionX * that.windowDimensions.x, fractionY * that.windowDimensions.y); + var recommendedRect = Controller.getRecommendedOverlayRect(); + var recommendedDimmensions = { x: recommendedRect.width, y: recommendedRect.height }; + var originRelativeX = (that.x - that.origin.x); + var originRelativeY = (that.y - that.origin.y); + var fractionX = clamp(originRelativeX / that.windowDimensions.x, 0, 1); + var fractionY = clamp(originRelativeY / that.windowDimensions.y, 0, 1); + that.windowDimensions = newSize || recommendedDimmensions; + that.origin = { x: recommendedRect.x, y: recommendedRect.y }; + var newX = (fractionX * that.windowDimensions.x) + recommendedRect.x; + var newY = (fractionY * that.windowDimensions.y) + recommendedRect.y; + that.move(newX, newY); }; if (optionalPersistenceKey) { this.fractionKey = optionalPersistenceKey + '.fraction'; this.save = function () { - var screenSize = Controller.getViewportDimensions(); + var recommendedRect = Controller.getRecommendedOverlayRect(); + var screenSize = { x: recommendedRect.width, y: recommendedRect.height }; if (screenSize.x > 0 && screenSize.y > 0) { // Guard against invalid screen size that can occur at shut-down. var fraction = {x: that.x / screenSize.x, y: that.y / screenSize.y}; @@ -411,7 +427,9 @@ ToolBar = function(x, y, direction, optionalPersistenceKey, optionalInitialPosit that.move(that.dragOffsetX + event.x, that.dragOffsetY + event.y); }; that.checkResize = function () { // Can be overriden or extended, but usually not. See onResizeViewport. - var currentWindowSize = Controller.getViewportDimensions(); + var recommendedRect = Controller.getRecommendedOverlayRect(); + var currentWindowSize = { x: recommendedRect.width, y: recommendedRect.height }; + if ((currentWindowSize.x !== that.windowDimensions.x) || (currentWindowSize.y !== that.windowDimensions.y)) { that.onResizeViewport(currentWindowSize); } @@ -434,7 +452,8 @@ ToolBar = function(x, y, direction, optionalPersistenceKey, optionalInitialPosit } if (this.fractionKey || optionalInitialPositionFunction) { var savedFraction = JSON.parse(Settings.getValue(this.fractionKey) || '0'); // getValue can answer empty string - var screenSize = Controller.getViewportDimensions(); + var recommendedRect = Controller.getRecommendedOverlayRect(); + var screenSize = { x: recommendedRect.width, y: recommendedRect.height }; if (savedFraction) { // If we have saved data, keep the toolbar at the same proportion of the screen width/height. that.move(savedFraction.x * screenSize.x, savedFraction.y * screenSize.y); diff --git a/interface/resources/qml/AvatarInputs.qml b/interface/resources/qml/AvatarInputs.qml index fb989dd174..75f379a425 100644 --- a/interface/resources/qml/AvatarInputs.qml +++ b/interface/resources/qml/AvatarInputs.qml @@ -23,6 +23,8 @@ Hifi.AvatarInputs { readonly property int mirrorWidth: 265 readonly property int iconSize: 24 readonly property int iconPadding: 5 + + readonly property bool shouldReposition: true Settings { category: "Overlay.AvatarInputs" diff --git a/interface/resources/qml/desktop/Desktop.qml b/interface/resources/qml/desktop/Desktop.qml index beea0d8c64..c0804a967d 100644 --- a/interface/resources/qml/desktop/Desktop.qml +++ b/interface/resources/qml/desktop/Desktop.qml @@ -21,8 +21,11 @@ FocusScope { objectName: "desktop" anchors.fill: parent - onHeightChanged: d.repositionAll(); - onWidthChanged: d.repositionAll(); + property rect recommendedRect: rect(0,0,0,0); + + onHeightChanged: d.handleSizeChanged(); + + onWidthChanged: d.handleSizeChanged(); // Controls and windows can trigger this signal to ensure the desktop becomes visible // when they're opened. @@ -50,6 +53,20 @@ FocusScope { QtObject { id: d + function handleSizeChanged() { + var oldRecommendedRect = recommendedRect; + var newRecommendedRectJS = Controller.getRecommendedOverlayRect(); + var newRecommendedRect = Qt.rect(newRecommendedRectJS.x, newRecommendedRectJS.y, + newRecommendedRectJS.width, + newRecommendedRectJS.height); + + if (oldRecommendedRect != Qt.rect(0,0,0,0) + && oldRecommendedRect != newRecommendedRect) { + d.repositionAll(); + } + recommendedRect = newRecommendedRect; + } + function findChild(item, name) { for (var i = 0; i < item.children.length; ++i) { if (item.children[i].objectName === name) { @@ -202,12 +219,42 @@ FocusScope { // } } + function getRepositionChildren(predicate) { + var currentWindows = []; + if (!desktop) { + console.log("Could not find desktop"); + return currentWindows; + } + + for (var i = 0; i < desktop.children.length; ++i) { + var child = desktop.children[i]; + if (child.shouldReposition === true && (!predicate || predicate(child))) { + currentWindows.push(child) + } + } + return currentWindows; + } function repositionAll() { + var oldRecommendedRect = recommendedRect; + var oldRecommendedDimmensions = { x: oldRecommendedRect.width, y: oldRecommendedRect.height }; + var newRecommendedRect = Controller.getRecommendedOverlayRect(); + var newRecommendedDimmensions = { x: newRecommendedRect.width, y: newRecommendedRect.height }; var windows = d.getTopLevelWindows(); for (var i = 0; i < windows.length; ++i) { - reposition(windows[i]); + var targetWindow = windows[i]; + if (targetWindow.visible) { + repositionWindow(targetWindow, true, oldRecommendedRect, oldRecommendedDimmensions, newRecommendedRect, newRecommendedDimmensions); + } } + + // also reposition the other children that aren't top level windows but want to be repositioned + var otherChildren = d.getRepositionChildren(); + for (var i = 0; i < otherChildren.length; ++i) { + var child = otherChildren[i]; + repositionWindow(child, true, oldRecommendedRect, oldRecommendedDimmensions, newRecommendedRect, newRecommendedDimmensions); + } + } } @@ -232,38 +279,56 @@ FocusScope { targetWindow.focus = true; } - reposition(targetWindow); + var oldRecommendedRect = recommendedRect; + var oldRecommendedDimmensions = { x: oldRecommendedRect.width, y: oldRecommendedRect.height }; + var newRecommendedRect = Controller.getRecommendedOverlayRect(); + var newRecommendedDimmensions = { x: newRecommendedRect.width, y: newRecommendedRect.height }; + repositionWindow(targetWindow, false, oldRecommendedRect, oldRecommendedDimmensions, newRecommendedRect, newRecommendedDimmensions); showDesktop(); } - function reposition(item) { + function repositionWindow(targetWindow, forceReposition, + oldRecommendedRect, oldRecommendedDimmensions, newRecommendedRect, newRecommendedDimmensions) { + if (desktop.width === 0 || desktop.height === 0) { return; } - var targetWindow = d.getDesktopWindow(item); if (!targetWindow) { console.warn("Could not find top level window for " + item); return; } + var recommended = Controller.getRecommendedOverlayRect(); + var maxX = recommended.x + recommended.width; + var maxY = recommended.y + recommended.height; var newPosition = Qt.vector2d(targetWindow.x, targetWindow.y); - // If the window is completely offscreen, reposition it - if ((targetWindow.x > desktop.width || (targetWindow.x + targetWindow.width) < 0) || - (targetWindow.y > desktop.height || (targetWindow.y + targetWindow.height) < 0)) { + + // if we asked to force reposition, or if the window is completely outside of the recommended rectangle, reposition it + if (forceReposition || (targetWindow.x > maxX || (targetWindow.x + targetWindow.width) < recommended.x) || + (targetWindow.y > maxY || (targetWindow.y + targetWindow.height) < recommended.y)) { newPosition.x = -1 newPosition.y = -1 } + if (newPosition.x === -1 && newPosition.y === -1) { - // Set initial window position - // var minPosition = Qt.vector2d(-windowRect.x, -windowRect.y); - // var maxPosition = Qt.vector2d(desktop.width - windowRect.width, desktop.height - windowRect.height); - // newPosition = Utils.clampVector(newPosition, minPosition, maxPosition); - // newPosition = Utils.randomPosition(minPosition, maxPosition); - newPosition = Qt.vector2d(desktop.width / 2 - targetWindow.width / 2, - desktop.height / 2 - targetWindow.height / 2); + var originRelativeX = (targetWindow.x - oldRecommendedRect.x); + var originRelativeY = (targetWindow.y - oldRecommendedRect.y); + if (isNaN(originRelativeX)) { + originRelativeX = 0; + } + if (isNaN(originRelativeY)) { + originRelativeY = 0; + } + var fractionX = Utils.clamp(originRelativeX / oldRecommendedDimmensions.x, 0, 1); + var fractionY = Utils.clamp(originRelativeY / oldRecommendedDimmensions.y, 0, 1); + + var newX = (fractionX * newRecommendedDimmensions.x) + newRecommendedRect.x; + var newY = (fractionY * newRecommendedDimmensions.y) + newRecommendedRect.y; + + newPosition = Qt.vector2d(newX, newY); } targetWindow.x = newPosition.x; targetWindow.y = newPosition.y; diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index cd6f302d43..f3639946ad 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2681,8 +2681,6 @@ void Application::idle(uint64_t now) { _overlayConductor.setEnabled(Menu::getInstance()->isOptionChecked(MenuOption::Overlays)); } - - // If the offscreen Ui has something active that is NOT the root, then assume it has keyboard focus. auto offscreenUi = DependencyManager::get(); if (_keyboardDeviceHasFocus && offscreenUi && offscreenUi->getWindow()->activeFocusItem() != offscreenUi->getRootItem()) { @@ -4894,19 +4892,44 @@ QRect Application::getRenderingGeometry() const { } glm::uvec2 Application::getUiSize() const { - return getActiveDisplayPlugin()->getRecommendedUiSize(); + static const uint MIN_SIZE = 1; + glm::uvec2 result(MIN_SIZE); + if (_displayPlugin) { + result = getActiveDisplayPlugin()->getRecommendedUiSize(); + } + return result; +} + +QRect Application::getRecommendedOverlayRect() const { + auto uiSize = getUiSize(); + QRect result(0, 0, uiSize.x, uiSize.y); + if (_displayPlugin) { + result = getActiveDisplayPlugin()->getRecommendedOverlayRect(); + } + return result; } QSize Application::getDeviceSize() const { - return fromGlm(getActiveDisplayPlugin()->getRecommendedRenderSize()); + static const int MIN_SIZE = 1; + QSize result(MIN_SIZE, MIN_SIZE); + if (_displayPlugin) { + result = fromGlm(getActiveDisplayPlugin()->getRecommendedRenderSize()); + } + return result; } bool Application::isThrottleRendering() const { - return getActiveDisplayPlugin()->isThrottled(); + if (_displayPlugin) { + return getActiveDisplayPlugin()->isThrottled(); + } + return false; } bool Application::hasFocus() const { - return getActiveDisplayPlugin()->hasFocus(); + if (_displayPlugin) { + return getActiveDisplayPlugin()->hasFocus(); + } + return (QApplication::activeWindow() != nullptr); } glm::vec2 Application::getViewportDimensions() const { diff --git a/interface/src/Application.h b/interface/src/Application.h index 6bfad21525..2911d42b65 100644 --- a/interface/src/Application.h +++ b/interface/src/Application.h @@ -117,6 +117,7 @@ public: QRect getRenderingGeometry() const; glm::uvec2 getUiSize() const; + QRect getRecommendedOverlayRect() const; QSize getDeviceSize() const; bool hasFocus() const; diff --git a/interface/src/scripting/ControllerScriptingInterface.cpp b/interface/src/scripting/ControllerScriptingInterface.cpp index f6e5b6364f..d28c209a52 100644 --- a/interface/src/scripting/ControllerScriptingInterface.cpp +++ b/interface/src/scripting/ControllerScriptingInterface.cpp @@ -80,6 +80,11 @@ glm::vec2 ControllerScriptingInterface::getViewportDimensions() const { return qApp->getUiSize(); } +QVariant ControllerScriptingInterface::getRecommendedOverlayRect() const { + auto rect = qApp->getRecommendedOverlayRect(); + return qRectToVariant(rect); +} + controller::InputController* ControllerScriptingInterface::createInputController(const QString& deviceName, const QString& tracker) { // This is where we retrieve the Device Tracker category and then the sub tracker within it auto icIt = _inputControllers.find(0); diff --git a/interface/src/scripting/ControllerScriptingInterface.h b/interface/src/scripting/ControllerScriptingInterface.h index 43bb6987db..fc8d125839 100644 --- a/interface/src/scripting/ControllerScriptingInterface.h +++ b/interface/src/scripting/ControllerScriptingInterface.h @@ -96,6 +96,7 @@ public slots: virtual void releaseJoystick(int joystickIndex); virtual glm::vec2 getViewportDimensions() const; + virtual QVariant getRecommendedOverlayRect() const; /// Factory to create an InputController virtual controller::InputController* createInputController(const QString& deviceName, const QString& tracker); diff --git a/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp b/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp index b39fd8861d..4648fc8957 100644 --- a/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp +++ b/libraries/display-plugins/src/display-plugins/CompositorHelper.cpp @@ -34,6 +34,7 @@ static const float reticleSize = TWO_PI / 100.0f; static QString _tooltipId; const uvec2 CompositorHelper::VIRTUAL_SCREEN_SIZE = uvec2(3960, 1188); // ~10% more pixel density than old version, 72dx240d FOV +const QRect CompositorHelper::VIRTUAL_SCREEN_RECOMMENDED_OVERLAY_RECT = QRect(956, 0, 2048, 1188); // don't include entire width only center 2048 const float CompositorHelper::VIRTUAL_UI_ASPECT_RATIO = (float)VIRTUAL_SCREEN_SIZE.x / (float)VIRTUAL_SCREEN_SIZE.y; const vec2 CompositorHelper::VIRTUAL_UI_TARGET_FOV = vec2(PI * 3.0f / 2.0f, PI * 3.0f / 2.0f / VIRTUAL_UI_ASPECT_RATIO); const vec2 CompositorHelper::MOUSE_EXTENTS_ANGULAR_SIZE = vec2(PI * 2.0f, PI * 0.95f); // horizontal: full sphere, vertical: ~5deg from poles diff --git a/libraries/display-plugins/src/display-plugins/CompositorHelper.h b/libraries/display-plugins/src/display-plugins/CompositorHelper.h index 062e5c1319..c0b53b329e 100644 --- a/libraries/display-plugins/src/display-plugins/CompositorHelper.h +++ b/libraries/display-plugins/src/display-plugins/CompositorHelper.h @@ -42,6 +42,7 @@ class CompositorHelper : public QObject, public Dependency { Q_PROPERTY(bool reticleOverDesktop READ getReticleOverDesktop WRITE setReticleOverDesktop) public: static const uvec2 VIRTUAL_SCREEN_SIZE; + static const QRect VIRTUAL_SCREEN_RECOMMENDED_OVERLAY_RECT; static const float VIRTUAL_UI_ASPECT_RATIO; static const vec2 VIRTUAL_UI_TARGET_FOV; static const vec2 MOUSE_EXTENTS_ANGULAR_SIZE; diff --git a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp index 34e484a988..79b50a7f88 100644 --- a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp +++ b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp @@ -34,6 +34,11 @@ glm::uvec2 HmdDisplayPlugin::getRecommendedUiSize() const { return CompositorHelper::VIRTUAL_SCREEN_SIZE; } +QRect HmdDisplayPlugin::getRecommendedOverlayRect() const { + return CompositorHelper::VIRTUAL_SCREEN_RECOMMENDED_OVERLAY_RECT; +} + + bool HmdDisplayPlugin::internalActivate() { _monoPreview = _container->getBoolSetting("monoPreview", DEFAULT_MONO_VIEW); diff --git a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h index d16f03112f..e6ceb7e376 100644 --- a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h +++ b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h @@ -26,6 +26,8 @@ public: void setEyeRenderPose(uint32_t frameIndex, Eye eye, const glm::mat4& pose) override final; bool isDisplayVisible() const override { return isHmdMounted(); } + QRect getRecommendedOverlayRect() const override final; + virtual glm::mat4 getHeadPose() const override; diff --git a/libraries/plugins/src/plugins/DisplayPlugin.h b/libraries/plugins/src/plugins/DisplayPlugin.h index de6fe0c839..64a73ab12a 100644 --- a/libraries/plugins/src/plugins/DisplayPlugin.h +++ b/libraries/plugins/src/plugins/DisplayPlugin.h @@ -105,6 +105,12 @@ public: return aspect(getRecommendedRenderSize()); } + // The recommended bounds for primary overlay placement + virtual QRect getRecommendedOverlayRect() const { + auto recommendedSize = getRecommendedUiSize(); + return QRect(0, 0, recommendedSize.x, recommendedSize.y); + } + // Stereo specific methods virtual glm::mat4 getEyeProjection(Eye eye, const glm::mat4& baseProjection) const { return baseProjection; diff --git a/libraries/shared/src/RegisteredMetaTypes.cpp b/libraries/shared/src/RegisteredMetaTypes.cpp index 953fdb3582..53fa8b30cf 100644 --- a/libraries/shared/src/RegisteredMetaTypes.cpp +++ b/libraries/shared/src/RegisteredMetaTypes.cpp @@ -128,7 +128,7 @@ void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) { vec3.z = object.property("z").toVariant().toFloat(); } -QVariant vec3toVariant(const glm::vec3 &vec3) { +QVariant vec3toVariant(const glm::vec3& vec3) { if (vec3.x != vec3.x || vec3.y != vec3.y || vec3.z != vec3.z) { // if vec3 contains a NaN don't try to convert it return QVariant(); @@ -140,6 +140,18 @@ QVariant vec3toVariant(const glm::vec3 &vec3) { return result; } +QVariant vec4toVariant(const glm::vec4& vec4) { + if (isNaN(vec4.x) || isNaN(vec4.y) || isNaN(vec4.z) || isNaN(vec4.w)) { + // if vec4 contains a NaN don't try to convert it + return QVariant(); + } + QVariantMap result; + result["x"] = vec4.x; + result["y"] = vec4.y; + result["z"] = vec4.z; + result["w"] = vec4.w; + return result; +} QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector& vector) { QScriptValue array = engine->newArray(); @@ -150,7 +162,7 @@ QScriptValue qVectorVec3ToScriptValue(QScriptEngine* engine, const QVector()) { + v = glm::vec4(object.toFloat()); + valid = true; + } else if (object.canConvert()) { + auto qvec4 = qvariant_cast(object); + v.x = qvec4.x(); + v.y = qvec4.y(); + v.z = qvec4.z(); + v.w = qvec4.w(); + valid = true; + } else { + auto map = object.toMap(); + auto x = map["x"]; + auto y = map["y"]; + auto z = map["z"]; + auto w = map["w"]; + if (x.canConvert() && y.canConvert() && z.canConvert() && w.canConvert()) { + v.x = x.toFloat(); + v.y = y.toFloat(); + v.z = z.toFloat(); + v.w = w.toFloat(); + valid = true; + } + } + return v; +} + +glm::vec4 vec4FromVariant(const QVariant& object) { + bool valid = false; + return vec4FromVariant(object, valid); +} + +QScriptValue quatToScriptValue(QScriptEngine* engine, const glm::quat& quat) { QScriptValue obj = engine->newObject(); if (quat.x != quat.x || quat.y != quat.y || quat.z != quat.z || quat.w != quat.w) { // if quat contains a NaN don't try to convert it @@ -207,7 +256,7 @@ QScriptValue quatToScriptValue(QScriptEngine* engine, const glm::quat &quat) { return obj; } -void quatFromScriptValue(const QScriptValue &object, glm::quat &quat) { +void quatFromScriptValue(const QScriptValue& object, glm::quat &quat) { quat.x = object.property("x").toVariant().toFloat(); quat.y = object.property("y").toVariant().toFloat(); quat.z = object.property("z").toVariant().toFloat(); @@ -245,12 +294,12 @@ glm::quat quatFromVariant(const QVariant &object, bool& isValid) { return q; } -glm::quat quatFromVariant(const QVariant &object) { +glm::quat quatFromVariant(const QVariant& object) { bool valid = false; return quatFromVariant(object, valid); } -QVariant quatToVariant(const glm::quat &quat) { +QVariant quatToVariant(const glm::quat& quat) { if (quat.x != quat.x || quat.y != quat.y || quat.z != quat.z) { // if vec3 contains a NaN don't try to convert it return QVariant(); diff --git a/libraries/shared/src/RegisteredMetaTypes.h b/libraries/shared/src/RegisteredMetaTypes.h index 652ec26fe7..2aefd3aa47 100644 --- a/libraries/shared/src/RegisteredMetaTypes.h +++ b/libraries/shared/src/RegisteredMetaTypes.h @@ -43,12 +43,15 @@ void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4); // Vec4 QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4); void vec4FromScriptValue(const QScriptValue& object, glm::vec4& vec4); +QVariant vec4toVariant(const glm::vec4& vec4); +glm::vec4 vec4FromVariant(const QVariant &object, bool& valid); +glm::vec4 vec4FromVariant(const QVariant &object); // Vec3 QScriptValue vec3toScriptValue(QScriptEngine* engine, const glm::vec3 &vec3); void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3); -QVariant vec3toVariant(const glm::vec3 &vec3); +QVariant vec3toVariant(const glm::vec3& vec3); glm::vec3 vec3FromVariant(const QVariant &object, bool& valid); glm::vec3 vec3FromVariant(const QVariant &object); @@ -71,9 +74,10 @@ glm::quat quatFromVariant(const QVariant &object); // Rect QScriptValue qRectToScriptValue(QScriptEngine* engine, const QRect& rect); void qRectFromScriptValue(const QScriptValue& object, QRect& rect); - -QVariant qRectToVariant(const QRect& rect); QRect qRectFromVariant(const QVariant& object, bool& isValid); +QRect qRectFromVariant(const QVariant& object); +QVariant qRectToVariant(const QRect& rect); + // xColor QScriptValue xColorToScriptValue(QScriptEngine* engine, const xColor& color);