diff --git a/libraries/fbx/src/FBXReader_Node.cpp b/libraries/fbx/src/FBXReader_Node.cpp
index a6fba5a4d5..68e9d6abac 100644
--- a/libraries/fbx/src/FBXReader_Node.cpp
+++ b/libraries/fbx/src/FBXReader_Node.cpp
@@ -9,17 +9,20 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-#include <iostream>
-#include <QBuffer>
-#include <QDataStream>
-#include <QIODevice>
-#include <QStringList>
-#include <QTextStream>
-#include <QtDebug>
-#include <QtEndian>
-#include <QFileInfo>
 #include "FBXReader.h"
 
+#include <iostream>
+#include <QtCore/QBuffer>
+#include <QtCore/QDataStream>
+#include <QtCore/QIODevice>
+#include <QtCore/QStringList>
+#include <QtCore/QTextStream>
+#include <QtCore/QDebug>
+#include <QtCore/QtEndian>
+#include <QtCore/QFileInfo>
+
+#include <shared/NsightHelpers.h>
+
 template<class T> int streamSize() {
     return sizeof(T);
 }
@@ -299,6 +302,7 @@ FBXNode parseTextFBXNode(Tokenizer& tokenizer) {
 }
 
 FBXNode FBXReader::parseFBX(QIODevice* device) {
+    PROFILE_RANGE_EX(__FUNCTION__, 0xff0000ff, device);
     // verify the prolog
     const QByteArray BINARY_PROLOG = "Kaydara FBX Binary  ";
     if (device->peek(BINARY_PROLOG.size()) != BINARY_PROLOG) {
diff --git a/libraries/fbx/src/OBJReader.cpp b/libraries/fbx/src/OBJReader.cpp
index c28d680fb0..84c6c7aaa4 100644
--- a/libraries/fbx/src/OBJReader.cpp
+++ b/libraries/fbx/src/OBJReader.cpp
@@ -12,17 +12,20 @@
 // http://www.scratchapixel.com/old/lessons/3d-advanced-lessons/obj-file-format/obj-file-format/
 // http://paulbourke.net/dataformats/obj/
 
+#include "OBJReader.h"
 
-#include <QBuffer>
-#include <QIODevice>
-#include <QtNetwork/QNetworkAccessManager>
-#include <QtNetwork/QNetworkRequest>
-#include <QEventLoop>
 #include <ctype.h>  // .obj files are not locale-specific. The C/ASCII charset applies.
 
+#include <QtCore/QBuffer>
+#include <QtCore/QIODevice>
+#include <QtCore/QEventLoop>
+#include <QtNetwork/QNetworkAccessManager>
+#include <QtNetwork/QNetworkRequest>
+
+#include <shared/NsightHelpers.h>
 #include <NetworkAccessManager.h>
+
 #include "FBXReader.h"
-#include "OBJReader.h"
 #include "ModelFormatLogging.h"
 
 QHash<QString, float> COMMENT_SCALE_HINTS = {{"This file uses centimeters as units", 1.0f / 100.0f},
@@ -404,7 +407,7 @@ done:
 
 
 FBXGeometry* OBJReader::readOBJ(QByteArray& model, const QVariantHash& mapping, const QUrl& url) {
-
+    PROFILE_RANGE_EX(__FUNCTION__, 0xffff0000, nullptr);
     QBuffer buffer { &model };
     buffer.open(QIODevice::ReadOnly);
 
diff --git a/libraries/gpu/src/gpu/GLBackendTexture.cpp b/libraries/gpu/src/gpu/GLBackendTexture.cpp
index 3fc7906285..242b9100e1 100755
--- a/libraries/gpu/src/gpu/GLBackendTexture.cpp
+++ b/libraries/gpu/src/gpu/GLBackendTexture.cpp
@@ -10,6 +10,7 @@
 //
 #include "GPULogging.h"
 #include "GLBackendShared.h"
+#include "GLTexelFormat.h"
 
 using namespace gpu;
 
@@ -36,369 +37,6 @@ void GLBackend::GLTexture::setSize(GLuint size) {
     _size = size;
 }
 
-class GLTexelFormat {
-public:
-    GLenum internalFormat;
-    GLenum format;
-    GLenum type;
-
-    static GLTexelFormat evalGLTexelFormat(const Element& dstFormat, const Element& srcFormat) {
-        if (dstFormat != srcFormat) {
-            GLTexelFormat texel = {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE};
-
-            switch(dstFormat.getDimension()) {
-            case gpu::SCALAR: {
-                texel.format = GL_RED;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RED;
-                    break;
-                case gpu::DEPTH:
-                    texel.internalFormat = GL_DEPTH_COMPONENT;
-                    break;
-                case gpu::DEPTH_STENCIL:
-                    texel.type = GL_UNSIGNED_INT_24_8;
-                    texel.format = GL_DEPTH_STENCIL;
-                    texel.internalFormat = GL_DEPTH24_STENCIL8;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-                break;
-            }
-
-            case gpu::VEC2: {
-                texel.format = GL_RG;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RG;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-
-                break;
-            }
-
-            case gpu::VEC3: {
-                texel.format = GL_RGB;
-
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RGB;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-
-                break;
-            }
-
-            case gpu::VEC4: {
-                texel.format = GL_RGBA;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(srcFormat.getSemantic()) {
-                case gpu::BGRA:
-                case gpu::SBGRA:
-                    texel.format = GL_BGRA;
-                    break; 
-                case gpu::RGB:
-                case gpu::RGBA:
-                case gpu::SRGB:
-                case gpu::SRGBA:
-                default:
-                    break;
-                };
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                    texel.internalFormat = GL_RGB;
-                    break;
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RGBA;
-                    break;
-                case gpu::SRGB:
-                    texel.internalFormat = GL_SRGB;
-                    break;
-                case gpu::SRGBA:
-                    texel.internalFormat = GL_SRGB_ALPHA;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-                break;
-            }
-
-            default:
-                qCDebug(gpulogging) << "Unknown combination of texel format";
-            }
-            return texel;
-        } else {
-            GLTexelFormat texel = {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE};
-
-            switch(dstFormat.getDimension()) {
-            case gpu::SCALAR: {
-                texel.format = GL_RED;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                case gpu::SRGB:
-                case gpu::SRGBA:
-                    texel.internalFormat = GL_RED;
-                    switch (dstFormat.getType()) {
-                        case gpu::UINT32: {
-                            texel.internalFormat = GL_R32UI;
-                            break;
-                            }
-                        case gpu::INT32: {
-                            texel.internalFormat = GL_R32I;
-                            break;
-                            }
-                        case gpu::NUINT32: {
-                            texel.internalFormat = GL_RED;
-                            break;
-                            }
-                        case gpu::NINT32: {
-                            texel.internalFormat = GL_RED_SNORM;
-                            break;
-                            }
-                        case gpu::FLOAT: {
-                            texel.internalFormat = GL_R32F;
-                            break;
-                            }
-                        case gpu::UINT16: {
-                            texel.internalFormat = GL_R16UI;
-                            break;
-                            }
-                        case gpu::INT16: {
-                            texel.internalFormat = GL_R16I;
-                            break;
-                            }
-                        case gpu::NUINT16: {
-                            texel.internalFormat = GL_R16;
-                            break;
-                            }
-                        case gpu::NINT16: {
-                            texel.internalFormat = GL_R16_SNORM;
-                            break;
-                            }
-                        case gpu::HALF: {
-                            texel.internalFormat = GL_R16F;
-                            break;
-                            }
-                        case gpu::UINT8: {
-                            texel.internalFormat = GL_R8UI;
-                            break;
-                            }
-                        case gpu::INT8: {
-                            texel.internalFormat = GL_R8I;
-                            break;
-                            }
-                        case gpu::NUINT8: {
-                            if ((dstFormat.getSemantic() == gpu::SRGB || dstFormat.getSemantic() == gpu::SRGBA)) {
-                                texel.internalFormat = GL_SLUMINANCE;
-                            } else {
-                                texel.internalFormat = GL_R8;
-                            }
-                            break;
-                            }
-                        case gpu::NINT8: {
-                            texel.internalFormat = GL_R8_SNORM;
-                            break;
-                            }
-                        case gpu::NUM_TYPES: { // quiet compiler
-                            Q_UNREACHABLE();
-                            }
-                        
-                    }
-                    break;
-
-                case gpu::R11G11B10:
-                    texel.format = GL_RGB;
-                    // the type should be float
-                    texel.internalFormat = GL_R11F_G11F_B10F;
-                    break;
-
-                case gpu::DEPTH:
-                    texel.format = GL_DEPTH_COMPONENT; // It's depth component to load it
-                    texel.internalFormat = GL_DEPTH_COMPONENT;
-                    switch (dstFormat.getType()) {
-                    case gpu::UINT32:
-                    case gpu::INT32:
-                    case gpu::NUINT32:
-                    case gpu::NINT32: {
-                        texel.internalFormat = GL_DEPTH_COMPONENT32;
-                        break;
-                        }
-                    case gpu::FLOAT: {
-                        texel.internalFormat = GL_DEPTH_COMPONENT32F;
-                       break;
-                    }
-                    case gpu::UINT16:
-                    case gpu::INT16:
-                    case gpu::NUINT16:
-                    case gpu::NINT16:
-                    case gpu::HALF: {
-                        texel.internalFormat = GL_DEPTH_COMPONENT16;
-                        break;
-                        }
-                    case gpu::UINT8:
-                    case gpu::INT8:
-                    case gpu::NUINT8:
-                    case gpu::NINT8: {
-                        texel.internalFormat = GL_DEPTH_COMPONENT24;
-                        break;
-                        }
-                    case gpu::NUM_TYPES: { // quiet compiler
-                        Q_UNREACHABLE();
-                    }
-                    }
-                    break;
-                case gpu::DEPTH_STENCIL:
-                    texel.type = GL_UNSIGNED_INT_24_8;
-                    texel.format = GL_DEPTH_STENCIL;
-                    texel.internalFormat = GL_DEPTH24_STENCIL8;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-
-                break;
-            }
-
-            case gpu::VEC2: {
-                texel.format = GL_RG;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RG;
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-
-                break;
-            }
-
-            case gpu::VEC3: {
-                texel.format = GL_RGB;
-
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RGB;
-                    break;
-                case gpu::SRGB:
-                case gpu::SRGBA:
-                    texel.internalFormat = GL_SRGB; // standard 2.2 gamma correction color
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-                break;
-            }
-
-            case gpu::VEC4: {
-                texel.format = GL_RGBA;
-                texel.type = _elementTypeToGLType[dstFormat.getType()];
-
-                switch(dstFormat.getSemantic()) {
-                case gpu::RGB:
-                    texel.internalFormat = GL_RGB;
-                    break;
-                case gpu::RGBA:
-                    texel.internalFormat = GL_RGBA;
-                    switch (dstFormat.getType()) {
-                    case gpu::UINT32:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA32UI;
-                        break;
-                    case gpu::INT32:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA32I;
-                        break;
-                    case gpu::FLOAT:
-                        texel.internalFormat = GL_RGBA32F;
-                        break;
-                    case gpu::UINT16:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA16UI;
-                        break;
-                    case gpu::INT16:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA16I;
-                        break;
-                    case gpu::NUINT16:
-                        texel.format = GL_RGBA;
-                        texel.internalFormat = GL_RGBA16;
-                        break;
-                    case gpu::NINT16:
-                        texel.format = GL_RGBA;
-                        texel.internalFormat = GL_RGBA16_SNORM;
-                        break;
-                    case gpu::HALF:
-                        texel.format = GL_RGBA;
-                        texel.internalFormat = GL_RGBA16F;
-                        break;
-                    case gpu::UINT8:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA8UI;
-                        break;
-                    case gpu::INT8:
-                        texel.format = GL_RGBA_INTEGER;
-                        texel.internalFormat = GL_RGBA8I;
-                        break;
-                    case gpu::NUINT8:
-                        texel.format = GL_RGBA;
-                        texel.internalFormat = GL_RGBA8;
-                        break;
-                    case gpu::NINT8:
-                        texel.format = GL_RGBA;
-                        texel.internalFormat = GL_RGBA8_SNORM;
-                        break;
-                    case gpu::NUINT32:
-                    case gpu::NINT32:
-                    case gpu::NUM_TYPES: // quiet compiler
-                        Q_UNREACHABLE();
-                    }
-                    break;
-                case gpu::SRGB:
-                    texel.internalFormat = GL_SRGB;
-                    break;
-                case gpu::SRGBA:
-                    texel.internalFormat = GL_SRGB_ALPHA; // standard 2.2 gamma correction color
-                    break;
-                default:
-                    qCDebug(gpulogging) << "Unknown combination of texel format";
-                }
-                break;
-            }
-
-            default:
-                qCDebug(gpulogging) << "Unknown combination of texel format";
-            }
-            return texel;
-        }
-    }
-};
-
-
 GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
     GLTexture* object = Backend::getGPUObject<GLBackend::GLTexture>(texture);
 
diff --git a/libraries/gpu/src/gpu/GLTexelFormat.h b/libraries/gpu/src/gpu/GLTexelFormat.h
new file mode 100644
index 0000000000..274b5eeba3
--- /dev/null
+++ b/libraries/gpu/src/gpu/GLTexelFormat.h
@@ -0,0 +1,372 @@
+//
+//  Created by Bradley Austin Davis on 2016/04/03
+//  Copyright 2013-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 "GLBackendShared.h"
+
+class GLTexelFormat {
+public:
+    GLenum internalFormat;
+    GLenum format;
+    GLenum type;
+
+    static GLTexelFormat evalGLTexelFormat(const gpu::Element& dstFormat, const gpu::Element& srcFormat) {
+        using namespace gpu;
+        if (dstFormat != srcFormat) {
+            GLTexelFormat texel = { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE };
+
+            switch (dstFormat.getDimension()) {
+            case gpu::SCALAR: {
+                texel.format = GL_RED;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    texel.internalFormat = GL_R8;
+                    break;
+                case gpu::DEPTH:
+                    texel.internalFormat = GL_DEPTH_COMPONENT32;
+                    break;
+                case gpu::DEPTH_STENCIL:
+                    texel.type = GL_UNSIGNED_INT_24_8;
+                    texel.format = GL_DEPTH_STENCIL;
+                    texel.internalFormat = GL_DEPTH24_STENCIL8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+                break;
+            }
+
+            case gpu::VEC2: {
+                texel.format = GL_RG;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RG8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+
+                break;
+            }
+
+            case gpu::VEC3: {
+                texel.format = GL_RGB;
+
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RGB8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+
+                break;
+            }
+
+            case gpu::VEC4: {
+                texel.format = GL_RGBA;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (srcFormat.getSemantic()) {
+                case gpu::BGRA:
+                case gpu::SBGRA:
+                    texel.format = GL_BGRA;
+                    break;
+                case gpu::RGB:
+                case gpu::RGBA:
+                case gpu::SRGB:
+                case gpu::SRGBA:
+                default:
+                    break;
+                };
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                    texel.internalFormat = GL_RGB8;
+                    break;
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RGBA8;
+                    break;
+                case gpu::SRGB:
+                    texel.internalFormat = GL_SRGB8;
+                    break;
+                case gpu::SRGBA:
+                    texel.internalFormat = GL_SRGB8_ALPHA8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+                break;
+            }
+
+            default:
+                qCDebug(gpulogging) << "Unknown combination of texel format";
+            }
+            return texel;
+        } else {
+            GLTexelFormat texel = { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE };
+
+            switch (dstFormat.getDimension()) {
+            case gpu::SCALAR: {
+                texel.format = GL_RED;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                case gpu::SRGB:
+                case gpu::SRGBA:
+                    texel.internalFormat = GL_R8;
+                    switch (dstFormat.getType()) {
+                    case gpu::UINT32: {
+                        texel.internalFormat = GL_R32UI;
+                        break;
+                    }
+                    case gpu::INT32: {
+                        texel.internalFormat = GL_R32I;
+                        break;
+                    }
+                    case gpu::NUINT32: {
+                        texel.internalFormat = GL_R8;
+                        break;
+                    }
+                    case gpu::NINT32: {
+                        texel.internalFormat = GL_R8_SNORM;
+                        break;
+                    }
+                    case gpu::FLOAT: {
+                        texel.internalFormat = GL_R32F;
+                        break;
+                    }
+                    case gpu::UINT16: {
+                        texel.internalFormat = GL_R16UI;
+                        break;
+                    }
+                    case gpu::INT16: {
+                        texel.internalFormat = GL_R16I;
+                        break;
+                    }
+                    case gpu::NUINT16: {
+                        texel.internalFormat = GL_R16;
+                        break;
+                    }
+                    case gpu::NINT16: {
+                        texel.internalFormat = GL_R16_SNORM;
+                        break;
+                    }
+                    case gpu::HALF: {
+                        texel.internalFormat = GL_R16F;
+                        break;
+                    }
+                    case gpu::UINT8: {
+                        texel.internalFormat = GL_R8UI;
+                        break;
+                    }
+                    case gpu::INT8: {
+                        texel.internalFormat = GL_R8I;
+                        break;
+                    }
+                    case gpu::NUINT8: {
+                        if ((dstFormat.getSemantic() == gpu::SRGB || dstFormat.getSemantic() == gpu::SRGBA)) {
+                            texel.internalFormat = GL_SLUMINANCE8;
+                        } else {
+                            texel.internalFormat = GL_R8;
+                        }
+                        break;
+                    }
+                    case gpu::NINT8: {
+                        texel.internalFormat = GL_R8_SNORM;
+                        break;
+                    }
+                    case gpu::NUM_TYPES: { // quiet compiler
+                        Q_UNREACHABLE();
+                    }
+
+                    }
+                    break;
+
+                case gpu::R11G11B10:
+                    texel.format = GL_RGB;
+                    // the type should be float
+                    texel.internalFormat = GL_R11F_G11F_B10F;
+                    break;
+
+                case gpu::DEPTH:
+                    texel.format = GL_DEPTH_COMPONENT; // It's depth component to load it
+                    texel.internalFormat = GL_DEPTH_COMPONENT32;
+                    switch (dstFormat.getType()) {
+                    case gpu::UINT32:
+                    case gpu::INT32:
+                    case gpu::NUINT32:
+                    case gpu::NINT32: {
+                        texel.internalFormat = GL_DEPTH_COMPONENT32;
+                        break;
+                    }
+                    case gpu::FLOAT: {
+                        texel.internalFormat = GL_DEPTH_COMPONENT32F;
+                        break;
+                    }
+                    case gpu::UINT16:
+                    case gpu::INT16:
+                    case gpu::NUINT16:
+                    case gpu::NINT16:
+                    case gpu::HALF: {
+                        texel.internalFormat = GL_DEPTH_COMPONENT16;
+                        break;
+                    }
+                    case gpu::UINT8:
+                    case gpu::INT8:
+                    case gpu::NUINT8:
+                    case gpu::NINT8: {
+                        texel.internalFormat = GL_DEPTH_COMPONENT24;
+                        break;
+                    }
+                    case gpu::NUM_TYPES: { // quiet compiler
+                        Q_UNREACHABLE();
+                    }
+                    }
+                    break;
+                case gpu::DEPTH_STENCIL:
+                    texel.type = GL_UNSIGNED_INT_24_8;
+                    texel.format = GL_DEPTH_STENCIL;
+                    texel.internalFormat = GL_DEPTH24_STENCIL8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+
+                break;
+            }
+
+            case gpu::VEC2: {
+                texel.format = GL_RG;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RG8;
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+
+                break;
+            }
+
+            case gpu::VEC3: {
+                texel.format = GL_RGB;
+
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RGB8;
+                    break;
+                case gpu::SRGB:
+                case gpu::SRGBA:
+                    texel.internalFormat = GL_SRGB8; // standard 2.2 gamma correction color
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+                break;
+            }
+
+            case gpu::VEC4: {
+                texel.format = GL_RGBA;
+                texel.type = _elementTypeToGLType[dstFormat.getType()];
+
+                switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                    texel.internalFormat = GL_RGB8;
+                    break;
+                case gpu::RGBA:
+                    texel.internalFormat = GL_RGBA8;
+                    switch (dstFormat.getType()) {
+                    case gpu::UINT32:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA32UI;
+                        break;
+                    case gpu::INT32:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA32I;
+                        break;
+                    case gpu::FLOAT:
+                        texel.internalFormat = GL_RGBA32F;
+                        break;
+                    case gpu::UINT16:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA16UI;
+                        break;
+                    case gpu::INT16:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA16I;
+                        break;
+                    case gpu::NUINT16:
+                        texel.format = GL_RGBA;
+                        texel.internalFormat = GL_RGBA16;
+                        break;
+                    case gpu::NINT16:
+                        texel.format = GL_RGBA;
+                        texel.internalFormat = GL_RGBA16_SNORM;
+                        break;
+                    case gpu::HALF:
+                        texel.format = GL_RGBA;
+                        texel.internalFormat = GL_RGBA16F;
+                        break;
+                    case gpu::UINT8:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA8UI;
+                        break;
+                    case gpu::INT8:
+                        texel.format = GL_RGBA_INTEGER;
+                        texel.internalFormat = GL_RGBA8I;
+                        break;
+                    case gpu::NUINT8:
+                        texel.format = GL_RGBA;
+                        texel.internalFormat = GL_RGBA8;
+                        break;
+                    case gpu::NINT8:
+                        texel.format = GL_RGBA;
+                        texel.internalFormat = GL_RGBA8_SNORM;
+                        break;
+                    case gpu::NUINT32:
+                    case gpu::NINT32:
+                    case gpu::NUM_TYPES: // quiet compiler
+                        Q_UNREACHABLE();
+                    }
+                    break;
+                case gpu::SRGB:
+                    texel.internalFormat = GL_SRGB8;
+                    break;
+                case gpu::SRGBA:
+                    texel.internalFormat = GL_SRGB8_ALPHA8; // standard 2.2 gamma correction color
+                    break;
+                default:
+                    qCDebug(gpulogging) << "Unknown combination of texel format";
+                }
+                break;
+            }
+
+            default:
+                qCDebug(gpulogging) << "Unknown combination of texel format";
+            }
+            return texel;
+        }
+    }
+};
diff --git a/libraries/model-networking/src/model-networking/TextureCache.cpp b/libraries/model-networking/src/model-networking/TextureCache.cpp
index 3ba36dc2da..6870fa9b72 100644
--- a/libraries/model-networking/src/model-networking/TextureCache.cpp
+++ b/libraries/model-networking/src/model-networking/TextureCache.cpp
@@ -21,6 +21,8 @@
 #include <QRunnable>
 #include <QThreadPool>
 #include <qimagereader.h>
+
+#include <shared/NsightHelpers.h>
 #include <PathUtils.h>
 
 #include <gpu/Batch.h>
@@ -278,6 +280,7 @@ void ImageReader::listSupportedImageFormats() {
 }
 
 void ImageReader::run() {
+    PROFILE_RANGE_EX(__FUNCTION__, 0xffff0000, nullptr);
     auto originalPriority = QThread::currentThread()->priority();
     if (originalPriority == QThread::InheritPriority) {
         originalPriority = QThread::NormalPriority;
@@ -315,6 +318,7 @@ void ImageReader::run() {
     gpu::Texture* theTexture = nullptr;
     auto ntex = texture.dynamicCast<NetworkTexture>();
     if (ntex) {
+        PROFILE_RANGE_EX(__FUNCTION__"::textureLoader", 0xffffff00, nullptr);
         theTexture = ntex->getTextureLoader()(image, _url.toString().toStdString());
     }
 
diff --git a/libraries/shared/src/shared/NsightHelpers.h b/libraries/shared/src/shared/NsightHelpers.h
index 9853171b34..c637c78162 100644
--- a/libraries/shared/src/shared/NsightHelpers.h
+++ b/libraries/shared/src/shared/NsightHelpers.h
@@ -20,7 +20,7 @@ public:
 };
 
 #define PROFILE_RANGE(name) ProfileRange profileRangeThis(name);
-#define PROFILE_RANGE_EX(name, argbColor, payload) ProfileRange profileRangeThis(name, argbColor, payload);
+#define PROFILE_RANGE_EX(name, argbColor, payload) ProfileRange profileRangeThis(name, argbColor, (uint64_t)payload);
 #else
 #define PROFILE_RANGE(name)
 #define PROFILE_RANGE_EX(name, argbColor, payload)