new javascript call: Model.newMesh()

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h

@@ -66,7 +66,7 @@ public:
     void render(RenderArgs* args) override;
     virtual bool supportsDetailedRayIntersection() const override { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                        bool& keepSearching, OctreeElementPointer& element, float& distance, 
+                        bool& keepSearching, OctreeElementPointer& element, float& distance,
                         BoxFace& face, glm::vec3& surfaceNormal,
                         void** intersectedObject, bool precisionPicking) const override;
 

libraries/model/src/model/MeshFace.cpp

@@ -0,0 +1,44 @@
+//
+//  MeshFace.cpp
+//  libraries/model/src/model/
+//
+//  Created by Seth Alves on 2017-3-23
+//  Copyright 2017 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 <RegisteredMetaTypes.h>
+
+#include "MeshFace.h"
+
+
+QScriptValue meshFaceToScriptValue(QScriptEngine* engine, const MeshFace &meshFace) {
+    QScriptValue obj = engine->newObject();
+    obj.setProperty("vertices", qVectorIntToScriptValue(engine, meshFace.vertexIndices));
+    return obj;
+}
+
+void meshFaceFromScriptValue(const QScriptValue &object, MeshFace& meshFaceResult) {
+    qVectorIntFromScriptValue(object.property("vertices"), meshFaceResult.vertexIndices);
+}
+
+QScriptValue qVectorMeshFaceToScriptValue(QScriptEngine* engine, const QVector<MeshFace>& vector) {
+    QScriptValue array = engine->newArray();
+    for (int i = 0; i < vector.size(); i++) {
+        array.setProperty(i, meshFaceToScriptValue(engine, vector.at(i)));
+    }
+    return array;
+}
+
+void qVectorMeshFaceFromScriptValue(const QScriptValue& array, QVector<MeshFace>& result) {
+    int length = array.property("length").toInteger();
+    result.clear();
+
+    for (int i = 0; i < length; i++) {
+        MeshFace meshFace = MeshFace();
+        meshFaceFromScriptValue(array.property(i), meshFace);
+        result << meshFace;
+    }
+}

libraries/model/src/model/MeshFace.h

@@ -0,0 +1,43 @@
+//
+//  MeshFace.h
+//  libraries/model/src/model/
+//
+//  Created by Seth Alves on 2017-3-23
+//  Copyright 2017 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
+//
+
+#ifndef hifi_MeshFace_h
+#define hifi_MeshFace_h
+
+#include <QScriptEngine>
+#include <QScriptValueIterator>
+#include <QtScript/QScriptValue>
+
+#include "Geometry.h"
+
+using MeshPointer = std::shared_ptr<model::Mesh>;
+
+class MeshFace {
+
+public:
+    MeshFace() {}
+    ~MeshFace() {}
+
+    QVector<uint32_t> vertexIndices;
+    // TODO -- material...
+};
+
+Q_DECLARE_METATYPE(MeshFace)
+Q_DECLARE_METATYPE(QVector<MeshFace>)
+
+QScriptValue meshFaceToScriptValue(QScriptEngine* engine, const MeshFace &meshFace);
+void meshFaceFromScriptValue(const QScriptValue &object, MeshFace& meshFaceResult);
+QScriptValue qVectorMeshFaceToScriptValue(QScriptEngine* engine, const QVector<MeshFace>& vector);
+void qVectorMeshFaceFromScriptValue(const QScriptValue& array, QVector<MeshFace>& result);
+
+
+
+#endif // hifi_MeshFace_h

libraries/script-engine/src/ModelScriptingInterface.cpp

@@ -12,7 +12,9 @@
 #include <QScriptEngine>
 #include <QScriptValueIterator>
 #include <QtScript/QScriptValue>
+#include <model/MeshFace.h>
 #include "ScriptEngine.h"
+#include "ScriptEngineLogging.h"
 #include "ModelScriptingInterface.h"
 #include "OBJWriter.h"
 
@@ -20,6 +22,8 @@ ModelScriptingInterface::ModelScriptingInterface(QObject* parent) : QObject(pare
     _modelScriptEngine = qobject_cast<ScriptEngine*>(parent);
 
     qScriptRegisterSequenceMetaType<QList<MeshProxy*>>(_modelScriptEngine);
+    qScriptRegisterMetaType(_modelScriptEngine, meshFaceToScriptValue, meshFaceFromScriptValue);
+    qScriptRegisterMetaType(_modelScriptEngine, qVectorMeshFaceToScriptValue, qVectorMeshFaceFromScriptValue);
 }
 
 QString ModelScriptingInterface::meshToOBJ(MeshProxyList in) {
@@ -118,8 +122,6 @@ QScriptValue ModelScriptingInterface::appendMeshes(MeshProxyList in) {
     return meshToScriptValue(_modelScriptEngine, resultProxy);
 }
 
-
-
 QScriptValue ModelScriptingInterface::transformMesh(glm::mat4 transform, MeshProxy* meshProxy) {
     if (!meshProxy) {
         return QScriptValue(false);
@@ -135,3 +137,57 @@ QScriptValue ModelScriptingInterface::transformMesh(glm::mat4 transform, MeshPro
     MeshProxy* resultProxy = new MeshProxy(result);
     return meshToScriptValue(_modelScriptEngine, resultProxy);
 }
+
+QScriptValue ModelScriptingInterface::newMesh(const QVector<glm::vec3>& vertices,
+                                              const QVector<glm::vec3>& normals,
+                                              const QVector<MeshFace>& faces) {
+    model::MeshPointer mesh(new model::Mesh());
+
+    // vertices
+    auto vertexBuffer = std::make_shared<gpu::Buffer>(vertices.size() * sizeof(glm::vec3), (gpu::Byte*)vertices.data());
+    auto vertexBufferPtr = gpu::BufferPointer(vertexBuffer);
+    gpu::BufferView vertexBufferView(vertexBufferPtr, 0, vertexBufferPtr->getSize(),
+                                     sizeof(glm::vec3), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
+    mesh->setVertexBuffer(vertexBufferView);
+
+    if (vertices.size() == normals.size()) {
+        // normals
+        auto normalBuffer = std::make_shared<gpu::Buffer>(normals.size() * sizeof(glm::vec3), (gpu::Byte*)normals.data());
+        auto normalBufferPtr = gpu::BufferPointer(normalBuffer);
+        gpu::BufferView normalBufferView(normalBufferPtr, 0, normalBufferPtr->getSize(),
+                                         sizeof(glm::vec3), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
+        mesh->addAttribute(gpu::Stream::NORMAL, normalBufferView);
+    } else {
+        qCDebug(scriptengine) << "ModelScriptingInterface::newMesh normals must be same length as vertices";
+    }
+
+    // indices (faces)
+    int VERTICES_PER_TRIANGLE = 3;
+    int indexBufferSize = faces.size() * sizeof(uint32_t) * VERTICES_PER_TRIANGLE;
+    unsigned char* indexData  = new unsigned char[indexBufferSize];
+    unsigned char* indexDataCursor = indexData;
+    foreach(const MeshFace& meshFace, faces) {
+        for (int i = 0; i < VERTICES_PER_TRIANGLE; i++) {
+            memcpy(indexDataCursor, &meshFace.vertexIndices[i], sizeof(uint32_t));
+            indexDataCursor += sizeof(uint32_t);
+        }
+    }
+    auto indexBuffer = std::make_shared<gpu::Buffer>(indexBufferSize, (gpu::Byte*)indexData);
+    auto indexBufferPtr = gpu::BufferPointer(indexBuffer);
+    gpu::BufferView indexBufferView(indexBufferPtr, gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW));
+    mesh->setIndexBuffer(indexBufferView);
+
+    // parts
+    std::vector<model::Mesh::Part> parts;
+    parts.emplace_back(model::Mesh::Part((model::Index)0, // startIndex
+                                         (model::Index)faces.size() * 3, // numIndices
+                                         (model::Index)0, // baseVertex
+                                         model::Mesh::TRIANGLES)); // topology
+    mesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(parts.size() * sizeof(model::Mesh::Part),
+                                                        (gpu::Byte*) parts.data()), gpu::Element::PART_DRAWCALL));
+
+
+
+    MeshProxy* meshProxy = new MeshProxy(mesh);
+    return meshToScriptValue(_modelScriptEngine, meshProxy);
+}

libraries/script-engine/src/ModelScriptingInterface.h

@@ -18,6 +18,7 @@
 #include <OBJWriter.h>
 #include <model/Geometry.h>
 #include <model/MeshProxy.h>
+#include <model/MeshFace.h>
 
 using MeshPointer = std::shared_ptr<model::Mesh>;
 class ScriptEngine;
@@ -31,6 +32,9 @@ public:
     Q_INVOKABLE QString meshToOBJ(MeshProxyList in);
     Q_INVOKABLE QScriptValue appendMeshes(MeshProxyList in);
     Q_INVOKABLE QScriptValue transformMesh(glm::mat4 transform, MeshProxy* meshProxy);
+    Q_INVOKABLE QScriptValue newMesh(const QVector<glm::vec3>& vertices,
+                                     const QVector<glm::vec3>& normals,
+                                     const QVector<MeshFace>& faces);
 
 private:
     ScriptEngine* _modelScriptEngine { nullptr };

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -43,6 +43,7 @@ void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, qVectorQuatToScriptValue, qVectorQuatFromScriptValue);
     qScriptRegisterMetaType(engine, qVectorBoolToScriptValue, qVectorBoolFromScriptValue);
     qScriptRegisterMetaType(engine, qVectorFloatToScriptValue, qVectorFloatFromScriptValue);
+    qScriptRegisterMetaType(engine, qVectorIntToScriptValue, qVectorIntFromScriptValue);
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, qRectToScriptValue, qRectFromScriptValue);
@@ -386,6 +387,15 @@ QScriptValue qVectorFloatToScriptValue(QScriptEngine* engine, const QVector<floa
     return array;
 }
 
+QScriptValue qVectorIntToScriptValue(QScriptEngine* engine, const QVector<uint32_t>& vector) {
+    QScriptValue array = engine->newArray();
+    for (int i = 0; i < vector.size(); i++) {
+        int num = vector.at(i);
+        array.setProperty(i, QScriptValue(num));
+    }
+    return array;
+}
+
 void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vector) {
     int length = array.property("length").toInteger();
     
@@ -393,6 +403,15 @@ void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vect
         vector << array.property(i).toVariant().toFloat();
     }
 }
+
+void qVectorIntFromScriptValue(const QScriptValue& array, QVector<uint32_t>& vector) {
+    int length = array.property("length").toInteger();
+
+    for (int i = 0; i < length; i++) {
+        vector << array.property(i).toVariant().toInt();
+    }
+}
+
 //
 QVector<glm::vec3> qVectorVec3FromScriptValue(const QScriptValue& array){
     QVector<glm::vec3> newVector;

libraries/shared/src/RegisteredMetaTypes.h

@@ -113,6 +113,10 @@ QScriptValue qVectorFloatToScriptValue(QScriptEngine* engine, const QVector<floa
 void qVectorFloatFromScriptValue(const QScriptValue& array, QVector<float>& vector);
 QVector<float> qVectorFloatFromScriptValue(const QScriptValue& array);
 
+// vector<uint32_t>
+QScriptValue qVectorIntToScriptValue(QScriptEngine* engine, const QVector<uint32_t>& vector);
+void qVectorIntFromScriptValue(const QScriptValue& array, QVector<uint32_t>& vector);
+
 QVector<QUuid> qVectorQUuidFromScriptValue(const QScriptValue& array);
 
 QScriptValue aaCubeToScriptValue(QScriptEngine* engine, const AACube& aaCube);