From 0d62b10a8f0c0a363f6a7185a4f2b59932b4ff20 Mon Sep 17 00:00:00 2001 From: "Anthony J. Thibault" Date: Mon, 7 Mar 2016 16:16:14 -0800 Subject: [PATCH] Added Mat4 support to script Also, hooked up MyAvatar.sensorToWorldMatrix access to script. --- examples/tests/mat4test.js | 165 +++++++++++++++++++ interface/src/avatar/MyAvatar.cpp | 5 +- interface/src/avatar/MyAvatar.h | 9 +- libraries/script-engine/src/Mat4.cpp | 71 ++++++++ libraries/script-engine/src/Mat4.h | 45 +++++ libraries/script-engine/src/ScriptEngine.cpp | 1 + libraries/script-engine/src/ScriptEngine.h | 4 +- libraries/shared/src/GLMHelpers.cpp | 9 + libraries/shared/src/GLMHelpers.h | 1 + libraries/shared/src/RegisteredMetaTypes.cpp | 41 +++++ libraries/shared/src/RegisteredMetaTypes.h | 5 + 11 files changed, 352 insertions(+), 4 deletions(-) create mode 100644 examples/tests/mat4test.js create mode 100644 libraries/script-engine/src/Mat4.cpp create mode 100644 libraries/script-engine/src/Mat4.h diff --git a/examples/tests/mat4test.js b/examples/tests/mat4test.js new file mode 100644 index 0000000000..ebce420dcb --- /dev/null +++ b/examples/tests/mat4test.js @@ -0,0 +1,165 @@ +// +// mat4test.js +// examples/tests +// +// Created by Anthony Thibault on 2016/3/7 +// Copyright 2016 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +var IDENTITY = {r0c0: 1, r0c1: 0, r0c2: 0, r0c3: 0, + r1c0: 0, r1c1: 1, r1c2: 0, r1c3: 0, + r2c0: 0, r2c1: 0, r2c2: 1, r2c3: 0, + r3c0: 0, r3c1: 0, r3c2: 0, r3c3: 1}; + +var ROT_ZERO = {x: 0, y: 0, z: 0, w: 1}; +var ROT_Y_180 = {x: 0, y: 1, z: 0, w: 0}; + +var ONE = {x: 1, y: 1, z: 1}; +var ZERO = {x: 0, y: 0, z: 0}; +var ONE_TWO_THREE = {x: 1, y: 2, z: 3}; +var ONE_HALF = {x: 0.5, y: 0.5, z: 0.5}; + +var EPSILON = 0.000001; + +function mat4FuzzyEqual(a, b) { + var r, c; + for (r = 0; r < 4; r++) { + for (c = 0; c < 4; c++) { + if (Math.abs(a["r" + r + "c" + c] - b["r" + r + "c" + c]) > EPSILON) { + return false; + } + } + } + return true; +} + +function vec3FuzzyEqual(a, b) { + if (Math.abs(a.x - b.x) > EPSILON || + Math.abs(a.y - b.y) > EPSILON || + Math.abs(a.z - b.z) > EPSILON) { + return false; + } + return true; +} + +function quatFuzzyEqual(a, b) { + if (Math.abs(a.x - b.x) > EPSILON || + Math.abs(a.y - b.y) > EPSILON || + Math.abs(a.z - b.z) > EPSILON || + Math.abs(a.w - b.w) > EPSILON) { + return false; + } + return true; +} + +var failureCount = 0; +var testCount = 0; +function assert(test) { + testCount++; + if (!test) { + print("MAT4 TEST " + testCount + " failed!"); + failureCount++; + } +} + +function testCreate() { + var test0 = Mat4.createFromScaleRotAndTrans(ONE, {x: 0, y: 0, z: 0, w: 1}, ZERO); + assert(mat4FuzzyEqual(test0, IDENTITY)); + + var test1 = Mat4.createFromRotAndTrans({x: 0, y: 0, z: 0, w: 1}, ZERO); + assert(mat4FuzzyEqual(test1, IDENTITY)); + + var test2 = Mat4.createFromRotAndTrans(ROT_Y_180, ONE_TWO_THREE); + assert(mat4FuzzyEqual(test2, {r0c0: -1, r0c1: 0, r0c2: 0, r0c3: 1, + r1c0: 0, r1c1: 1, r1c2: 0, r1c3: 2, + r2c0: 0, r2c1: 0, r2c2: -1, r2c3: 3, + r3c0: 0, r3c1: 0, r3c2: 0, r3c3: 1})); + + var test3 = Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE); + assert(mat4FuzzyEqual(test3, {r0c0: -0.5, r0c1: 0, r0c2: 0, r0c3: 1, + r1c0: 0, r1c1: 0.5, r1c2: 0, r1c3: 2, + r2c0: 0, r2c1: 0, r2c2: -0.5, r2c3: 3, + r3c0: 0, r3c1: 0, r3c2: 0, r3c3: 1})); +} + +function testExtractTranslation() { + var test0 = Mat4.extractTranslation(IDENTITY); + assert(vec3FuzzyEqual(ZERO, test0)); + + var test1 = Mat4.extractTranslation(Mat4.createFromRotAndTrans(ROT_Y_180, ONE_TWO_THREE)); + assert(vec3FuzzyEqual(ONE_TWO_THREE, test1)); +} + +function testExtractRotation() { + var test0 = Mat4.extractRotation(IDENTITY); + assert(quatFuzzyEqual(ROT_ZERO, test0)); + + var test1 = Mat4.extractRotation(Mat4.createFromRotAndTrans(ROT_Y_180, ONE_TWO_THREE)); + assert(quatFuzzyEqual(ROT_Y_180, test1)); +} + +function testExtractScale() { + var test0 = Mat4.extractScale(IDENTITY); + assert(vec3FuzzyEqual(ONE, test0)); + + var test1 = Mat4.extractScale(Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE)); + assert(vec3FuzzyEqual(ONE_HALF, test1)); + + var test2 = Mat4.extractScale(Mat4.createFromScaleRotAndTrans(ONE_TWO_THREE, ROT_ZERO, ONE_TWO_THREE)); + assert(vec3FuzzyEqual(ONE_TWO_THREE, test2)); +} + +function testTransformPoint() { + var test0 = Mat4.transformPoint(IDENTITY, ONE); + assert(vec3FuzzyEqual(ONE, test0)); + + var m = Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE); + var test1 = Mat4.transformPoint(m, ONE); + assert(vec3FuzzyEqual({x: 0.5, y: 2.5, z: 2.5}, test1)); +} + +function testTransformVector() { + var test0 = Mat4.transformVector(IDENTITY, ONE); + assert(vec3FuzzyEqual(ONE, test0)); + + var m = Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE); + var test1 = Mat4.transformVector(m, ONE); + assert(vec3FuzzyEqual({x: -0.5, y: 0.5, z: -0.5}, test1)); +} + +function testInverse() { + var test0 = IDENTITY; + assert(mat4FuzzyEqual(IDENTITY, Mat4.multiply(test0, Mat4.inverse(test0)))); + + var test1 = Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE); + assert(mat4FuzzyEqual(IDENTITY, Mat4.multiply(test1, Mat4.inverse(test1)))); + + var test2 = Mat4.extractScale(Mat4.createFromScaleRotAndTrans(ONE_TWO_THREE, ROT_ZERO, ONE_TWO_THREE)); + assert(mat4FuzzyEqual(IDENTITY, Mat4.multiply(test2, Mat4.inverse(test2)))); +} + +function testFront() { + var test0 = IDENTITY; + assert(mat4FuzzyEqual({x: 0, y: 0, z: -1}, Mat4.getFront(test0))); + + var test1 = Mat4.createFromScaleRotAndTrans(ONE_HALF, ROT_Y_180, ONE_TWO_THREE); + assert(mat4FuzzyEqual({x: 0, y: 0, z: 1}, Mat4.getFront(test1))); +} + +function testMat4() { + testCreate(); + testExtractTranslation(); + testExtractRotation(); + testExtractScale(); + testTransformPoint(); + testTransformVector(); + testInverse(); + testFront(); + + print("MAT4 TEST complete! (" + (testCount - failureCount) + "/" + testCount + ") tests passed!"); +} + +testMat4(); diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp index 397627434f..26e0ce56dd 100644 --- a/interface/src/avatar/MyAvatar.cpp +++ b/interface/src/avatar/MyAvatar.cpp @@ -416,8 +416,9 @@ void MyAvatar::simulate(float deltaTime) { } } +// thread-safe glm::mat4 MyAvatar::getSensorToWorldMatrix() const { - return _sensorToWorldMatrix; + return _sensorToWorldMatrixCache.get(); } // Pass a recent sample of the HMD to the avatar. @@ -442,6 +443,8 @@ void MyAvatar::updateSensorToWorldMatrix() { _sensorToWorldMatrix = desiredMat * glm::inverse(_bodySensorMatrix); lateUpdatePalms(); + + _sensorToWorldMatrixCache.set(_sensorToWorldMatrix); } // Update avatar head rotation with sensor data diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h index 731cba8153..fd5c2920a9 100644 --- a/interface/src/avatar/MyAvatar.h +++ b/interface/src/avatar/MyAvatar.h @@ -22,7 +22,7 @@ #include "Avatar.h" #include "AtRestDetector.h" #include "MyCharacterController.h" - +#include class ModelItemID; @@ -78,6 +78,9 @@ class MyAvatar : public Avatar { Q_PROPERTY(controller::Pose rightHandPose READ getRightHandPose) Q_PROPERTY(controller::Pose leftHandTipPose READ getLeftHandTipPose) Q_PROPERTY(controller::Pose rightHandTipPose READ getRightHandTipPose) + + Q_PROPERTY(glm::mat4 sensorToWorldMatrix READ getSensorToWorldMatrix) + Q_PROPERTY(float energy READ getEnergy WRITE setEnergy) public: @@ -98,8 +101,9 @@ public: const glm::vec3& getHMDSensorPosition() const { return _hmdSensorPosition; } const glm::quat& getHMDSensorOrientation() const { return _hmdSensorOrientation; } const glm::vec2& getHMDSensorFacingMovingAverage() const { return _hmdSensorFacingMovingAverage; } - glm::mat4 getSensorToWorldMatrix() const; + // thread safe + Q_INVOKABLE glm::mat4 getSensorToWorldMatrix() const; // Pass a recent sample of the HMD to the avatar. // This can also update the avatar's position to follow the HMD @@ -390,6 +394,7 @@ private: // used to transform any sensor into world space, including the _hmdSensorMat, or hand controllers. glm::mat4 _sensorToWorldMatrix; + ThreadSafeValueCache _sensorToWorldMatrixCache { glm::mat4() }; struct FollowHelper { FollowHelper(); diff --git a/libraries/script-engine/src/Mat4.cpp b/libraries/script-engine/src/Mat4.cpp new file mode 100644 index 0000000000..bb65cb1e26 --- /dev/null +++ b/libraries/script-engine/src/Mat4.cpp @@ -0,0 +1,71 @@ +// +// Mat4.cpp +// libraries/script-engine/src +// +// Created by Anthony Thibault on 3/7/16. +// Copyright 2016 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#include +#include +#include "ScriptEngineLogging.h" +#include "Mat4.h" + +glm::mat4 Mat4::multiply(const glm::mat4& m1, const glm::mat4& m2) const { + return m1 * m2; +} + +glm::mat4 Mat4::createFromRotAndTrans(const glm::quat& rot, const glm::vec3& trans) const { + return ::createMatFromQuatAndPos(rot, trans); +} + +glm::mat4 Mat4::createFromScaleRotAndTrans(const glm::vec3& scale, const glm::quat& rot, const glm::vec3& trans) const { + return createMatFromScaleQuatAndPos(scale, rot, trans); +} + +glm::vec3 Mat4::extractTranslation(const glm::mat4& m) const { + return ::extractTranslation(m); +} + +glm::quat Mat4::extractRotation(const glm::mat4& m) const { + return ::glmExtractRotation(m); +} + +glm::vec3 Mat4::extractScale(const glm::mat4& m) const { + return ::extractScale(m); +} + +glm::vec3 Mat4::transformPoint(const glm::mat4& m, const glm::vec3& point) const { + return ::transformPoint(m, point); +} + +glm::vec3 Mat4::transformVector(const glm::mat4& m, const glm::vec3& vector) const { + return ::transformVectorFast(m, vector); +} + +glm::mat4 Mat4::inverse(const glm::mat4& m) const { + return glm::inverse(m); +} + +glm::vec3 Mat4::getFront(const glm::mat4& m) const { + return glm::vec3(-m[0][2], -m[1][2], -m[2][2]); +} + +glm::vec3 Mat4::getRight(const glm::mat4& m) const { + return glm::vec3(m[0][0], m[1][0], m[2][0]); +} + +glm::vec3 Mat4::getUp(const glm::mat4& m) const { + return glm::vec3(m[0][1], m[1][1], m[2][1]); +} + +void Mat4::print(const QString& label, const glm::mat4& m) const { + qCDebug(scriptengine) << qPrintable(label) << + "row0 =" << m[0][0] << "," << m[1][0] << "," << m[2][0] << "," << m[3][0] << + "row1 =" << m[0][1] << "," << m[1][1] << "," << m[2][1] << "," << m[3][1] << + "row2 =" << m[0][2] << "," << m[1][2] << "," << m[2][2] << "," << m[3][2] << + "row3 =" << m[0][3] << "," << m[1][3] << "," << m[2][3] << "," << m[3][3]; +} diff --git a/libraries/script-engine/src/Mat4.h b/libraries/script-engine/src/Mat4.h new file mode 100644 index 0000000000..047bf56079 --- /dev/null +++ b/libraries/script-engine/src/Mat4.h @@ -0,0 +1,45 @@ +// +// Mat4.h +// libraries/script-engine/src +// +// Created by Anthony Thibault on 3/7/16. +// Copyright 2016 High Fidelity, Inc. +// +// Scriptable 4x4 Matrix class library. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#ifndef hifi_Mat4_h +#define hifi_Mat4_h + +#include +#include + +/// Scriptable Mat4 object. Used exclusively in the JavaScript API +class Mat4 : public QObject { + Q_OBJECT + +public slots: + glm::mat4 multiply(const glm::mat4& m1, const glm::mat4& m2) const; + glm::mat4 createFromRotAndTrans(const glm::quat& rot, const glm::vec3& trans) const; + glm::mat4 createFromScaleRotAndTrans(const glm::vec3& scale, const glm::quat& rot, const glm::vec3& trans) const; + + glm::vec3 extractTranslation(const glm::mat4& m) const; + glm::quat extractRotation(const glm::mat4& m) const; + glm::vec3 extractScale(const glm::mat4& m) const; + + glm::vec3 transformPoint(const glm::mat4& m, const glm::vec3& point) const; + glm::vec3 transformVector(const glm::mat4& m, const glm::vec3& vector) const; + + glm::mat4 inverse(const glm::mat4& m) const; + + glm::vec3 getFront(const glm::mat4& m) const; + glm::vec3 getRight(const glm::mat4& m) const; + glm::vec3 getUp(const glm::mat4& m) const; + + void print(const QString& label, const glm::mat4& m) const; +}; + +#endif // hifi_Mat4_h diff --git a/libraries/script-engine/src/ScriptEngine.cpp b/libraries/script-engine/src/ScriptEngine.cpp index 9ee2c374c5..61ebfe4515 100644 --- a/libraries/script-engine/src/ScriptEngine.cpp +++ b/libraries/script-engine/src/ScriptEngine.cpp @@ -315,6 +315,7 @@ void ScriptEngine::init() { registerGlobalObject("Entities", entityScriptingInterface.data()); registerGlobalObject("Quat", &_quatLibrary); registerGlobalObject("Vec3", &_vec3Library); + registerGlobalObject("Mat4", &_mat4Library); registerGlobalObject("Uuid", &_uuidLibrary); registerGlobalObject("AnimationCache", DependencyManager::get().data()); registerGlobalObject("Messages", DependencyManager::get().data()); diff --git a/libraries/script-engine/src/ScriptEngine.h b/libraries/script-engine/src/ScriptEngine.h index 91d4c3f5a5..8056a4f487 100644 --- a/libraries/script-engine/src/ScriptEngine.h +++ b/libraries/script-engine/src/ScriptEngine.h @@ -34,6 +34,7 @@ #include "ArrayBufferClass.h" #include "AudioScriptingInterface.h" #include "Quat.h" +#include "Mat4.h" #include "ScriptCache.h" #include "ScriptUUID.h" #include "Vec3.h" @@ -199,6 +200,7 @@ protected: QString _fileNameString; Quat _quatLibrary; Vec3 _vec3Library; + Mat4 _mat4Library; ScriptUUID _uuidLibrary; std::atomic _isUserLoaded { false }; bool _isReloading { false }; @@ -219,4 +221,4 @@ protected: static std::atomic _stoppingAllScripts; }; -#endif // hifi_ScriptEngine_h \ No newline at end of file +#endif // hifi_ScriptEngine_h diff --git a/libraries/shared/src/GLMHelpers.cpp b/libraries/shared/src/GLMHelpers.cpp index e9d6591cac..b2294f9ef3 100644 --- a/libraries/shared/src/GLMHelpers.cpp +++ b/libraries/shared/src/GLMHelpers.cpp @@ -376,6 +376,15 @@ glm::mat4 createMatFromQuatAndPos(const glm::quat& q, const glm::vec3& p) { return m; } +// create matrix from a non-uniform scale, orientation and position +glm::mat4 createMatFromScaleQuatAndPos(const glm::vec3& scale, const glm::quat& rot, const glm::vec3& trans) { + glm::vec3 xAxis = rot * glm::vec3(scale.x, 0.0f, 0.0f); + glm::vec3 yAxis = rot * glm::vec3(0.0f, scale.y, 0.0f); + glm::vec3 zAxis = rot * glm::vec3(0.0f, 0.0f, scale.z); + return glm::mat4(glm::vec4(xAxis, 0.0f), glm::vec4(yAxis, 0.0f), + glm::vec4(zAxis, 0.0f), glm::vec4(trans, 1.0f)); +} + // cancel out roll and pitch glm::quat cancelOutRollAndPitch(const glm::quat& q) { glm::vec3 zAxis = q * glm::vec3(0.0f, 0.0f, 1.0f); diff --git a/libraries/shared/src/GLMHelpers.h b/libraries/shared/src/GLMHelpers.h index 15f3f60cf7..4a37d68240 100644 --- a/libraries/shared/src/GLMHelpers.h +++ b/libraries/shared/src/GLMHelpers.h @@ -212,6 +212,7 @@ glm::detail::tvec4 lerp(const glm::detail::tvec4& x, const glm::deta } glm::mat4 createMatFromQuatAndPos(const glm::quat& q, const glm::vec3& p); +glm::mat4 createMatFromScaleQuatAndPos(const glm::vec3& scale, const glm::quat& rot, const glm::vec3& trans); glm::quat cancelOutRollAndPitch(const glm::quat& q); glm::mat4 cancelOutRollAndPitch(const glm::mat4& m); glm::vec3 transformPoint(const glm::mat4& m, const glm::vec3& p); diff --git a/libraries/shared/src/RegisteredMetaTypes.cpp b/libraries/shared/src/RegisteredMetaTypes.cpp index 94d9b0ae26..953fdb3582 100644 --- a/libraries/shared/src/RegisteredMetaTypes.cpp +++ b/libraries/shared/src/RegisteredMetaTypes.cpp @@ -34,6 +34,7 @@ static int collisionMetaTypeId = qRegisterMetaType(); static int qMapURLStringMetaTypeId = qRegisterMetaType>(); void registerMetaTypes(QScriptEngine* engine) { + qScriptRegisterMetaType(engine, mat4toScriptValue, mat4FromScriptValue); qScriptRegisterMetaType(engine, vec4toScriptValue, vec4FromScriptValue); qScriptRegisterMetaType(engine, vec3toScriptValue, vec3FromScriptValue); qScriptRegisterMetaType(engine, qVectorVec3ToScriptValue, qVectorVec3FromScriptValue); @@ -53,6 +54,46 @@ void registerMetaTypes(QScriptEngine* engine) { qScriptRegisterMetaType(engine, aaCubeToScriptValue, aaCubeFromScriptValue); } +QScriptValue mat4toScriptValue(QScriptEngine* engine, const glm::mat4& mat4) { + QScriptValue obj = engine->newObject(); + obj.setProperty("r0c0", mat4[0][0]); + obj.setProperty("r1c0", mat4[0][1]); + obj.setProperty("r2c0", mat4[0][2]); + obj.setProperty("r3c0", mat4[0][3]); + obj.setProperty("r0c1", mat4[1][0]); + obj.setProperty("r1c1", mat4[1][1]); + obj.setProperty("r2c1", mat4[1][2]); + obj.setProperty("r3c1", mat4[1][3]); + obj.setProperty("r0c2", mat4[2][0]); + obj.setProperty("r1c2", mat4[2][1]); + obj.setProperty("r2c2", mat4[2][2]); + obj.setProperty("r3c2", mat4[2][3]); + obj.setProperty("r0c3", mat4[3][0]); + obj.setProperty("r1c3", mat4[3][1]); + obj.setProperty("r2c3", mat4[3][2]); + obj.setProperty("r3c3", mat4[3][3]); + return obj; +} + +void mat4FromScriptValue(const QScriptValue& object, glm::mat4& mat4) { + mat4[0][0] = object.property("r0c0").toVariant().toFloat(); + mat4[0][1] = object.property("r1c0").toVariant().toFloat(); + mat4[0][2] = object.property("r2c0").toVariant().toFloat(); + mat4[0][3] = object.property("r3c0").toVariant().toFloat(); + mat4[1][0] = object.property("r0c1").toVariant().toFloat(); + mat4[1][1] = object.property("r1c1").toVariant().toFloat(); + mat4[1][2] = object.property("r2c1").toVariant().toFloat(); + mat4[1][3] = object.property("r3c1").toVariant().toFloat(); + mat4[2][0] = object.property("r0c2").toVariant().toFloat(); + mat4[2][1] = object.property("r1c2").toVariant().toFloat(); + mat4[2][2] = object.property("r2c2").toVariant().toFloat(); + mat4[2][3] = object.property("r3c2").toVariant().toFloat(); + mat4[3][0] = object.property("r0c3").toVariant().toFloat(); + mat4[3][1] = object.property("r1c3").toVariant().toFloat(); + mat4[3][2] = object.property("r2c3").toVariant().toFloat(); + mat4[3][3] = object.property("r3c3").toVariant().toFloat(); +} + QScriptValue vec4toScriptValue(QScriptEngine* engine, const glm::vec4& vec4) { QScriptValue obj = engine->newObject(); obj.setProperty("x", vec4.x); diff --git a/libraries/shared/src/RegisteredMetaTypes.h b/libraries/shared/src/RegisteredMetaTypes.h index 0a3e94a5b6..652ec26fe7 100644 --- a/libraries/shared/src/RegisteredMetaTypes.h +++ b/libraries/shared/src/RegisteredMetaTypes.h @@ -28,6 +28,7 @@ Q_DECLARE_METATYPE(glm::vec4) Q_DECLARE_METATYPE(glm::vec3) Q_DECLARE_METATYPE(glm::vec2) Q_DECLARE_METATYPE(glm::quat) +Q_DECLARE_METATYPE(glm::mat4) Q_DECLARE_METATYPE(xColor) Q_DECLARE_METATYPE(QVector) Q_DECLARE_METATYPE(QVector) @@ -35,6 +36,10 @@ Q_DECLARE_METATYPE(AACube) void registerMetaTypes(QScriptEngine* engine); +// Mat4 +QScriptValue mat4toScriptValue(QScriptEngine* engine, const glm::mat4& mat4); +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);