Merge branch 'master' of https://github.com/highfidelity/hifi into temp1

examples/libraries/entityPropertyDialogBox.js

@@ -54,6 +54,8 @@ EntityPropertyDialogBox = (function () {
             index++;
             array.push({ label: "Textures:", value: properties.textures });
             index++;
+            array.push({ label: "Original Textures:\n" + properties.originalTextures, type: "header" });
+            index++;
         }
         array.push({ label: "Position:", type: "header" });
         index++;
@@ -239,6 +241,7 @@ EntityPropertyDialogBox = (function () {
                 properties.animationFPS = array[index++].value;
                 properties.animationFrameIndex = array[index++].value;
                 properties.textures = array[index++].value;
+                index++; // skip textureNames label
             }
             index++; // skip header
             properties.position.x = array[index++].value;

interface/src/Application.cpp

@@ -416,6 +416,9 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
 
     _trayIcon->show();
     
+    // set the local loopback interface for local sounds from audio scripts
+    AudioScriptingInterface::getInstance().setLocalLoopbackInterface(&_audio);
+    
 #ifdef HAVE_RTMIDI
     // setup the MIDIManager
     MIDIManager& midiManagerInstance = MIDIManager::getInstance();

interface/src/Audio.cpp

@@ -184,9 +184,9 @@ QAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& de
         QAudioDeviceInfo::defaultOutputDevice();
 #else
     foreach(QAudioDeviceInfo audioDevice, QAudioDeviceInfo::availableDevices(mode)) {
-        qDebug() << audioDevice.deviceName() << " " << deviceName;
         if (audioDevice.deviceName().trimmed() == deviceName.trimmed()) {
             result = audioDevice;
+            break;
         }
     }
 #endif
@@ -1331,9 +1331,22 @@ void Audio::startDrumSound(float volume, float frequency, float duration, float
     _drumSoundSample = 0;
 }
 
-void Audio::handleAudioByteArray(const QByteArray& audioByteArray) {
+void Audio::handleAudioByteArray(const QByteArray& audioByteArray, const AudioInjectorOptions& injectorOptions) {
-    // TODO: either create a new audio device (up to the limit of the sound card or a hard limit)
+    if (audioByteArray.size() > 0) {
-    // or send to the mixer and use delayed loopback
+        QAudioFormat localFormat = _outputFormat;
+        
+        if (!injectorOptions.isStereo()) {
+            localFormat.setChannelCount(1);
+        }
+        
+        QAudioOutput* localSoundOutput = new QAudioOutput(getNamedAudioDeviceForMode(QAudio::AudioOutput, _outputAudioDeviceName), localFormat, this);
+        
+        QIODevice* localIODevice = localSoundOutput->start();
+        qDebug() << "Writing" << audioByteArray.size() << "to" << localIODevice;
+        localIODevice->write(audioByteArray);
+    } else {
+        qDebug() << "Audio::handleAudioByteArray called with an empty byte array. Sound is likely still downloading.";
+    }
 }
 
 void Audio::renderToolBox(int x, int y, bool boxed) {
@@ -1903,6 +1916,7 @@ bool Audio::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceInfo) {
             }
         }
     }
+    
     return supportedFormat;
 }
 
@@ -1961,6 +1975,7 @@ bool Audio::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDeviceInfo)
             supportedFormat = true;
         }
     }
+    
     return supportedFormat;
 }
 

interface/src/Audio.h

@@ -155,7 +155,7 @@ public slots:
     void selectAudioFilterBassCut();
     void selectAudioFilterSmiley();
 
-    virtual void handleAudioByteArray(const QByteArray& audioByteArray);
+    virtual void handleAudioByteArray(const QByteArray& audioByteArray, const AudioInjectorOptions& options);
 
     void sendDownstreamAudioStatsPacket();
 

interface/src/Hair.h

@@ -24,10 +24,10 @@
 const int HAIR_CONSTRAINTS = 2; 
 
 const int DEFAULT_HAIR_STRANDS = 20;
-const int DEFAULT_HAIR_LINKS = 10;
+const int DEFAULT_HAIR_LINKS = 11;
 const float DEFAULT_HAIR_RADIUS = 0.075f;
-const float DEFAULT_HAIR_LINK_LENGTH = 0.06f;
+const float DEFAULT_HAIR_LINK_LENGTH = 0.1f;
-const float DEFAULT_HAIR_THICKNESS = 0.025f;
+const float DEFAULT_HAIR_THICKNESS = 0.07f;
 const glm::vec3 DEFAULT_GRAVITY(0.0f, -9.8f, 0.0f);
 
 class Hair {

interface/src/entities/EntityTreeRenderer.cpp

@@ -61,11 +61,13 @@ EntityTreeRenderer::~EntityTreeRenderer() {
 
 void EntityTreeRenderer::clear() {
     OctreeRenderer::clear();
+    _entityScripts.clear();
 }
 
 void EntityTreeRenderer::init() {
     OctreeRenderer::init();
-    static_cast<EntityTree*>(_tree)->setFBXService(this);
+    EntityTree* entityTree = static_cast<EntityTree*>(_tree);
+    entityTree->setFBXService(this);
 
     if (_wantScripts) {
         _entitiesScriptEngine = new ScriptEngine(NO_SCRIPT, "Entities", 
@@ -77,6 +79,8 @@ void EntityTreeRenderer::init() {
     // first chance, we'll check for enter/leave entity events.    
     glm::vec3 avatarPosition = Application::getInstance()->getAvatar()->getPosition();
     _lastAvatarPosition = avatarPosition + glm::vec3(1.f, 1.f, 1.f);
+    
+    connect(entityTree, &EntityTree::deletingEntity, this, &EntityTreeRenderer::deletingEntity);
 }
 
 QScriptValue EntityTreeRenderer::loadEntityScript(const EntityItemID& entityItemID) {
@@ -762,4 +766,7 @@ void EntityTreeRenderer::mouseMoveEvent(QMouseEvent* event, unsigned int deviceI
     }
 }
 
+void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) {
+    _entityScripts.remove(entityID);
+}
 

interface/src/entities/EntityTreeRenderer.h

@@ -101,6 +101,9 @@ signals:
 
     void enterEntity(const EntityItemID& entityItemID);
     void leaveEntity(const EntityItemID& entityItemID);
+
+public slots:
+    void deletingEntity(const EntityItemID& entityID);
     
 private:
     QList<Model*> _releasedModels;

interface/src/entities/RenderableModelEntityItem.cpp

@@ -62,10 +62,21 @@ void RenderableModelEntityItem::remapTextures() {
         return; // nothing to do if we don't have a model
     }
     
+    if (!_model->isLoadedWithTextures()) {
+        return; // nothing to do if the model has not yet loaded it's default textures
+    }
+    
+    if (!_originalTexturesRead && _model->isLoadedWithTextures()) {
+        const QSharedPointer<NetworkGeometry>& networkGeometry = _model->getGeometry();
+        if (networkGeometry) {
+            _originalTextures = networkGeometry->getTextureNames();
+            _originalTexturesRead = true;
+        }
+    }
+    
     if (_currentTextures == _textures) {
         return; // nothing to do if our recently mapped textures match our desired textures
     }
-    qDebug() << "void RenderableModelEntityItem::remapTextures()....";
     
     // since we're changing here, we need to run through our current texture map
     // and any textures in the recently mapped texture, that is not in our desired
@@ -234,6 +245,14 @@ bool RenderableModelEntityItem::needsSimulation() const {
     return _needsInitialSimulation || simulationState == Moving || simulationState == Changing;
 }
 
+EntityItemProperties RenderableModelEntityItem::getProperties() const {
+    EntityItemProperties properties = ModelEntityItem::getProperties(); // get the properties from our base class
+    if (_originalTexturesRead) {
+        properties.setTextureNames(_originalTextures);
+    }
+    return properties;
+}
+
 
 
 

interface/src/entities/RenderableModelEntityItem.h

@@ -37,10 +37,12 @@ public:
         _model(NULL),
         _needsInitialSimulation(true),
         _needsModelReload(true),
-        _myRenderer(NULL) { }
+        _myRenderer(NULL),
+        _originalTexturesRead(false) { }
 
     virtual ~RenderableModelEntityItem();
 
+    virtual EntityItemProperties getProperties() const;
     virtual bool setProperties(const EntityItemProperties& properties, bool forceCopy);
     virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
                                                 ReadBitstreamToTreeParams& args,
@@ -59,6 +61,8 @@ private:
     bool _needsModelReload;
     EntityTreeRenderer* _myRenderer;
     QString _currentTextures;
+    QStringList _originalTextures;
+    bool _originalTexturesRead;
 };
 
 #endif // hifi_RenderableModelEntityItem_h

interface/src/renderer/GeometryCache.cpp

@@ -734,6 +734,32 @@ void NetworkGeometry::setTextureWithNameToURL(const QString& name, const QUrl& u
     }
 }
 
+QStringList NetworkGeometry::getTextureNames() const {
+    QStringList result;
+    for (int i = 0; i < _meshes.size(); i++) {
+        const NetworkMesh& mesh = _meshes[i];
+        for (int j = 0; j < mesh.parts.size(); j++) {
+            const NetworkMeshPart& part = mesh.parts[j];
+            
+            if (!part.diffuseTextureName.isEmpty()) {
+                QString textureURL = part.diffuseTexture->getURL().toString();
+                result << part.diffuseTextureName + ":" + textureURL;
+            }
+
+            if (!part.normalTextureName.isEmpty()) {
+                QString textureURL = part.normalTexture->getURL().toString();
+                result << part.normalTextureName + ":" + textureURL;
+            }
+
+            if (!part.specularTextureName.isEmpty()) {
+                QString textureURL = part.specularTexture->getURL().toString();
+                result << part.specularTextureName + ":" + textureURL;
+            }
+        }
+    }
+    return result;
+}
+
 /// Reads geometry in a worker thread.
 class GeometryReader : public QRunnable {
 public:

interface/src/renderer/GeometryCache.h

@@ -112,6 +112,7 @@ public:
     virtual void clearLoadPriority(const QPointer<QObject>& owner);
     
     void setTextureWithNameToURL(const QString& name, const QUrl& url);
+    QStringList getTextureNames() const;
     
 protected:
 

libraries/audio/src/AbstractAudioInterface.h

@@ -14,6 +14,8 @@
 
 #include <QtCore/QObject>
 
+#include "AudioInjectorOptions.h"
+
 class AbstractAudioInterface : public QObject {
     Q_OBJECT
 public:
@@ -22,7 +24,7 @@ public:
     virtual void startCollisionSound(float magnitude, float frequency, float noise, float duration, bool flashScreen) = 0;
     virtual void startDrumSound(float volume, float frequency, float duration, float decay) = 0;
 public slots:
-    virtual void handleAudioByteArray(const QByteArray& audioByteArray) = 0;
+    virtual void handleAudioByteArray(const QByteArray& audioByteArray, const AudioInjectorOptions& options) = 0;
 };
 
 Q_DECLARE_METATYPE(AbstractAudioInterface*)

libraries/audio/src/AudioInjector.cpp

@@ -62,14 +62,6 @@ void AudioInjector::injectAudio() {
     
     // make sure we actually have samples downloaded to inject
     if (soundByteArray.size()) {
-        // give our sample byte array to the local audio interface, if we have it, so it can be handled locally
-        if (_options.getLoopbackAudioInterface()) {
-            // assume that localAudioInterface could be on a separate thread, use Qt::AutoConnection to handle properly
-            QMetaObject::invokeMethod(_options.getLoopbackAudioInterface(), "handleAudioByteArray",
-                                      Qt::AutoConnection,
-                                      Q_ARG(QByteArray, soundByteArray));
-            
-        }
         
         // setup the packet for injected audio
         QByteArray injectAudioPacket = byteArrayWithPopulatedHeader(PacketTypeInjectAudio);
@@ -86,7 +78,7 @@ void AudioInjector::injectAudio() {
         packetStream << _options.isStereo();
         
         // pack the flag for loopback
-        uchar loopbackFlag = (uchar) (!_options.getLoopbackAudioInterface());
+        uchar loopbackFlag = (uchar) true;
         packetStream << loopbackFlag;
         
         // pack the position for injected audio

libraries/audio/src/AudioInjectorOptions.cpp

@@ -18,8 +18,7 @@ AudioInjectorOptions::AudioInjectorOptions(QObject* parent) :
     _loop(false),
     _orientation(glm::vec3(0.0f, 0.0f, 0.0f)),
     _isStereo(false),
-    _ignorePenumbra(false),
+    _ignorePenumbra(false)
-    _loopbackAudioInterface(NULL)
 {
 }
 
@@ -30,7 +29,6 @@ AudioInjectorOptions::AudioInjectorOptions(const AudioInjectorOptions& other) {
     _orientation = other._orientation;
     _isStereo = other._isStereo;
     _ignorePenumbra = other._ignorePenumbra;
-    _loopbackAudioInterface = other._loopbackAudioInterface;
 }
 
 void AudioInjectorOptions::operator=(const AudioInjectorOptions& other) {
@@ -40,5 +38,4 @@ void AudioInjectorOptions::operator=(const AudioInjectorOptions& other) {
     _orientation = other._orientation;
     _isStereo = other._isStereo;
     _ignorePenumbra = other._ignorePenumbra;
-    _loopbackAudioInterface = other._loopbackAudioInterface;
 }

libraries/audio/src/AudioInjectorOptions.h

@@ -19,8 +19,6 @@
 
 #include <RegisteredMetaTypes.h>
 
-#include "AbstractAudioInterface.h"
-
 class AudioInjectorOptions : public QObject {
     Q_OBJECT
     
@@ -53,9 +51,6 @@ public:
     const bool ignorePenumbra() const {return _ignorePenumbra; }
     void setIgnorePenumbra(bool ignorePenumbra) { _ignorePenumbra = ignorePenumbra; }
     
-    AbstractAudioInterface* getLoopbackAudioInterface() const { return _loopbackAudioInterface; }
-    void setLoopbackAudioInterface(AbstractAudioInterface* loopbackAudioInterface)
-        { _loopbackAudioInterface = loopbackAudioInterface; }
 private:
     glm::vec3 _position;
     float _volume;
@@ -63,7 +58,8 @@ private:
     glm::quat _orientation;
     bool _isStereo;
     bool _ignorePenumbra;
-    AbstractAudioInterface* _loopbackAudioInterface;
 };
 
+Q_DECLARE_METATYPE(AudioInjectorOptions)
+
 #endif // hifi_AudioInjectorOptions_h

libraries/audio/src/AudioScriptingInterface.cpp

@@ -16,6 +16,12 @@ AudioScriptingInterface& AudioScriptingInterface::getInstance() {
     return staticInstance;
 }
 
+AudioScriptingInterface::AudioScriptingInterface() :
+    _localLoopbackInterface(NULL)
+{
+    qRegisterMetaType<AudioInjectorOptions>("AudioInjectorOptions");
+}
+
 void AudioScriptingInterface::stopAllInjectors() {
     QList<QPointer<AudioInjector> >::iterator injector = _activeInjectors.begin();
     while (injector != _activeInjectors.end()) {
@@ -31,6 +37,18 @@ void AudioScriptingInterface::stopAllInjectors() {
     }
 }
 
+void AudioScriptingInterface::playLocalSound(Sound* sound, const AudioInjectorOptions* injectorOptions) {
+    if (sound->isStereo()) {
+        const_cast<AudioInjectorOptions*>(injectorOptions)->setIsStereo(true);
+    }
+    
+    // assume that localAudioInterface could be on a separate thread, use Qt::AutoConnection to handle properly
+    QMetaObject::invokeMethod(_localLoopbackInterface, "handleAudioByteArray",
+                              Qt::AutoConnection,
+                              Q_ARG(QByteArray, sound->getByteArray()),
+                              Q_ARG(const AudioInjectorOptions&, *injectorOptions));
+}
+
 AudioInjector* AudioScriptingInterface::playSound(Sound* sound, const AudioInjectorOptions* injectorOptions) {
     
     if (sound->isStereo()) {

libraries/audio/src/AudioScriptingInterface.h

@@ -14,6 +14,7 @@
 
 #include <qpointer.h>
 
+#include "AbstractAudioInterface.h"
 #include "AudioInjector.h"
 #include "Sound.h"
 
@@ -25,20 +26,23 @@ public:
     static AudioScriptingInterface& getInstance();
     
     void stopAllInjectors();
+    
+    void setLocalLoopbackInterface(AbstractAudioInterface* audioInterface) { _localLoopbackInterface = audioInterface; }
 public slots:
 
     static float getLoudness(AudioInjector* injector);
 
+    void playLocalSound(Sound *sound, const AudioInjectorOptions* injectorOptions = NULL);
     AudioInjector* playSound(Sound* sound, const AudioInjectorOptions* injectorOptions = NULL);
+    
     void stopInjector(AudioInjector* injector);
     bool isInjectorPlaying(AudioInjector* injector);
     
     void injectorStopped();
     
 private:
-    AudioScriptingInterface() {};
+    AudioScriptingInterface();
     QList< QPointer<AudioInjector> > _activeInjectors;
-
+    AbstractAudioInterface* _localLoopbackInterface;
-
 };
 #endif // hifi_AudioScriptingInterface_h

libraries/entities/src/EntityItemProperties.cpp

@@ -243,6 +243,9 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine) cons
     boundingBox.setProperty("dimensions", boundingBoxDimensions);
     COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(boundingBox, boundingBox); // gettable, but not settable
 
+    QString textureNamesList = _textureNames.join(",\n");
+    COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(originalTextures, textureNamesList); // gettable, but not settable
+
     return properties;
 }
 

libraries/entities/src/EntityItemProperties.h

@@ -285,6 +285,9 @@ public:
 
     const QString& getTextures() const { return _textures; }
     void setTextures(const QString& value) { _textures = value; _texturesChanged = true; }
+
+    const QStringList& getTextureNames() const { return _textureNames; }
+    void setTextureNames(const QStringList& value) { _textureNames = value; }
     
     void setLastEdited(quint64 usecTime) { _lastEdited = usecTime; }
 
@@ -381,6 +384,7 @@ private:
     // properties of model geometry. But these properties are not serialized like other properties.
     QVector<SittingPoint> _sittingPoints;
     glm::vec3 _naturalDimensions;
+    QStringList _textureNames;
 };
 Q_DECLARE_METATYPE(EntityItemProperties);
 QScriptValue EntityItemPropertiesToScriptValue(QScriptEngine* engine, const EntityItemProperties& properties);

libraries/entities/src/EntityTree.cpp

@@ -185,6 +185,8 @@ void EntityTree::trackDeletedEntity(const EntityItemID& entityID) {
 }
 
 void EntityTree::deleteEntity(const EntityItemID& entityID) {
+    emit deletingEntity(entityID);
+
     // NOTE: callers must lock the tree before using this method
     DeleteEntityOperator theOperator(this, entityID);
     recurseTreeWithOperator(&theOperator);
@@ -197,6 +199,7 @@ void EntityTree::deleteEntities(QSet<EntityItemID> entityIDs) {
     foreach(const EntityItemID& entityID, entityIDs) {
         // tell our delete operator about this entityID
         theOperator.addEntityIDToDeleteList(entityID);
+        emit deletingEntity(entityID);
     }
 
     recurseTreeWithOperator(&theOperator);

libraries/entities/src/EntityTree.h

@@ -141,6 +141,9 @@ public:
     void trackDeletedEntity(const EntityItemID& entityID);
 
     QList<EntityItem*>& getMovingEntities() { return _movingEntities; }
+    
+signals:
+    void deletingEntity(const EntityItemID& entityID);
 
 private:
 

libraries/networking/src/ResourceCache.h

@@ -123,6 +123,8 @@ public:
     void setCache(ResourceCache* cache) { _cache = cache; }
 
     Q_INVOKABLE void allReferencesCleared();
+    
+    const QUrl& getURL() const { return _url; }
 
 signals: