Merge branch 'master' of https://github.com/Geenz/hifi into 19514

interface/src/Application.cpp

@@ -62,6 +62,7 @@
 #include <UUID.h>
 #include <OctreeSceneStats.h>
 #include <LocalVoxelsList.h>
+#include <FstReader.h>
 
 #include "Application.h"
 #include "ClipboardScriptingInterface.h"
@@ -3460,7 +3461,10 @@ void Application::reloadAllScripts() {
 }
 
 void Application::uploadFST() {
-    _fstReader.zip();
+    FstReader reader;
+    if (reader.zip()) {
+        reader.send();
+    }
 }
 
 void Application::removeScriptName(const QString& fileNameString) {

interface/src/Application.h

@@ -28,7 +28,6 @@
 #include <ParticleEditPacketSender.h>
 #include <ScriptEngine.h>
 #include <OctreeQuery.h>
-#include <FstReader.h>
 
 #include "Audio.h"
 #include "BandwidthMeter.h"
@@ -479,8 +478,6 @@ private:
     TouchEvent _lastTouchEvent;
     
     Overlays _overlays;
-    
-    FstReader _fstReader;
 };
 
 #endif /* defined(__interface__Application__) */

interface/src/Menu.cpp

@@ -129,7 +129,10 @@ Menu::Menu() :
                                   this,
                                   SLOT(goTo()));
 
-
+    addDisabledActionAndSeparator(fileMenu, "Upload/Browse");
+    addActionToQMenuAndActionHash(fileMenu, MenuOption::UploaderAvatarHead, 0, Application::getInstance(), SLOT(uploadFST()));
+    addActionToQMenuAndActionHash(fileMenu, MenuOption::UploaderAvatarSkeleton, 0, Application::getInstance(), SLOT(uploadFST()));
+    
     addDisabledActionAndSeparator(fileMenu, "Settings");
     addActionToQMenuAndActionHash(fileMenu, MenuOption::SettingsImport, 0, this, SLOT(importSettings()));
     addActionToQMenuAndActionHash(fileMenu, MenuOption::SettingsExport, 0, this, SLOT(exportSettings()));
@@ -161,7 +164,6 @@ Menu::Menu() :
 
     QMenu* toolsMenu = addMenu("Tools");
     addActionToQMenuAndActionHash(toolsMenu, MenuOption::MetavoxelEditor, 0, this, SLOT(showMetavoxelEditor()));
-    addActionToQMenuAndActionHash(toolsMenu, MenuOption::FstUploader, 0, Application::getInstance(), SLOT(uploadFST()));
 
     _chatAction = addActionToQMenuAndActionHash(toolsMenu,
                                                 MenuOption::Chat,

interface/src/Menu.h

@@ -243,7 +243,6 @@ namespace MenuOption {
     const QString FirstPerson = "First Person";
     const QString FrameTimer = "Show Timer";
     const QString FrustumRenderMode = "Render Mode";
-    const QString FstUploader = "Upload .fst file";
     const QString Fullscreen = "Fullscreen";
     const QString FullscreenMirror = "Fullscreen Mirror";
     const QString GlowMode = "Cycle Glow Mode";
@@ -292,6 +291,8 @@ namespace MenuOption {
     const QString StopAllScripts = "Stop All Scripts";
     const QString TestPing = "Test Ping";
     const QString TransmitterDrive = "Transmitter Drive";
+    const QString UploaderAvatarHead = "Upload Avatar Head";
+    const QString UploaderAvatarSkeleton = "Upload Avatar Skeleton";
     const QString Quit =  "Quit";
     const QString Voxels = "Voxels";
     const QString VoxelMode = "Cycle Voxel Mode";

libraries/shared/src/AccountManager.cpp

@@ -13,6 +13,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QUrlQuery>
 #include <QtNetwork/QNetworkRequest>
+#include <QHttpMultiPart>
 
 #include "NodeList.h"
 #include "PacketHeaders.h"
@@ -99,21 +100,25 @@ void AccountManager::setAuthURL(const QUrl& authURL) {
 }
 
 void AccountManager::authenticatedRequest(const QString& path, QNetworkAccessManager::Operation operation,
-                                          const JSONCallbackParameters& callbackParams, const QByteArray& dataByteArray) {
+                                          const JSONCallbackParameters& callbackParams,
+                                          const QByteArray& dataByteArray,
+                                          QHttpMultiPart* dataMultiPart) {
     QMetaObject::invokeMethod(this, "invokedRequest",
                               Q_ARG(const QString&, path),
                               Q_ARG(QNetworkAccessManager::Operation, operation),
                               Q_ARG(const JSONCallbackParameters&, callbackParams),
-                              Q_ARG(const QByteArray&, dataByteArray));
+                              Q_ARG(const QByteArray&, dataByteArray),
+                              Q_ARG(QHttpMultiPart*, dataMultiPart));
 }
 
 void AccountManager::invokedRequest(const QString& path, QNetworkAccessManager::Operation operation,
-                                    const JSONCallbackParameters& callbackParams, const QByteArray& dataByteArray) {
-
+                                    const JSONCallbackParameters& callbackParams,
+                                    const QByteArray& dataByteArray, QHttpMultiPart* dataMultiPart) {
+    
     if (!_networkAccessManager) {
         _networkAccessManager = new QNetworkAccessManager(this);
     }
-
+    
     if (hasValidAccessToken()) {
         QNetworkRequest authenticatedRequest;
         
@@ -140,11 +145,18 @@ void AccountManager::invokedRequest(const QString& path, QNetworkAccessManager::
             case QNetworkAccessManager::PostOperation:
             case QNetworkAccessManager::PutOperation:
                 authenticatedRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-                
-                if (operation == QNetworkAccessManager::PostOperation) {
-                    networkReply = _networkAccessManager->post(authenticatedRequest, dataByteArray);
+                if (dataMultiPart) {
+                    if (operation == QNetworkAccessManager::PostOperation) {
+                        networkReply = _networkAccessManager->post(authenticatedRequest, dataMultiPart);
+                    } else {
+                        networkReply = _networkAccessManager->put(authenticatedRequest, dataMultiPart);
+                    }
                 } else {
-                    networkReply = _networkAccessManager->put(authenticatedRequest, dataByteArray);
+                    if (operation == QNetworkAccessManager::PostOperation) {
+                        networkReply = _networkAccessManager->post(authenticatedRequest, dataByteArray);
+                    } else {
+                        networkReply = _networkAccessManager->put(authenticatedRequest, dataByteArray);
+                    }
                 }
                 
                 break;

libraries/shared/src/AccountManager.h

@@ -39,7 +39,8 @@ public:
     void authenticatedRequest(const QString& path,
                               QNetworkAccessManager::Operation operation = QNetworkAccessManager::GetOperation,
                               const JSONCallbackParameters& callbackParams = JSONCallbackParameters(),
-                              const QByteArray& dataByteArray = QByteArray());
+                              const QByteArray& dataByteArray = QByteArray(),
+                              QHttpMultiPart* dataMultiPart = NULL);
     
     const QUrl& getAuthURL() const { return _authURL; }
     void setAuthURL(const QUrl& authURL);
@@ -77,7 +78,9 @@ private:
     void operator=(AccountManager const& other); // not implemented
     
     Q_INVOKABLE void invokedRequest(const QString& path, QNetworkAccessManager::Operation operation,
-                                    const JSONCallbackParameters& callbackParams, const QByteArray& dataByteArray);
+                                    const JSONCallbackParameters& callbackParams,
+                                    const QByteArray& dataByteArray,
+                                    QHttpMultiPart* dataMultiPart);
     
     QUrl _authURL;
     QNetworkAccessManager* _networkAccessManager;

libraries/shared/src/FstReader.cpp

@@ -10,16 +10,36 @@
 #include <QDebug>
 #include <QFile>
 #include <QTextStream>
-#include <QDir>
 #include <QFileDialog>
 #include <QStandardPaths>
+#include <QHttpMultiPart>
+#include <QVariant>
+
+#include "AccountManager.h"
 
 #include "FstReader.h"
 
-FstReader::FstReader() {
-    
+
+static const QString NAME_FIELD = "name";
+static const QString FILENAME_FIELD = "filename";
+static const QString TEXDIR_FIELD = "texdir";
+static const QString LOD_FIELD = "lod";
+
+static const QString MODEL_URL = "/api/v1/models";
+
+static const int MAX_SIZE = 10 * 1024 * 1024; // 10 MB
+
+FstReader::FstReader() :
+    _lodCount(-1),
+    _texturesCount(-1),
+    _readyToSend(false),
+    _dataMultiPart(new QHttpMultiPart(QHttpMultiPart::FormDataType))
+{
 }
 
+FstReader::~FstReader() {
+    delete _dataMultiPart;
+}
 
 bool FstReader::zip() {
     // File Dialog
@@ -34,12 +54,18 @@ bool FstReader::zip() {
         qDebug() << "[ERROR] Could not open FST file : " << fst.fileName();
         return false;
     }
+    
+    // Compress and copy the fst
+    if (!compressFile(QFileInfo(fst).filePath(), _zipDir.path() + "/" + QFileInfo(fst).fileName())) {
+        return false;
+    }
+    _totalSize += QFileInfo(fst).size();
+    if (!addPart(_zipDir.path() + "/" + QFileInfo(fst).fileName(),
+                 QString("fst"))) {
+        return false;
+    }
     qDebug() << "Reading FST file : " << QFileInfo(fst).filePath();
     
-    
-    QTemporaryDir tempRootDir(_zipDir.path() + "/" + QFileInfo(fst).baseName());
-    QDir rootDir(tempRootDir.path());
-    
     // Let's read through the FST file
     QTextStream stream(&fst);
     QList<QString> line;
@@ -49,59 +75,75 @@ bool FstReader::zip() {
             continue;
         }
         
+        if (_totalSize > MAX_SIZE) {
+            qDebug() << "[ERROR] Model too big, over " << MAX_SIZE << " Bytes.";
+            return false;
+        }
+        
         // according to what is read, we modify the command
-        if (line.first() == filenameField) {
-            QFileInfo fbx(QFileInfo(fst).path() + "/" + line.at(1));
+        if (line.first() == NAME_FIELD) {
+            QHttpPart textPart;
+            textPart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data;"
+                               " name=\"model_name\"");
+            textPart.setBody(line[1].toUtf8());
+            _dataMultiPart->append(textPart);
+        } else if (line.first() == FILENAME_FIELD) {
+            QFileInfo fbx(QFileInfo(fst).path() + "/" + line[1]);
             if (!fbx.exists() || !fbx.isFile()) { // Check existence
                 qDebug() << "[ERROR] FBX file " << fbx.absoluteFilePath() << " doesn't exist.";
                 return false;
-            } else if (fbx.size() > MAX_FBX_SIZE) { // Check size
-                qDebug() << "[ERROR] FBX file " << fbx.absoluteFilePath() << " too big, over " << MAX_FBX_SIZE << " MB.";
-                return false;
-            } else { // Compress and copy
-                compressFile(fbx.filePath(),
-                             rootDir.path() + "/" + line.at(1));
             }
-        } else if (line.first() == texdirField) { // Check existence
-            QFileInfo texdir(QFileInfo(fst).path() + "/" + line.at(1));
+            // Compress and copy
+            if (!compressFile(fbx.filePath(), _zipDir.path() + "/" + line[1])) {
+                return false;
+            }
+            _totalSize += fbx.size();
+            if (!addPart(_zipDir.path() + "/" + line[1], "fbx")) {
+                return false;
+            }
+        } else if (line.first() == TEXDIR_FIELD) { // Check existence
+            QFileInfo texdir(QFileInfo(fst).path() + "/" + line[1]);
             if (!texdir.exists() || !texdir.isDir()) {
                 qDebug() << "[ERROR] Texture directory " << texdir.absolutePath() << " doesn't exist.";
                 return false;
             }
-            QDir newTexdir(rootDir.canonicalPath() + "/" + line.at(1));
-            if (!newTexdir.exists() && !rootDir.mkpath(line.at(1))) { // Create texdir
-                qDebug() << "[ERROR] Couldn't create " << line.at(1) << ".";
+            if (!addTextures(texdir)) { // Recursive compress and copy
                 return false;
             }
-            if (!addTextures(texdir, newTexdir)) { // Recursive compress and copy
-                return false;
-            }
-        } else if (line.first() == lodField) {
-            QFileInfo lod(QFileInfo(fst).path() + "/" + line.at(1));
+        } else if (line.first() == LOD_FIELD) {
+            QFileInfo lod(QFileInfo(fst).path() + "/" + line[1]);
             if (!lod.exists() || !lod.isFile()) { // Check existence
                 qDebug() << "[ERROR] FBX file " << lod.absoluteFilePath() << " doesn't exist.";
                 return false;
-            } else if (lod.size() > MAX_FBX_SIZE) { // Check size
-                qDebug() << "[ERROR] FBX file " << lod.absoluteFilePath() << " too big, over " << MAX_FBX_SIZE << " MB.";\
+            }
+            // Compress and copy
+            if (!compressFile(lod.filePath(), _zipDir.path() + "/" + line[1])) {
+                return false;
+            }
+            _totalSize += lod.size();
+            if (!addPart(_zipDir.path() + "/" + line[1], QString("lod%1").arg(++_lodCount))) {
                 return false;
-            } else { // Compress and copy
-                compressFile(lod.filePath(), rootDir.path() + "/" + line.at(1));
             }
         }
     }
     
-    // Compress and copy the fst
-    compressFile(fst.fileName(),
-                 rootDir.path() + "/" + QFileInfo(fst).fileName());
+    _readyToSend = true;
+    return true;
+}
+
+bool FstReader::send() {
+    if (!_readyToSend) {
+        return false;
+    }
     
-    tempRootDir.setAutoRemove(false);
+    AccountManager::getInstance().authenticatedRequest(MODEL_URL, QNetworkAccessManager::PostOperation, JSONCallbackParameters(), QByteArray(), _dataMultiPart);
     
     return true;
 }
 
-bool FstReader::addTextures(QFileInfo& texdir, QDir newTexdir) {
+bool FstReader::addTextures(const QFileInfo& texdir) {
     QStringList filter;
-    filter << "*.png" << "*.tiff" << "*.jpg" << "*.jpeg";
+    filter << "*.png" << "*.tif" << "*.jpg" << "*.jpeg";
     
     QFileInfoList list = QDir(texdir.filePath()).entryInfoList(filter,
                                                                QDir::Files |
@@ -110,19 +152,17 @@ bool FstReader::addTextures(QFileInfo& texdir, QDir newTexdir) {
                                                                QDir::NoSymLinks);
     foreach (QFileInfo info, list) {
         if (info.isFile()) {
-            if (info.size() > MAX_TEXTURE_SIZE) {
-                qDebug() << "[ERROR] Texture " << info.absoluteFilePath()
-                         << "too big, file  over " << MAX_TEXTURE_SIZE << " Bytes.";
+            // Compress and copy
+            if (!compressFile(info.filePath(), _zipDir.path() + "/" + info.fileName())) {
+                return false;
+            }
+            _totalSize += info.size();
+            if (!addPart(_zipDir.path() + "/" + info.fileName(),
+                         QString("texture%1").arg(++_texturesCount))) {
                 return false;
             }
-            compressFile(info.canonicalFilePath(), newTexdir.path() + "/" + info.fileName());
         } else if (info.isDir()) {
-            if (newTexdir.mkdir(info.fileName())) {
-                qDebug() << "[ERROR] Couldn't create texdir.";
-                return false;
-            }
-            QDir texdirChild(newTexdir.canonicalPath() + "/" + info.fileName());
-            if (!addTextures(info, QDir(info.canonicalFilePath()))) {
+            if (!addTextures(info)) {
                 return false;
             }
         } else {
@@ -153,7 +193,24 @@ bool FstReader::compressFile(const QString &inFileName, const QString &outFileNa
 }
 
 
-
+bool FstReader::addPart(const QString &path, const QString& name) {
+    QFile* file = new QFile(path);
+    if (!file->open(QIODevice::ReadOnly)) {
+        qDebug() << "[ERROR] Couldn't open " << file->fileName();
+        return false;
+    }
+    
+    QHttpPart part;
+    part.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data;"
+                   " name=\"" + name.toUtf8() +  "\";"
+                   " filename=\"" + QFileInfo(*file).fileName().toUtf8() +  "\"");
+    part.setHeader(QNetworkRequest::ContentTypeHeader, "application/octet-stream");
+    part.setBodyDevice(file);
+    _dataMultiPart->append(part);
+    file->setParent(_dataMultiPart);
+    
+    return true;
+}
 
 
 

libraries/shared/src/FstReader.h

@@ -10,28 +10,31 @@
 #ifndef __hifi__FstReader__
 #define __hifi__FstReader__
 
-#include <QString>
-#include <QList>
 #include <QTemporaryDir>
 
-static const QString filenameField = "filename";
-static const QString texdirField = "texdir";
-static const QString lodField = "lod";
-
-static const int MAX_FBX_SIZE = 1024 * 1024; // 1 MB
-static const int MAX_TEXTURE_SIZE = 1024 * 1024; // 1 MB
+class QHttpMultiPart;
 
 class FstReader {
 public:
     FstReader();
+    ~FstReader();
     
     bool zip();
+    bool send();
     
 private:
     QTemporaryDir _zipDir;
+    int _lodCount;
+    int _texturesCount;
+    int _totalSize;
+    bool _readyToSend;
     
-    bool addTextures(QFileInfo& texdir, QDir newTexdir);
+    QHttpMultiPart* _dataMultiPart;
+    
+    
+    bool addTextures(const QFileInfo& texdir);
     bool compressFile(const QString& inFileName, const QString& outFileName);
+    bool addPart(const QString& path, const QString& name);
 };
 
 #endif /* defined(__hifi__FstReader__) */