isolate calls to the QtScript libraries to an interface we control

Heather Anderson committed 5 years ago

Commit 1e018db1 parent 713b29e260 files · +6904 −5064Browse files

Showing the changes to libraries/script-engine/src/ModelScriptingInterface.cpp (1 of 260 files). Show all

Unified · Split

libraries/script-engine/src/ModelScriptingInterface.cpp+24−24

 //
 #include "ModelScriptingInterface.h"
-#include <QtScript/QScriptEngine>
-#include <QtScript/QScriptValueIterator>
-#include <QtScript/QScriptValue>
 #include <model-networking/SimpleMeshProxy.h>
 #include "ScriptEngine.h"
+#include "ScriptEngineCast.h"
 #include "ScriptEngineLogging.h"
+#include "ScriptManager.h"
+#include "ScriptValueUtils.h"
 #include "OBJWriter.h"
 ModelScriptingInterface::ModelScriptingInterface(QObject* parent) : QObject(parent) {
-    _modelScriptEngine = qobject_cast<QScriptEngine*>(parent);
+    _modelScriptEngine = qobject_cast<ScriptManager*>(parent)->engine();
-    qScriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine);
+    scriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine.get());
-    qScriptRegisterMetaType(_modelScriptEngine, meshFaceToScriptValue, meshFaceFromScriptValue);
+    scriptRegisterMetaType(_modelScriptEngine.get(), meshFaceToScriptValue, meshFaceFromScriptValue);
-    qScriptRegisterMetaType(_modelScriptEngine, qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue);
+    scriptRegisterMetaType(_modelScriptEngine.get(), qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue);
 }
 QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) {
     return writeOBJToString(meshes);
 }
-QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
+ScriptValuePointer ModelScriptingInterface::appendMeshes(MeshProxyList in) {
     // figure out the size of the resulting mesh
     size_t totalVertexCount { 0 };
     size_t totalColorCount { 0 };
     MeshProxy* resultProxy = new SimpleMeshProxy(result);
-    return meshToScriptValue(_modelScriptEngine, resultProxy);
+    return meshToScriptValue(_modelScriptEngine.get(), resultProxy);
 }
-QScriptValue ModelScriptingInterface::transformMesh(glm::mat4 transform, MeshProxy* meshProxy) {
+ScriptValuePointer ModelScriptingInterface::transformMesh(glm::mat4 transform, MeshProxy* meshProxy) {
     if (!meshProxy) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     MeshPointer mesh = meshProxy->getMeshPointer();
     if (!mesh) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     const auto inverseTransposeTransform = glm::inverse(glm::transpose(transform));
                                           [&](glm::vec3 normal){ return glm::vec3(inverseTransposeTransform * glm::vec4(normal, 0.0f)); },
                                           [&](uint32_t index){ return index; });
     MeshProxy* resultProxy = new SimpleMeshProxy(result);
-    return meshToScriptValue(_modelScriptEngine, resultProxy);
+    return meshToScriptValue(_modelScriptEngine.get(), resultProxy);
 }
-QScriptValue ModelScriptingInterface::getVertexCount(MeshProxy* meshProxy) {
+ScriptValuePointer ModelScriptingInterface::getVertexCount(MeshProxy* meshProxy) {
     if (!meshProxy) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     MeshPointer mesh = meshProxy->getMeshPointer();
     if (!mesh) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     gpu::BufferView::Index numVertices = (gpu::BufferView::Index)mesh->getNumVertices();
-    return numVertices;
+    return _modelScriptEngine->newValue(numVertices);
 }
-QScriptValue ModelScriptingInterface::getVertex(MeshProxy* meshProxy, int vertexIndex) {
+ScriptValuePointer ModelScriptingInterface::getVertex(MeshProxy* meshProxy, int vertexIndex) {
     if (!meshProxy) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     MeshPointer mesh = meshProxy->getMeshPointer();
     if (!mesh) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     const gpu::BufferView& vertexBufferView = mesh->getVertexBuffer();
     gpu::BufferView::Index numVertices = (gpu::BufferView::Index)mesh->getNumVertices();
     if (vertexIndex < 0 || vertexIndex >= numVertices) {
-        return QScriptValue(false);
+        return ScriptValuePointer(false);
     }
     glm::vec3 pos = vertexBufferView.get<glm::vec3>(vertexIndex);
-    return vec3ToScriptValue(_modelScriptEngine, pos);
+    return vec3ToScriptValue(_modelScriptEngine.get(), pos);
 }
-QScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
+ScriptValuePointer ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
                                               const QVector<glm::vec3>& normals,
                                               const QVector<MeshFace>& faces) {
     graphics::MeshPointer mesh(std::make_shared<graphics::Mesh>());
     MeshProxy* meshProxy = new SimpleMeshProxy(mesh);
-    return meshToScriptValue(_modelScriptEngine, meshProxy);
+    return meshToScriptValue(_modelScriptEngine.get(), meshProxy);
 }