Merge branch 'master' of github.com:highfidelity/hifi into ice-troubles-1

2025-04-08 23:55:24 +02:00 · 2016-09-23 13:16:26 -07:00 · 2016-09-23 13:16:26 -07:00 · 8cadd299a2
commit 8cadd299a2
parent d2c5378627 89288b3ed5
50 changed files with 1313 additions and 584 deletions
--- a/assignment-client/src/octree/OctreeServer.cpp
+++ b/assignment-client/src/octree/OctreeServer.cpp
@ -19,6 +19,7 @@
 #include <AccountManager.h>
 #include <HTTPConnection.h>
 #include <LogHandler.h>
+#include <shared/NetworkUtils.h>
 #include <NetworkingConstants.h>
 #include <NumericalConstants.h>
 #include <UUID.h>
--- a/cmake/externals/LibOVR/CMakeLists.txt
+++ b/cmake/externals/LibOVR/CMakeLists.txt
@ -20,8 +20,8 @@ if (WIN32)

  ExternalProject_Add(
    ${EXTERNAL_NAME}
-    URL http://hifi-public.s3.amazonaws.com/dependencies/ovr_sdk_win_1.3.0_public.zip
-    URL_MD5 a2dcf695e0f03a70fdd1ed7480585e82
+    URL https://hifi-public.s3.amazonaws.com/dependencies/ovr_sdk_win_1.8.0_public.zip
+    URL_MD5 bea17e04acc1dd8cf7cabefa1b28cc3c
    CONFIGURE_COMMAND ""
    BUILD_COMMAND ""
    INSTALL_COMMAND ""
@ -29,8 +29,8 @@ if (WIN32)
  )

  ExternalProject_Get_Property(${EXTERNAL_NAME} SOURCE_DIR)
-
-  set(LIBOVR_DIR ${SOURCE_DIR}/OculusSDK/LibOVR)
+  message("LIBOVR dir ${SOURCE_DIR}")
+  set(LIBOVR_DIR ${SOURCE_DIR}/LibOVR)
  if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
    set(LIBOVR_LIB_DIR ${LIBOVR_DIR}/Lib/Windows/x64/Release/VS2013 CACHE TYPE INTERNAL)
  else()
@ -38,6 +38,7 @@ if (WIN32)
  endif()

  set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${LIBOVR_DIR}/Include CACHE TYPE INTERNAL)
+  message("LIBOVR include dir ${${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS}")
  set(${EXTERNAL_NAME_UPPER}_LIBRARIES ${LIBOVR_LIB_DIR}/LibOVR.lib CACHE TYPE INTERNAL)
  
 elseif(APPLE)
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@ -174,6 +174,13 @@ void DomainServer::parseCommandLine() {
    const QCommandLineOption domainIDOption("d", "domain-server uuid");
    parser.addOption(domainIDOption);

+    const QCommandLineOption getTempNameOption("get-temp-name", "Request a temporary domain-name");
+    parser.addOption(getTempNameOption);
+
+    const QCommandLineOption masterConfigOption("master-config", "Deprecated config-file option");
+    parser.addOption(masterConfigOption);
+
+
    if (!parser.parse(QCoreApplication::arguments())) {
        qWarning() << parser.errorText() << endl;
        parser.showHelp();
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@ -44,12 +44,12 @@
 #include <AbstractUriHandler.h>
 #include <shared/RateCounter.h>
 #include <ThreadSafeValueCache.h>
+#include <shared/FileLogger.h>

 #include "avatar/MyAvatar.h"
 #include "Bookmarks.h"
 #include "Camera.h"
 #include "ConnectionMonitor.h"
-#include "FileLogger.h"
 #include "gpu/Context.h"
 #include "Menu.h"
 #include "octree/OctreePacketProcessor.h"
--- a/interface/src/ui/CachesSizeDialog.cpp
+++ b/interface/src/ui/CachesSizeDialog.cpp
@ -58,7 +58,10 @@ void CachesSizeDialog::confirmClicked(bool checked) {
    DependencyManager::get<AnimationCache>()->setUnusedResourceCacheSize(_animations->value() * BYTES_PER_MEGABYTES);
    DependencyManager::get<ModelCache>()->setUnusedResourceCacheSize(_geometries->value() * BYTES_PER_MEGABYTES);
    DependencyManager::get<SoundCache>()->setUnusedResourceCacheSize(_sounds->value() * BYTES_PER_MEGABYTES);
+    // Disabling the texture cache because it's a liability in cases where we're overcommiting GPU memory
+#if 0
    DependencyManager::get<TextureCache>()->setUnusedResourceCacheSize(_textures->value() * BYTES_PER_MEGABYTES);
+#endif
    
    QDialog::close();
 }
@ -78,4 +81,4 @@ void CachesSizeDialog::reject() {
 void CachesSizeDialog::closeEvent(QCloseEvent* event) {
    QDialog::closeEvent(event);
    emit closed();
-}
+}
--- a/interface/src/ui/LogDialog.h
+++ b/interface/src/ui/LogDialog.h
@ -20,7 +20,7 @@
 #include <QCheckBox>
 #include <QSyntaxHighlighter>

-#include "AbstractLoggerInterface.h"
+#include <shared/AbstractLoggerInterface.h>

 class KeywordHighlighter : public QSyntaxHighlighter {
    Q_OBJECT
--- a/interface/src/ui/Snapshot.cpp
+++ b/interface/src/ui/Snapshot.cpp
@ -25,7 +25,7 @@
 #include <AddressManager.h>
 #include <avatar/AvatarManager.h>
 #include <avatar/MyAvatar.h>
-#include <FileUtils.h>
+#include <shared/FileUtils.h>
 #include <NodeList.h>
 #include <OffscreenUi.h>
 #include <SharedUtil.h>
--- a/libraries/gpu-gl/src/gpu/gl/GLBackend.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLBackend.cpp
@ -39,6 +39,10 @@ static GLBackend* INSTANCE{ nullptr };
 static const char* GL_BACKEND_PROPERTY_NAME = "com.highfidelity.gl.backend";

 BackendPointer GLBackend::createBackend() {
+    // The ATI memory info extension only exposes 'free memory' so we want to force it to 
+    // cache the value as early as possible
+    getDedicatedMemory();
+
    // FIXME provide a mechanism to override the backend for testing
    // Where the gpuContext is initialized and where the TRUE Backend is created and assigned
    auto version = QOpenGLContextWrapper::currentContextVersion();
@ -589,7 +593,23 @@ void GLBackend::releaseQuery(GLuint id) const {
    _queriesTrash.push_back(id);
 }

+void GLBackend::queueLambda(const std::function<void()> lambda) const {
+    Lock lock(_trashMutex);
+    _lambdaQueue.push_back(lambda);
+}
+
 void GLBackend::recycle() const {
+    {
+        std::list<std::function<void()>> lamdbasTrash;
+        {
+            Lock lock(_trashMutex);
+            std::swap(_lambdaQueue, lamdbasTrash);
+        }
+        for (auto lambda : lamdbasTrash) {
+            lambda();
+        }
+    }
+
    {
        std::vector<GLuint> ids;
        std::list<std::pair<GLuint, Size>> buffersTrash;
@ -679,6 +699,10 @@ void GLBackend::recycle() const {
            glDeleteQueries((GLsizei)ids.size(), ids.data());
        }
    }
+
+#ifndef THREADED_TEXTURE_TRANSFER
+    gl::GLTexture::_textureTransferHelper->process();
+#endif
 }

 void GLBackend::setCameraCorrection(const Mat4& correction) {
--- a/libraries/gpu-gl/src/gpu/gl/GLBackend.h
+++ b/libraries/gpu-gl/src/gpu/gl/GLBackend.h
@ -175,6 +175,7 @@ public:
    virtual void releaseShader(GLuint id) const;
    virtual void releaseProgram(GLuint id) const;
    virtual void releaseQuery(GLuint id) const;
+    virtual void queueLambda(const std::function<void()> lambda) const;

 protected:

@ -197,6 +198,7 @@ protected:
    mutable std::list<GLuint> _shadersTrash;
    mutable std::list<GLuint> _programsTrash;
    mutable std::list<GLuint> _queriesTrash;
+    mutable std::list<std::function<void()>> _lambdaQueue;

    void renderPassTransfer(const Batch& batch);
    void renderPassDraw(const Batch& batch);
@ -365,6 +367,7 @@ protected:
    typedef void (GLBackend::*CommandCall)(const Batch&, size_t);
    static CommandCall _commandCalls[Batch::NUM_COMMANDS];
    friend class GLState;
+    friend class GLTexture;
 };

 } }
--- a/libraries/gpu-gl/src/gpu/gl/GLBackendPipeline.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLBackendPipeline.cpp
@ -165,7 +165,7 @@ void GLBackend::do_setUniformBuffer(const Batch& batch, size_t paramOffset) {
        _uniform._buffers[slot] = uniformBuffer;
        (void) CHECK_GL_ERROR();
    } else {
-        releaseResourceTexture(slot);
+        releaseUniformBuffer(slot);
        return;
    }
 }
--- a/libraries/gpu-gl/src/gpu/gl/GLShared.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLShared.cpp
@ -60,6 +60,32 @@ bool checkGLErrorDebug(const char* name) {
 #endif
 }

+gpu::Size getFreeDedicatedMemory() {
+    Size result { 0 };
+    static bool nvidiaMemorySupported { true };
+    static bool atiMemorySupported { true };
+    if (nvidiaMemorySupported) {
+        
+        GLint nvGpuMemory { 0 };
+        glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &nvGpuMemory);
+        if (GL_NO_ERROR == glGetError()) {
+            result = KB_TO_BYTES(nvGpuMemory);
+        } else {
+            nvidiaMemorySupported = false;
+        }
+    } else if (atiMemorySupported) {
+        GLint atiGpuMemory[4];
+        // not really total memory, but close enough if called early enough in the application lifecycle
+        glGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI, atiGpuMemory);
+        if (GL_NO_ERROR == glGetError()) {
+            result = KB_TO_BYTES(atiGpuMemory[0]);
+        } else {
+            atiMemorySupported = false;
+        }
+    }
+    return result;
+}
+
 gpu::Size getDedicatedMemory() {
    static Size dedicatedMemory { 0 };
    static std::once_flag once;
--- a/libraries/gpu-gl/src/gpu/gl/GLShared.h
+++ b/libraries/gpu-gl/src/gpu/gl/GLShared.h
@ -25,6 +25,7 @@ void serverWait();
 void clientWait();

 gpu::Size getDedicatedMemory();
+gpu::Size getFreeDedicatedMemory();
 ComparisonFunction comparisonFuncFromGL(GLenum func);
 State::StencilOp stencilOpFromGL(GLenum stencilOp);
 State::BlendOp blendOpFromGL(GLenum blendOp);
--- a/libraries/gpu-gl/src/gpu/gl/GLTexelFormat.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLTexelFormat.cpp
@ -12,9 +12,244 @@ using namespace gpu;
 using namespace gpu::gl;


-GLTexelFormat GLTexelFormat::evalGLTexelFormatInternal(const gpu::Element& dstFormat) {
-    GLTexelFormat texel = { GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE };
-    return texel;
+GLenum GLTexelFormat::evalGLTexelFormatInternal(const gpu::Element& dstFormat) {
+    GLenum result = GL_RGBA8;
+    switch (dstFormat.getDimension()) {
+        case gpu::SCALAR: {
+            switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                case gpu::SRGB:
+                case gpu::SRGBA:
+                    switch (dstFormat.getType()) {
+                        case gpu::UINT32:
+                            result = GL_R32UI;
+                            break;
+                        case gpu::INT32:
+                            result = GL_R32I;
+                            break;
+                        case gpu::NUINT32:
+                            result = GL_R8;
+                            break;
+                        case gpu::NINT32:
+                            result = GL_R8_SNORM;
+                            break;
+                        case gpu::FLOAT:
+                            result = GL_R32F;
+                            break;
+                        case gpu::UINT16:
+                            result = GL_R16UI;
+                            break;
+                        case gpu::INT16:
+                            result = GL_R16I;
+                            break;
+                        case gpu::NUINT16:
+                            result = GL_R16;
+                            break;
+                        case gpu::NINT16:
+                            result = GL_R16_SNORM;
+                            break;
+                        case gpu::HALF:
+                            result = GL_R16F;
+                            break;
+                        case gpu::UINT8:
+                            result = GL_R8UI;
+                            break;
+                        case gpu::INT8:
+                            result = GL_R8I;
+                            break;
+                        case gpu::NUINT8:
+                            if ((dstFormat.getSemantic() == gpu::SRGB || dstFormat.getSemantic() == gpu::SRGBA)) {
+                                result = GL_SLUMINANCE8;
+                            } else {
+                                result = GL_R8;
+                            }
+                            break;
+                        case gpu::NINT8:
+                            result = GL_R8_SNORM;
+                            break;
+
+                        default:
+                            Q_UNREACHABLE();
+                            break;
+                    }
+                    break;
+
+                case gpu::COMPRESSED_R:
+                    result = GL_COMPRESSED_RED_RGTC1;
+                    break;
+
+                case gpu::R11G11B10:
+                    // the type should be float
+                    result = GL_R11F_G11F_B10F;
+                    break;
+
+                case gpu::DEPTH:
+                    result = GL_DEPTH_COMPONENT32;
+                    switch (dstFormat.getType()) {
+                        case gpu::UINT32:
+                        case gpu::INT32:
+                        case gpu::NUINT32:
+                        case gpu::NINT32:
+                            result = GL_DEPTH_COMPONENT32;
+                            break;
+                        case gpu::FLOAT:
+                            result = GL_DEPTH_COMPONENT32F;
+                            break;
+                        case gpu::UINT16:
+                        case gpu::INT16:
+                        case gpu::NUINT16:
+                        case gpu::NINT16:
+                        case gpu::HALF:
+                            result = GL_DEPTH_COMPONENT16;
+                            break;
+                        case gpu::UINT8:
+                        case gpu::INT8:
+                        case gpu::NUINT8:
+                        case gpu::NINT8:
+                            result = GL_DEPTH_COMPONENT24;
+                            break;
+                        default:
+                            Q_UNREACHABLE();
+                            break;
+                    }
+                    break;
+
+                 case gpu::DEPTH_STENCIL:
+                    result = GL_DEPTH24_STENCIL8;
+                    break;
+
+                default:
+                    qCDebug(gpugllogging) << "Unknown combination of texel format";
+            }
+            break;
+        }
+
+        case gpu::VEC2: {
+            switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    result = GL_RG8;
+                    break;
+                default:
+                    qCDebug(gpugllogging) << "Unknown combination of texel format";
+            }
+
+            break;
+        }
+
+        case gpu::VEC3: {
+            switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                case gpu::RGBA:
+                    result = GL_RGB8;
+                    break;
+                case gpu::SRGB:
+                case gpu::SRGBA:
+                    result = GL_SRGB8; // standard 2.2 gamma correction color
+                    break;
+                case gpu::COMPRESSED_RGB:
+                    result = GL_COMPRESSED_RGB;
+                    break;
+                case gpu::COMPRESSED_SRGB:
+                    result = GL_COMPRESSED_SRGB;
+                    break;
+                default:
+                    qCDebug(gpugllogging) << "Unknown combination of texel format";
+            }
+
+            break;
+        }
+
+        case gpu::VEC4: {
+            switch (dstFormat.getSemantic()) {
+                case gpu::RGB:
+                    result = GL_RGB8;
+                    break;
+                case gpu::RGBA:
+                    switch (dstFormat.getType()) {
+                        case gpu::UINT32:
+                            result = GL_RGBA32UI;
+                            break;
+                        case gpu::INT32:
+                            result = GL_RGBA32I;
+                            break;
+                        case gpu::FLOAT:
+                            result = GL_RGBA32F;
+                            break;
+                        case gpu::UINT16:
+                            result = GL_RGBA16UI;
+                            break;
+                        case gpu::INT16:
+                            result = GL_RGBA16I;
+                            break;
+                        case gpu::NUINT16:
+                            result = GL_RGBA16;
+                            break;
+                        case gpu::NINT16:
+                            result = GL_RGBA16_SNORM;
+                            break;
+                        case gpu::HALF:
+                            result = GL_RGBA16F;
+                            break;
+                        case gpu::UINT8:
+                            result = GL_RGBA8UI;
+                            break;
+                        case gpu::INT8:
+                            result = GL_RGBA8I;
+                            break;
+                        case gpu::NUINT8:
+                            result = GL_RGBA8;
+                            break;
+                        case gpu::NINT8:
+                            result = GL_RGBA8_SNORM;
+                            break;
+                        case gpu::NUINT32:
+                        case gpu::NINT32:
+                        case gpu::NUM_TYPES: // quiet compiler
+                            Q_UNREACHABLE();
+                    }
+                    break;
+                case gpu::SRGB:
+                    result = GL_SRGB8;
+                    break;
+                case gpu::SRGBA:
+                    result = GL_SRGB8_ALPHA8; // standard 2.2 gamma correction color
+                    break;
+                case gpu::COMPRESSED_RGBA:
+                    result = GL_COMPRESSED_RGBA;
+                    break;
+                case gpu::COMPRESSED_SRGBA:
+                    result = GL_COMPRESSED_SRGB_ALPHA;
+                    break;
+
+                    // FIXME: WE will want to support this later
+                    /*
+                    case gpu::COMPRESSED_BC3_RGBA:
+                    result = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+                    break;
+                    case gpu::COMPRESSED_BC3_SRGBA:
+                    result = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
+                    break;
+
+                    case gpu::COMPRESSED_BC7_RGBA:
+                    result = GL_COMPRESSED_RGBA_BPTC_UNORM_ARB;
+                    break;
+                    case gpu::COMPRESSED_BC7_SRGBA:
+                    result = GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM;
+                    break;
+                    */
+
+                default:
+                    qCDebug(gpugllogging) << "Unknown combination of texel format";
+            }
+            break;
+        }
+
+        default:
+            qCDebug(gpugllogging) << "Unknown combination of texel format";
+    }
+    return result;
 }

 GLTexelFormat GLTexelFormat::evalGLTexelFormat(const Element& dstFormat, const Element& srcFormat) {
--- a/libraries/gpu-gl/src/gpu/gl/GLTexelFormat.h
+++ b/libraries/gpu-gl/src/gpu/gl/GLTexelFormat.h
@ -21,7 +21,7 @@ public:
    static GLTexelFormat evalGLTexelFormat(const Element& dstFormat) {
        return evalGLTexelFormat(dstFormat, dstFormat);
    }
-    static GLTexelFormat evalGLTexelFormatInternal(const Element& dstFormat);
+    static GLenum evalGLTexelFormatInternal(const Element& dstFormat);

    static GLTexelFormat evalGLTexelFormat(const Element& dstFormat, const Element& srcFormat);
 };
--- a/libraries/gpu-gl/src/gpu/gl/GLTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLTexture.cpp
@ -17,11 +17,11 @@ using namespace gpu;
 using namespace gpu::gl;

 std::shared_ptr<GLTextureTransferHelper> GLTexture::_textureTransferHelper;
-static std::map<uint16, size_t> _textureCountByMips;
-static uint16 _currentMaxMipCount { 0 };

 // FIXME placeholder for texture memory over-use
 #define DEFAULT_MAX_MEMORY_MB 256
+#define MIN_FREE_GPU_MEMORY_PERCENTAGE 0.25f
+#define OVER_MEMORY_PRESSURE 2.0f

 const GLenum GLTexture::CUBE_FACE_LAYOUT[6] = {
    GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
@ -94,6 +94,7 @@ const std::vector<GLenum>& GLTexture::getFaceTargets(GLenum target) {
    return faceTargets;
 }

+
 float GLTexture::getMemoryPressure() {
    // Check for an explicit memory limit
    auto availableTextureMemory = Texture::getAllowedGPUMemoryUsage();
@ -102,15 +103,28 @@ float GLTexture::getMemoryPressure() {
    if (!availableTextureMemory) {
        auto totalGpuMemory = getDedicatedMemory();

-        // If no limit has been explicitly set, and the dedicated memory can't be determined, 
-        // just use a fallback fixed value of 256 MB
        if (!totalGpuMemory) {
+            // If we can't query the dedicated memory just use a fallback fixed value of 256 MB
            totalGpuMemory = MB_TO_BYTES(DEFAULT_MAX_MEMORY_MB);
+        } else {
+            // Check the global free GPU memory
+            auto freeGpuMemory = getFreeDedicatedMemory();
+            if (freeGpuMemory) {
+                static gpu::Size lastFreeGpuMemory = 0;
+                auto freePercentage = (float)freeGpuMemory / (float)totalGpuMemory;
+                if (freeGpuMemory != lastFreeGpuMemory) {
+                    lastFreeGpuMemory = freeGpuMemory;
+                    if (freePercentage < MIN_FREE_GPU_MEMORY_PERCENTAGE) {
+                        qDebug() << "Exceeded max GPU memory";
+                        return OVER_MEMORY_PRESSURE;
+                    }
+                }
+            }
        }

-        // Allow 75% of all available GPU memory to be consumed by textures
+        // Allow 50% of all available GPU memory to be consumed by textures
        // FIXME overly conservative?
-        availableTextureMemory = (totalGpuMemory >> 2) * 3;
+        availableTextureMemory = (totalGpuMemory >> 1);
    }

    // Return the consumed texture memory divided by the available texture memory.
@ -118,80 +132,27 @@ float GLTexture::getMemoryPressure() {
    return (float)consumedGpuMemory / (float)availableTextureMemory;
 }

-GLTexture::DownsampleSource::DownsampleSource(const std::weak_ptr<GLBackend>& backend, GLTexture* oldTexture) :
-    _backend(backend),
-    _size(oldTexture ? oldTexture->_size : 0),
-    _texture(oldTexture ? oldTexture->takeOwnership() : 0),
-    _minMip(oldTexture ? oldTexture->_minMip : 0),
-    _maxMip(oldTexture ? oldTexture->_maxMip : 0)
-{
-}
-
-GLTexture::DownsampleSource::~DownsampleSource() {
-    if (_texture) {
-        auto backend = _backend.lock();
-        if (backend) {
-            backend->releaseTexture(_texture, _size);
-        }
-    }
-}
-
-GLTexture::GLTexture(const std::weak_ptr<GLBackend>& backend, const gpu::Texture& texture, GLuint id, GLTexture* originalTexture, bool transferrable) :
-    GLObject(backend, texture, id),
-    _storageStamp(texture.getStamp()),
-    _target(getGLTextureType(texture)),
-    _maxMip(texture.maxMip()),
-    _minMip(texture.minMip()),
-    _virtualSize(texture.evalTotalSize()),
-    _transferrable(transferrable),
-    _downsampleSource(backend, originalTexture)
-{
-    if (_transferrable) {
-        uint16 mipCount = usedMipLevels();
-        _currentMaxMipCount = std::max(_currentMaxMipCount, mipCount);
-        if (!_textureCountByMips.count(mipCount)) {
-            _textureCountByMips[mipCount] = 1;
-        } else {
-            ++_textureCountByMips[mipCount];
-        }
-    } 
-    Backend::incrementTextureGPUCount();
-    Backend::updateTextureGPUVirtualMemoryUsage(0, _virtualSize);
-}
-

 // Create the texture and allocate storage
 GLTexture::GLTexture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, GLuint id, bool transferrable) :
-    GLTexture(backend, texture, id, nullptr, transferrable)
+    GLObject(backend, texture, id),
+    _source(texture.source()),
+    _storageStamp(texture.getStamp()),
+    _target(getGLTextureType(texture)),
+    _internalFormat(gl::GLTexelFormat::evalGLTexelFormatInternal(texture.getTexelFormat())),
+    _maxMip(texture.maxMip()),
+    _minMip(texture.minMip()),
+    _virtualSize(texture.evalTotalSize()),
+    _transferrable(transferrable)
 {
-    // FIXME, do during allocation
-    //Backend::updateTextureGPUMemoryUsage(0, _size);
-    Backend::setGPUObject(texture, this);
-}
-
-// Create the texture and copy from the original higher resolution version
-GLTexture::GLTexture(const std::weak_ptr<GLBackend>& backend, const gpu::Texture& texture, GLuint id, GLTexture* originalTexture) :
-    GLTexture(backend, texture, id, originalTexture, originalTexture->_transferrable)
-{
-    Q_ASSERT(_minMip >= originalTexture->_minMip);
-    // Set the GPU object last because that implicitly destroys the originalTexture object
+    auto strongBackend = _backend.lock();
+    strongBackend->recycle();
+    Backend::incrementTextureGPUCount();
+    Backend::updateTextureGPUVirtualMemoryUsage(0, _virtualSize);
    Backend::setGPUObject(texture, this);
 }

 GLTexture::~GLTexture() {
-    if (_transferrable) {
-        uint16 mipCount = usedMipLevels();
-        Q_ASSERT(_textureCountByMips.count(mipCount));
-        auto& numTexturesForMipCount = _textureCountByMips[mipCount];
-        --numTexturesForMipCount;
-        if (0 == numTexturesForMipCount) {
-            _textureCountByMips.erase(mipCount);
-            if (mipCount == _currentMaxMipCount) {
-                _currentMaxMipCount = (_textureCountByMips.empty() ? 0 : _textureCountByMips.rbegin()->first);
-            }
-        }
-    }
-
    if (_id) {
        auto backend = _backend.lock();
        if (backend) {
@ -210,6 +171,28 @@ void GLTexture::createTexture() {
    });
 }

+void GLTexture::withPreservedTexture(std::function<void()> f) const {
+    GLint boundTex = -1;
+    switch (_target) {
+        case GL_TEXTURE_2D:
+            glGetIntegerv(GL_TEXTURE_BINDING_2D, &boundTex);
+            break;
+
+        case GL_TEXTURE_CUBE_MAP:
+            glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &boundTex);
+            break;
+
+        default:
+            qFatal("Unsupported texture type");
+    }
+    (void)CHECK_GL_ERROR();
+
+    glBindTexture(_target, _texture);
+    f();
+    glBindTexture(_target, boundTex);
+    (void)CHECK_GL_ERROR();
+}
+
 void GLTexture::setSize(GLuint size) const {
    Backend::updateTextureGPUMemoryUsage(_size, size);
    const_cast<GLuint&>(_size) = size;
@ -223,20 +206,6 @@ bool GLTexture::isOutdated() const {
    return GLSyncState::Idle == _syncState && _contentStamp < _gpuObject.getDataStamp();
 }

-bool GLTexture::isOverMaxMemory() const {
-    // FIXME switch to using the max mip count used from the previous frame
-    if (usedMipLevels() < _currentMaxMipCount) {
-        return false;
-    }
-    Q_ASSERT(usedMipLevels() == _currentMaxMipCount);
-
-    if (getMemoryPressure() < 1.0f) {
-        return false;
-    }
-
-    return true;
-}
-
 bool GLTexture::isReady() const {
    // If we have an invalid texture, we're never ready
    if (isInvalid()) {
@ -257,11 +226,6 @@ void GLTexture::postTransfer() {
    setSyncState(GLSyncState::Idle);
    ++_transferCount;

-    //// The public gltexture becaomes available
-    //_id = _privateTexture;
-
-    _downsampleSource.reset();
-
    // At this point the mip pixels have been loaded, we can notify the gpu texture to abandon it's memory
    switch (_gpuObject.getType()) {
        case Texture::TEX_2D:
--- a/libraries/gpu-gl/src/gpu/gl/GLTexture.h
+++ b/libraries/gpu-gl/src/gpu/gl/GLTexture.h
@ -73,14 +73,7 @@ public:
            return nullptr;
        }

-        // Do we need to reduce texture memory usage?
-        if (object->isOverMaxMemory() && texturePointer->incremementMinMip()) {
-            // WARNING, this code path will essentially `delete this`, 
-            // so no dereferencing of this instance should be done past this point
-            object = new GLTextureType(backend.shared_from_this(), texture, object);
-            _textureTransferHelper->transferTexture(texturePointer);
-            return nullptr;
-        }
+        ((GLTexture*)object)->updateMips();

        return object;
    }
@ -96,57 +89,38 @@ public:
        } else {
            object = Backend::getGPUObject<GLTextureType>(*texture);
        }
+
        if (!object) {
            return 0;
        }

-        GLuint result = object->_id;
+        if (!shouldSync) {
+            return object->_id;
+        }

        // Don't return textures that are in transfer state
-        if (shouldSync) {
-            if ((object->getSyncState() != GLSyncState::Idle) ||
-                // Don't return transferrable textures that have never completed transfer
-                (!object->_transferrable || 0 != object->_transferCount)) {
-                // Will be either 0 or the original texture being downsampled.
-                result = object->_downsampleSource._texture;
-            }
+        if ((object->getSyncState() != GLSyncState::Idle) ||
+            // Don't return transferrable textures that have never completed transfer
+            (!object->_transferrable || 0 != object->_transferCount)) {
+            return 0;
        }
        
-        return result;
-    }
-
-    // Used by derived classes and helpers to ensure the actual GL object exceeds the lifetime of `this`
-    GLuint takeOwnership() {
-        GLuint result = _id;
-        const_cast<GLuint&>(_id) = 0;
-        return result;
+        return object->_id;
    }

    ~GLTexture();

    const GLuint& _texture { _id };
+    const std::string _source;
    const Stamp _storageStamp;
    const GLenum _target;
+    const GLenum _internalFormat;
    const uint16 _maxMip;
-    const uint16 _minMip;
+    uint16 _minMip;
    const GLuint _virtualSize; // theoretical size as expected
    Stamp _contentStamp { 0 };
    const bool _transferrable;
    Size _transferCount { 0 };
-
-    struct DownsampleSource {
-        using Pointer = std::shared_ptr<DownsampleSource>;
-        DownsampleSource(const std::weak_ptr<gl::GLBackend>& backend) : _backend(backend), _size(0), _texture(0), _minMip(0), _maxMip(0) {}
-        DownsampleSource(const std::weak_ptr<gl::GLBackend>& backend, GLTexture* originalTexture);
-        ~DownsampleSource();
-        void reset() const { const_cast<GLuint&>(_texture) = 0; }
-        const std::weak_ptr<gl::GLBackend>& _backend;
-        const GLuint _size { 0 };
-        const GLuint _texture { 0 };
-        const uint16 _minMip { 0 };
-        const uint16 _maxMip { 0 };
-    } _downsampleSource;
-
    GLuint size() const { return _size; }
    GLSyncState getSyncState() const { return _syncState; }

@ -160,9 +134,7 @@ public:
    bool isReady() const;

    // Execute any post-move operations that must occur only on the main thread
-    void postTransfer();
-
-    bool isOverMaxMemory() const;
+    virtual void postTransfer();

    uint16 usedMipLevels() const { return (_maxMip - _minMip) + 1; }

@ -170,33 +142,34 @@ public:
    static const GLenum CUBE_FACE_LAYOUT[6];
    static const GLFilterMode FILTER_MODES[Sampler::NUM_FILTERS];
    static const GLenum WRAP_MODES[Sampler::NUM_WRAP_MODES];
-protected:

-    static const std::vector<GLenum>& getFaceTargets(GLenum textureType);
-
-    static GLenum getGLTextureType(const Texture& texture);
    // Return a floating point value indicating how much of the allowed 
    // texture memory we are currently consuming.  A value of 0 indicates 
    // no texture memory usage, while a value of 1 indicates all available / allowed memory
    // is consumed.  A value above 1 indicates that there is a problem.
    static float getMemoryPressure();
+protected:
+
+    static const std::vector<GLenum>& getFaceTargets(GLenum textureType);
+
+    static GLenum getGLTextureType(const Texture& texture);


    const GLuint _size { 0 }; // true size as reported by the gl api
    std::atomic<GLSyncState> _syncState { GLSyncState::Idle };

    GLTexture(const std::weak_ptr<gl::GLBackend>& backend, const Texture& texture, GLuint id, bool transferrable);
-    GLTexture(const std::weak_ptr<gl::GLBackend>& backend, const Texture& texture, GLuint id, GLTexture* originalTexture);

    void setSyncState(GLSyncState syncState) { _syncState = syncState; }

    void createTexture();
-    
+
+    virtual void updateMips() {}
    virtual void allocateStorage() const = 0;
    virtual void updateSize() const = 0;
    virtual void syncSampler() const = 0;
    virtual void generateMips() const = 0;
-    virtual void withPreservedTexture(std::function<void()> f) const = 0;
+    virtual void withPreservedTexture(std::function<void()> f) const;

 protected:
    void setSize(GLuint size) const;
@ -207,9 +180,6 @@ protected:
    virtual void finishTransfer();

 private:
-
-    GLTexture(const std::weak_ptr<GLBackend>& backend, const gpu::Texture& gpuTexture, GLuint id, GLTexture* originalTexture, bool transferrable);
-
    friend class GLTextureTransferHelper;
    friend class GLBackend;
 };
--- a/libraries/gpu-gl/src/gpu/gl/GLTextureTransfer.cpp
+++ b/libraries/gpu-gl/src/gpu/gl/GLTextureTransfer.cpp
@ -35,6 +35,8 @@ GLTextureTransferHelper::GLTextureTransferHelper() {
    initialize(true, QThread::LowPriority);
    // Clean shutdown on UNIX, otherwise _canvas is freed early
    connect(qApp, &QCoreApplication::aboutToQuit, [&] { terminate(); });
+#else
+    initialize(false, QThread::LowPriority);
 #endif
 }

@ -43,23 +45,18 @@ GLTextureTransferHelper::~GLTextureTransferHelper() {
    if (isStillRunning()) {
        terminate();
    }
+#else
+    terminate();
 #endif
 }

 void GLTextureTransferHelper::transferTexture(const gpu::TexturePointer& texturePointer) {
    GLTexture* object = Backend::getGPUObject<GLTexture>(*texturePointer);

-#ifdef THREADED_TEXTURE_TRANSFER
    Backend::incrementTextureGPUTransferCount();
    object->setSyncState(GLSyncState::Pending);
    Lock lock(_mutex);
    _pendingTextures.push_back(texturePointer);
-#else
-    for (object->startTransfer(); object->continueTransfer(); ) { }
-    object->finishTransfer();
-    object->_contentStamp = texturePointer->getDataStamp();
-    object->setSyncState(GLSyncState::Transferred);
-#endif
 }

 void GLTextureTransferHelper::setup() {
@ -100,13 +97,28 @@ void GLTextureTransferHelper::shutdown() {
 #endif
 }

+void GLTextureTransferHelper::queueExecution(VoidLambda lambda) {
+    Lock lock(_mutex);
+    _pendingCommands.push_back(lambda);
+}
+
+#define MAX_TRANSFERS_PER_PASS 2
+
 bool GLTextureTransferHelper::process() {
-#ifdef THREADED_TEXTURE_TRANSFER
-    // Take any new textures off the queue
+    // Take any new textures or commands off the queue
+    VoidLambdaList pendingCommands;
    TextureList newTransferTextures;
    {
        Lock lock(_mutex);
        newTransferTextures.swap(_pendingTextures);
+        pendingCommands.swap(_pendingCommands);
+    }
+
+    if (!pendingCommands.empty()) {
+        for (auto command : pendingCommands) {
+            command();
+        }
+        glFlush();
    }

    if (!newTransferTextures.empty()) {
@ -119,11 +131,16 @@ bool GLTextureTransferHelper::process() {
            _transferringTextures.push_back(texturePointer);
            _textureIterator = _transferringTextures.begin();
        }
+        _transferringTextures.sort([](const gpu::TexturePointer& a, const gpu::TexturePointer& b)->bool {
+            return a->getSize() < b->getSize();
+        });
    }

    // No transfers in progress, sleep
    if (_transferringTextures.empty()) {
+#ifdef THREADED_TEXTURE_TRANSFER
        QThread::usleep(1);
+#endif
        return true;
    }

@ -135,7 +152,11 @@ bool GLTextureTransferHelper::process() {
        qDebug() << "Texture list " << _transferringTextures.size();
    }

-    for (auto _textureIterator = _transferringTextures.begin(); _textureIterator != _transferringTextures.end();) {
+    size_t transferCount = 0;
+    for (_textureIterator = _transferringTextures.begin(); _textureIterator != _transferringTextures.end();) {
+        if (++transferCount > MAX_TRANSFERS_PER_PASS) {
+            break;
+        }
        auto texture = *_textureIterator;
        GLTexture* gltexture = Backend::getGPUObject<GLTexture>(*texture);
        if (gltexture->continueTransfer()) {
@ -144,9 +165,9 @@ bool GLTextureTransferHelper::process() {
        }

        gltexture->finishTransfer();
-        glNamedFramebufferTexture(_readFramebuffer, GL_COLOR_ATTACHMENT0, gltexture->_id, 0);
-        glBlitNamedFramebuffer(_readFramebuffer, _drawFramebuffer, 0, 0, 1, 1, 0, 0, 1, 1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+#ifdef THREADED_TEXTURE_TRANSFER
        clientWait();
+#endif
        gltexture->_contentStamp = gltexture->_gpuObject.getDataStamp();
        gltexture->updateSize();
        gltexture->setSyncState(gpu::gl::GLSyncState::Transferred);
@ -159,6 +180,7 @@ bool GLTextureTransferHelper::process() {
        _textureIterator = _transferringTextures.erase(_textureIterator);
    }

+#ifdef THREADED_TEXTURE_TRANSFER
    if (!_transferringTextures.empty()) {
        // Don't saturate the GPU
        clientWait();
@ -166,8 +188,7 @@ bool GLTextureTransferHelper::process() {
        // Don't saturate the CPU
        QThread::msleep(1);
    }
-#else
-    QThread::msleep(1);
 #endif
+
    return true;
 }
--- a/libraries/gpu-gl/src/gpu/gl/GLTextureTransfer.h
+++ b/libraries/gpu-gl/src/gpu/gl/GLTextureTransfer.h
@ -28,12 +28,14 @@ using TextureListIterator = TextureList::iterator;

 class GLTextureTransferHelper : public GenericThread {
 public:
+    using VoidLambda = std::function<void()>;
+    using VoidLambdaList = std::list<VoidLambda>;
    using Pointer = std::shared_ptr<GLTextureTransferHelper>;
    GLTextureTransferHelper();
    ~GLTextureTransferHelper();
    void transferTexture(const gpu::TexturePointer& texturePointer);
+    void queueExecution(VoidLambda lambda);

-protected:
    void setup() override;
    void shutdown() override;
    bool process() override;
@ -41,8 +43,15 @@ protected:
 private:
 #ifdef THREADED_TEXTURE_TRANSFER
    ::gl::OffscreenContext _context;
+    // Framebuffers / renderbuffers for forcing access to the texture on the transfer thread
+    GLuint _drawRenderbuffer { 0 };
+    GLuint _drawFramebuffer { 0 };
+    GLuint _readFramebuffer { 0 };
+#endif
    // A mutex for protecting items access on the render and transfer threads
    Mutex _mutex;
+    // Commands that have been submitted for execution on the texture transfer thread
+    VoidLambdaList _pendingCommands;
    // Textures that have been submitted for transfer
    TextureList _pendingTextures;
    // Textures currently in the transfer process
@ -50,11 +59,6 @@ private:
    TextureList _transferringTextures;
    TextureListIterator _textureIterator;

-    // Framebuffers / renderbuffers for forcing access to the texture on the transfer thread
-    GLuint _drawRenderbuffer { 0 };
-    GLuint _drawFramebuffer { 0 };
-    GLuint _readFramebuffer { 0 };
-#endif
 };

 } }
--- a/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41Backend.h
@ -43,7 +43,6 @@ public:
        GLuint allocate();
    public:
        GL41Texture(const std::weak_ptr<GLBackend>& backend, const Texture& buffer, bool transferrable);
-        GL41Texture(const std::weak_ptr<GLBackend>& backend, const Texture& buffer, GL41Texture* original);

    protected:
        void transferMip(uint16_t mipLevel, uint8_t face) const;
@ -52,7 +51,6 @@ public:
        void updateSize() const override;
        void syncSampler() const override;
        void generateMips() const override;
-        void withPreservedTexture(std::function<void()> f) const override;
    };


--- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
@ -40,30 +40,6 @@ GLTexture* GL41Backend::syncGPUObject(const TexturePointer& texture, bool transf

 GL41Texture::GL41Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, bool transferrable) : GLTexture(backend, texture, allocate(), transferrable) {}

-GL41Texture::GL41Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, GL41Texture* original) : GLTexture(backend, texture, allocate(), original) {}
-
-void GL41Texture::withPreservedTexture(std::function<void()> f) const  {
-    GLint boundTex = -1;
-    switch (_target) {
-    case GL_TEXTURE_2D:
-        glGetIntegerv(GL_TEXTURE_BINDING_2D, &boundTex);
-        break;
-
-    case GL_TEXTURE_CUBE_MAP:
-        glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &boundTex);
-        break;
-
-    default:
-        qFatal("Unsupported texture type");
-    }
-    (void)CHECK_GL_ERROR();
-
-    glBindTexture(_target, _texture);
-    f();
-    glBindTexture(_target, boundTex);
-    (void)CHECK_GL_ERROR();
-}
-
 void GL41Texture::generateMips() const {
    withPreservedTexture([&] {
        glGenerateMipmap(_target);
@ -147,35 +123,12 @@ void GL41Texture::startTransfer() {
    glBindTexture(_target, _id);
    (void)CHECK_GL_ERROR();

-    if (_downsampleSource._texture) {
-        GLuint fbo { 0 };
-        glGenFramebuffers(1, &fbo);
-        (void)CHECK_GL_ERROR();
-        glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
-        (void)CHECK_GL_ERROR();
-        // Find the distance between the old min mip and the new one
-        uint16 mipOffset = _minMip - _downsampleSource._minMip;
-        for (uint16 i = _minMip; i <= _maxMip; ++i) {
-            uint16 targetMip = i - _minMip;
-            uint16 sourceMip = targetMip + mipOffset;
-            Vec3u dimensions = _gpuObject.evalMipDimensions(i);
-            for (GLenum target : getFaceTargets(_target)) {
-                glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, _downsampleSource._texture, sourceMip);
-                (void)CHECK_GL_ERROR();
-                glCopyTexSubImage2D(target, targetMip, 0, 0, 0, 0, dimensions.x, dimensions.y);
-                (void)CHECK_GL_ERROR();
-            }
-        }
-        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-        glDeleteFramebuffers(1, &fbo);
-    } else {
-        // transfer pixels from each faces
-        uint8_t numFaces = (Texture::TEX_CUBE == _gpuObject.getType()) ? CUBE_NUM_FACES : 1;
-        for (uint8_t f = 0; f < numFaces; f++) {
-            for (uint16_t i = 0; i < Sampler::MAX_MIP_LEVEL; ++i) {
-                if (_gpuObject.isStoredMipFaceAvailable(i, f)) {
-                    transferMip(i, f);
-                }
+    // transfer pixels from each faces
+    uint8_t numFaces = (Texture::TEX_CUBE == _gpuObject.getType()) ? CUBE_NUM_FACES : 1;
+    for (uint8_t f = 0; f < numFaces; f++) {
+        for (uint16_t i = 0; i < Sampler::MAX_MIP_LEVEL; ++i) {
+            if (_gpuObject.isStoredMipFaceAvailable(i, f)) {
+                transferMip(i, f);
            }
        }
    }
--- a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.cpp
@ -147,3 +147,8 @@ void GL45Backend::do_multiDrawIndexedIndirect(const Batch& batch, size_t paramOf
    _stats._DSNumAPIDrawcalls++;
    (void)CHECK_GL_ERROR();
 }
+
+void GL45Backend::recycle() const {
+    Parent::recycle();
+    derezTextures();
+}
--- a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
@ -18,29 +18,6 @@ namespace gpu { namespace gl45 {
    
 using namespace gpu::gl;

-struct TransferState {
-    GLTexture& _texture;
-    GLenum _internalFormat { GL_RGBA8 };
-    GLTexelFormat _texelFormat;
-    uint8_t _face { 0 };
-    uint16_t  _mipLevel { 0 };
-    uint32_t _bytesPerLine { 0 };
-    uint32_t _bytesPerPixel { 0 };
-    uint32_t _bytesPerPage { 0 };
-    GLuint _maxSparseLevel { 0 };
-
-    uvec3 _mipDimensions;
-    uvec3 _mipOffset;
-    uvec3 _pageSize;
-    const uint8_t* _srcPointer { nullptr };
-    uvec3 currentPageSize() const;
-    void updateSparse();
-    void updateMip();
-    void populatePage(std::vector<uint8_t>& dest);
-    bool increment();
-    TransferState(GLTexture& texture);
-};
-
 class GL45Backend : public GLBackend {
    using Parent = GLBackend;
    // Context Backend static interface required
@ -53,14 +30,54 @@ public:
    class GL45Texture : public GLTexture {
        using Parent = GLTexture;
        static GLuint allocate(const Texture& texture);
+        static const uint32_t DEFAULT_PAGE_DIMENSION = 128;
+        static const uint32_t DEFAULT_MAX_SPARSE_LEVEL = 0xFFFF;
    public:
        GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, bool transferrable);
-        GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, GLTexture* original);
        ~GL45Texture();

+        void postTransfer() override;
+
+        struct SparseInfo {
+            SparseInfo(GL45Texture& texture);
+            void maybeMakeSparse();
+            void update();
+            uvec3 getPageCounts(const uvec3& dimensions) const;
+            uint32_t getPageCount(const uvec3& dimensions) const;
+
+            GL45Texture& texture;
+            bool sparse { false };
+            uvec3 pageDimensions { DEFAULT_PAGE_DIMENSION };
+            GLuint maxSparseLevel { DEFAULT_MAX_SPARSE_LEVEL };
+            uint32_t maxPages { 0 };
+            uint32_t pageBytes { 0 };
+            GLint pageDimensionsIndex { 0 };
+        };
+
+        struct TransferState {
+            TransferState(GL45Texture& texture);
+            uvec3 currentPageSize() const;
+            void updateMip();
+            void populatePage(std::vector<uint8_t>& dest);
+            bool increment();
+
+            GL45Texture& texture;
+            GLTexelFormat texelFormat;
+            uint8_t face { 0 };
+            uint16_t mipLevel { 0 };
+            uint32_t bytesPerLine { 0 };
+            uint32_t bytesPerPixel { 0 };
+            uint32_t bytesPerPage { 0 };
+            uvec3 mipDimensions;
+            uvec3 mipOffset;
+            const uint8_t* srcPointer { nullptr };
+        };
    protected:
+        void updateMips() override;
+        void stripToMip(uint16_t newMinMip);
        void startTransfer() override;
        bool continueTransfer() override;
+        void finishTransfer() override;
        void incrementalTransfer(const uvec3& size, const gpu::Texture::PixelsPointer& mip, std::function<void(const ivec3& offset, const uvec3& size)> f) const;
        void transferMip(uint16_t mipLevel, uint8_t face = 0) const;
        void allocateMip(uint16_t mipLevel, uint8_t face = 0) const;
@ -69,12 +86,20 @@ public:
        void syncSampler() const override;
        void generateMips() const override;
        void withPreservedTexture(std::function<void()> f) const override;
+        void derez();

+        SparseInfo _sparseInfo;
        TransferState _transferState;
+        uint32_t _allocatedPages { 0 };
+        uint32_t _lastMipAllocatedPages { 0 };
+        friend class GL45Backend;
    };


 protected:
+    void recycle() const override;
+    void derezTextures() const;
+
    GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;
    GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer) override;

--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
@ -17,6 +17,7 @@
 #include <glm/gtx/component_wise.hpp>

 #include <QtCore/QThread>
+#include <QtCore/QProcessEnvironment>

 #include "../gl/GLTexelFormat.h"

@ -24,79 +25,191 @@ using namespace gpu;
 using namespace gpu::gl;
 using namespace gpu::gl45;

-#define SPARSE_TEXTURES 1
+#ifdef Q_OS_WIN
+static const QString DEBUG_FLAG("HIFI_DISABLE_SPARSE_TEXTURES");
+static bool enableSparseTextures = !QProcessEnvironment::systemEnvironment().contains(DEBUG_FLAG);
+#else
+static bool enableSparseTextures = false;
+#endif

 // Allocate 1 MB of buffer space for paged transfers
 #define DEFAULT_PAGE_BUFFER_SIZE (1024*1024)
+#define DEFAULT_GL_PIXEL_ALIGNMENT 4

 using GL45Texture = GL45Backend::GL45Texture;

+static std::map<uint16_t, std::unordered_set<GL45Texture*>> texturesByMipCounts;
+static Mutex texturesByMipCountsMutex;
+using TextureTypeFormat = std::pair<GLenum, GLenum>;
+std::map<TextureTypeFormat, std::vector<uvec3>> sparsePageDimensionsByFormat;
+Mutex sparsePageDimensionsByFormatMutex;
+
+static std::vector<uvec3> getPageDimensionsForFormat(const TextureTypeFormat& typeFormat) {
+    {
+        Lock lock(sparsePageDimensionsByFormatMutex);
+        if (sparsePageDimensionsByFormat.count(typeFormat)) {
+            return sparsePageDimensionsByFormat[typeFormat];
+        }
+    }
+    GLint count = 0;
+    glGetInternalformativ(typeFormat.first, typeFormat.second, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, 1, &count);
+
+    std::vector<uvec3> result;
+    if (count > 0) {
+        std::vector<GLint> x, y, z;
+        x.resize(count);
+        glGetInternalformativ(typeFormat.first, typeFormat.second, GL_VIRTUAL_PAGE_SIZE_X_ARB, 1, &x[0]);
+        y.resize(count);
+        glGetInternalformativ(typeFormat.first, typeFormat.second, GL_VIRTUAL_PAGE_SIZE_Y_ARB, 1, &y[0]);
+        z.resize(count);
+        glGetInternalformativ(typeFormat.first, typeFormat.second, GL_VIRTUAL_PAGE_SIZE_Z_ARB, 1, &z[0]);
+
+        result.resize(count);
+        for (GLint i = 0; i < count; ++i) {
+            result[i] = uvec3(x[i], y[i], z[i]);
+        }
+        qCDebug(gpugl45logging) << "Got " << count << " page sizes";
+    }
+
+    {
+        Lock lock(sparsePageDimensionsByFormatMutex);
+        if (0 == sparsePageDimensionsByFormat.count(typeFormat)) {
+            sparsePageDimensionsByFormat[typeFormat] = result;
+        }
+    }
+
+    return result;
+}
+
+static std::vector<uvec3> getPageDimensionsForFormat(GLenum target, GLenum format) {
+    return getPageDimensionsForFormat({ target, format });
+}
+
 GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texture, bool transfer) {
    return GL45Texture::sync<GL45Texture>(*this, texture, transfer);
 }

-TransferState::TransferState(GLTexture& texture) : _texture(texture) {
+using SparseInfo = GL45Backend::GL45Texture::SparseInfo;
+
+SparseInfo::SparseInfo(GL45Texture& texture)
+    : texture(texture) {
 }

-void TransferState::updateSparse() {
-    glGetTextureParameterIuiv(_texture._id, GL_NUM_SPARSE_LEVELS_ARB, &_maxSparseLevel);
-    _internalFormat = gl::GLTexelFormat::evalGLTexelFormat(_texture._gpuObject.getTexelFormat(), _texture._gpuObject.getTexelFormat()).internalFormat;
-    ivec3 pageSize;
-    glGetInternalformativ(_texture._target, _internalFormat, GL_VIRTUAL_PAGE_SIZE_X_ARB, 1, &pageSize.x);
-    glGetInternalformativ(_texture._target, _internalFormat, GL_VIRTUAL_PAGE_SIZE_Y_ARB, 1, &pageSize.y);
-    glGetInternalformativ(_texture._target, _internalFormat, GL_VIRTUAL_PAGE_SIZE_Z_ARB, 1, &pageSize.z);
-    _pageSize = uvec3(pageSize);
-}
-
-void TransferState::updateMip() {
-    _mipDimensions = _texture._gpuObject.evalMipDimensions(_mipLevel);
-    _mipOffset = uvec3();
-    if (!_texture._gpuObject.isStoredMipFaceAvailable(_mipLevel, _face)) {
-        _srcPointer = nullptr;
+void SparseInfo::maybeMakeSparse() {
+    // Don't enable sparse for objects with explicitly managed mip levels
+    if (!texture._gpuObject.isAutogenerateMips()) {
+        qCDebug(gpugl45logging) << "Don't enable sparse texture for explicitly generated mipmaps on texture " << texture._source.c_str();
        return;
    }

-    auto mip = _texture._gpuObject.accessStoredMipFace(_mipLevel, _face);
-    _texelFormat = gl::GLTexelFormat::evalGLTexelFormat(_texture._gpuObject.getTexelFormat(), mip->getFormat());
-    _srcPointer = mip->readData();
-    _bytesPerLine = (uint32_t)mip->getSize() / _mipDimensions.y;
-    _bytesPerPixel = _bytesPerLine / _mipDimensions.x;
+    const uvec3 dimensions = texture._gpuObject.getDimensions();
+    auto allowedPageDimensions = getPageDimensionsForFormat(texture._target, texture._internalFormat);
+    // In order to enable sparse the texture size must be an integer multiple of the page size
+    for (size_t i = 0; i < allowedPageDimensions.size(); ++i) {
+        pageDimensionsIndex = (uint32_t) i;
+        pageDimensions = allowedPageDimensions[i];
+        // Is this texture an integer multiple of page dimensions?
+        if (uvec3(0) == (dimensions % pageDimensions)) {
+            qCDebug(gpugl45logging) << "Enabling sparse for texture " << texture._source.c_str();
+            sparse = true;
+            break;
+        }
+    }
+
+    if (sparse) {
+        glTextureParameteri(texture._id, GL_TEXTURE_SPARSE_ARB, GL_TRUE);
+        glTextureParameteri(texture._id, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, pageDimensionsIndex);
+    } else {
+        qCDebug(gpugl45logging) << "Size " << dimensions.x << " x " << dimensions.y << 
+            " is not supported by any sparse page size for texture" << texture._source.c_str();
+    }
+}
+
+// This can only be called after we've established our storage size
+void SparseInfo::update() {
+    if (!sparse) {
+        return;
+    }
+    glGetTextureParameterIuiv(texture._id, GL_NUM_SPARSE_LEVELS_ARB, &maxSparseLevel);
+    pageBytes = texture._gpuObject.getTexelFormat().getSize();
+    pageBytes *= pageDimensions.x * pageDimensions.y * pageDimensions.z;
+
+    for (uint16_t mipLevel = 0; mipLevel <= maxSparseLevel; ++mipLevel) {
+        auto mipDimensions = texture._gpuObject.evalMipDimensions(mipLevel);
+        auto mipPageCount = getPageCount(mipDimensions);
+        maxPages += mipPageCount;
+    }
+    if (texture._target == GL_TEXTURE_CUBE_MAP) {
+        maxPages *= GLTexture::CUBE_NUM_FACES;
+    }
+}
+
+uvec3 SparseInfo::getPageCounts(const uvec3& dimensions) const {
+    auto result = (dimensions / pageDimensions) +
+        glm::clamp(dimensions % pageDimensions, glm::uvec3(0), glm::uvec3(1));
+    return result;
+}
+
+uint32_t SparseInfo::getPageCount(const uvec3& dimensions) const {
+    auto pageCounts = getPageCounts(dimensions);
+    return pageCounts.x * pageCounts.y * pageCounts.z;
+}
+
+using TransferState = GL45Backend::GL45Texture::TransferState;
+
+TransferState::TransferState(GL45Texture& texture) : texture(texture) {
+}
+
+void TransferState::updateMip() {
+    mipDimensions = texture._gpuObject.evalMipDimensions(mipLevel);
+    mipOffset = uvec3();
+    if (!texture._gpuObject.isStoredMipFaceAvailable(mipLevel, face)) {
+        srcPointer = nullptr;
+        return;
+    }
+
+    auto mip = texture._gpuObject.accessStoredMipFace(mipLevel, face);
+    texelFormat = gl::GLTexelFormat::evalGLTexelFormat(texture._gpuObject.getTexelFormat(), mip->getFormat());
+    srcPointer = mip->readData();
+    bytesPerLine = (uint32_t)mip->getSize() / mipDimensions.y;
+    bytesPerPixel = bytesPerLine / mipDimensions.x;
 }

 bool TransferState::increment() {
-    if ((_mipOffset.x + _pageSize.x) < _mipDimensions.x) {
-        _mipOffset.x += _pageSize.x;
+    const SparseInfo& sparse = texture._sparseInfo;
+    if ((mipOffset.x + sparse.pageDimensions.x) < mipDimensions.x) {
+        mipOffset.x += sparse.pageDimensions.x;
        return true;
    }

-    if ((_mipOffset.y + _pageSize.y) < _mipDimensions.y) {
-        _mipOffset.x = 0;
-        _mipOffset.y += _pageSize.y;
+    if ((mipOffset.y + sparse.pageDimensions.y) < mipDimensions.y) {
+        mipOffset.x = 0;
+        mipOffset.y += sparse.pageDimensions.y;
        return true;
    }

-    if (_mipOffset.z + _pageSize.z < _mipDimensions.z) {
-        _mipOffset.x = 0;
-        _mipOffset.y = 0;
-        ++_mipOffset.z;
+    if (mipOffset.z + sparse.pageDimensions.z < mipDimensions.z) {
+        mipOffset.x = 0;
+        mipOffset.y = 0;
+        ++mipOffset.z;
        return true;
    }

    // Done with this mip?, move on to the next mip 
-    if (_mipLevel + 1 < _texture.usedMipLevels()) {
-        _mipOffset = uvec3(0);
-        ++_mipLevel;
+    if (mipLevel + 1 < texture.usedMipLevels()) {
+        mipOffset = uvec3(0);
+        ++mipLevel;
        updateMip();
        return true;
    }

-    uint8_t maxFace = (uint8_t)((_texture._target == GL_TEXTURE_CUBE_MAP) ? GLTexture::CUBE_NUM_FACES : 1);
-    uint8_t nextFace = _face + 1;
+    uint8_t maxFace = (uint8_t)((texture._target == GL_TEXTURE_CUBE_MAP) ? GLTexture::CUBE_NUM_FACES : 1);
+    uint8_t nextFace = face + 1;
    // Done with this face?  Move on to the next
    if (nextFace < maxFace) {
-        ++_face;
-        _mipOffset = uvec3(0);
-        _mipLevel = 0;
+        ++face;
+        mipOffset = uvec3(0);
+        mipLevel = 0;
        updateMip();
        return true;
    }
@ -104,10 +217,9 @@ bool TransferState::increment() {
    return false;
 }

-#define DEFAULT_GL_PIXEL_ALIGNMENT 4
 void TransferState::populatePage(std::vector<uint8_t>& buffer) {
    uvec3 pageSize = currentPageSize();
-    auto bytesPerPageLine = _bytesPerPixel * pageSize.x;
+    auto bytesPerPageLine = bytesPerPixel * pageSize.x;
    if (0 != (bytesPerPageLine % DEFAULT_GL_PIXEL_ALIGNMENT)) {
        bytesPerPageLine += DEFAULT_GL_PIXEL_ALIGNMENT - (bytesPerPageLine % DEFAULT_GL_PIXEL_ALIGNMENT);
        assert(0 == (bytesPerPageLine % DEFAULT_GL_PIXEL_ALIGNMENT));
@ -118,14 +230,14 @@ void TransferState::populatePage(std::vector<uint8_t>& buffer) {
    }
    uint8_t* dst = &buffer[0];
    for (uint32_t y = 0; y < pageSize.y; ++y) {
-        uint32_t srcOffset = (_bytesPerLine * (_mipOffset.y + y)) + (_bytesPerPixel * _mipOffset.x);
+        uint32_t srcOffset = (bytesPerLine * (mipOffset.y + y)) + (bytesPerPixel * mipOffset.x);
        uint32_t dstOffset = bytesPerPageLine * y;
-        memcpy(dst + dstOffset, _srcPointer + srcOffset, pageSize.x * _bytesPerPixel);
+        memcpy(dst + dstOffset, srcPointer + srcOffset, pageSize.x * bytesPerPixel);
    }
 }

 uvec3 TransferState::currentPageSize() const {
-    return glm::clamp(_mipDimensions - _mipOffset, uvec3(1), _pageSize);
+    return glm::clamp(mipDimensions - mipOffset, uvec3(1), texture._sparseInfo.pageDimensions);
 }

 GLuint GL45Texture::allocate(const Texture& texture) {
@ -139,25 +251,64 @@ GLuint GL45Backend::getTextureID(const TexturePointer& texture, bool transfer) {
 }

 GL45Texture::GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, bool transferrable)
-    : GLTexture(backend, texture, allocate(texture), transferrable), _transferState(*this) {
+    : GLTexture(backend, texture, allocate(texture), transferrable), _sparseInfo(*this), _transferState(*this) {

-#if SPARSE_TEXTURES
-    if (transferrable) {
-        glTextureParameteri(_id, GL_TEXTURE_SPARSE_ARB, GL_TRUE);
+    if (enableSparseTextures && _transferrable) {
+        _sparseInfo.maybeMakeSparse();
    }
-#endif
 }

-GL45Texture::GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture, GLTexture* original)
-    : GLTexture(backend, texture, allocate(texture), original), _transferState(*this) { }
-
 GL45Texture::~GL45Texture() {
-    // FIXME do we need to explicitly deallocate the virtual memory here?
-    //if (_transferrable) {
-    //    for (uint16_t mipLevel = 0; mipLevel < usedMipLevels(); ++i) {
-    //        glTexturePageCommitmentEXT(_id, mipLevel, offset.x, offset.y, offset.z, size.x, size.y, size.z, GL_TRUE);
-    //    }
-    //}
+    qCDebug(gpugl45logging) << "Destroying texture " << _id << " from source " << _source.c_str();
+    if (_sparseInfo.sparse) {
+        // Remove this texture from the candidate list of derezzable textures
+        {
+            auto mipLevels = usedMipLevels();
+            Lock lock(texturesByMipCountsMutex);
+            if (texturesByMipCounts.count(mipLevels)) {
+                auto& textures = texturesByMipCounts[mipLevels];
+                textures.erase(this);
+                if (textures.empty()) {
+                    texturesByMipCounts.erase(mipLevels);
+                }
+            }
+        }
+
+        // Experimenation suggests that allocating sparse textures on one context/thread and deallocating 
+        // them on another is buggy.  So for sparse textures we need to queue a lambda with the deallocation 
+        // callls to the transfer thread
+        auto id = _id;
+        // Set the class _id to 0 so we don't try to double delete
+        const_cast<GLuint&>(_id) = 0;
+        std::list<std::function<void()>> destructionFunctions;
+        
+        uint8_t maxFace = (uint8_t)((_target == GL_TEXTURE_CUBE_MAP) ? GLTexture::CUBE_NUM_FACES : 1);
+        auto maxSparseMip = std::min<uint16_t>(_maxMip, _sparseInfo.maxSparseLevel);
+        for (uint16_t mipLevel = _minMip; mipLevel <= maxSparseMip; ++mipLevel) {
+            auto mipDimensions = _gpuObject.evalMipDimensions(mipLevel);
+            destructionFunctions.push_back([id, maxFace, mipLevel, mipDimensions] {
+                glTexturePageCommitmentEXT(id, mipLevel, 0, 0, 0, mipDimensions.x, mipDimensions.y, maxFace, GL_FALSE);
+            });
+
+            auto deallocatedPages = _sparseInfo.getPageCount(mipDimensions) * maxFace;
+            assert(deallocatedPages <= _allocatedPages);
+            _allocatedPages -= deallocatedPages;
+        }
+
+        if (0 != _allocatedPages) {
+            qCWarning(gpugl45logging) << "Allocated pages remaining " << _id << " " << _allocatedPages;
+        }
+
+        auto size = _size;
+        _textureTransferHelper->queueExecution([id, size, destructionFunctions] {
+            for (auto function : destructionFunctions) {
+                function();
+            }
+            glDeleteTextures(1, &id);
+            Backend::decrementTextureGPUCount();
+            Backend::updateTextureGPUMemoryUsage(size, 0);
+        });
+    }
 }

 void GL45Texture::withPreservedTexture(std::function<void()> f) const {
@ -165,37 +316,38 @@ void GL45Texture::withPreservedTexture(std::function<void()> f) const {
 }

 void GL45Texture::generateMips() const {
+    qCDebug(gpugl45logging) << "Generating mipmaps for " << _source.c_str();
    glGenerateTextureMipmap(_id);
    (void)CHECK_GL_ERROR();
 }

 void GL45Texture::allocateStorage() const {
-    GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(_gpuObject.getTexelFormat());
-    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, 0);
-    glTextureParameteri(_id, GL_TEXTURE_MAX_LEVEL, _maxMip - _minMip);
    if (_gpuObject.getTexelFormat().isCompressed()) {
        qFatal("Compressed textures not yet supported");
    }
+    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, 0);
+    glTextureParameteri(_id, GL_TEXTURE_MAX_LEVEL, _maxMip - _minMip);
    // Get the dimensions, accounting for the downgrade level
    Vec3u dimensions = _gpuObject.evalMipDimensions(_minMip);
-    glTextureStorage2D(_id, usedMipLevels(), texelFormat.internalFormat, dimensions.x, dimensions.y);
+    glTextureStorage2D(_id, usedMipLevels(), _internalFormat, dimensions.x, dimensions.y);
    (void)CHECK_GL_ERROR();
 }

 void GL45Texture::updateSize() const {
-    setSize(_virtualSize);
-    if (!_id) {
-        return;
-    }
-
    if (_gpuObject.getTexelFormat().isCompressed()) {
        qFatal("Compressed textures not yet supported");
    }
+
+    if (_transferrable) {
+        setSize(_allocatedPages * _sparseInfo.pageBytes);
+    } else {
+        setSize(_virtualSize);
+    }
 }

 void GL45Texture::startTransfer() {
    Parent::startTransfer();
-    _transferState.updateSparse();
+    _sparseInfo.update();
    _transferState.updateMip();
 }

@ -204,48 +356,65 @@ bool GL45Texture::continueTransfer() {
    if (buffer.empty()) {
        buffer.resize(DEFAULT_PAGE_BUFFER_SIZE);
    }
-    uvec3 pageSize = _transferState.currentPageSize();
-    uvec3 offset = _transferState._mipOffset;
+    const uvec3 pageSize = _transferState.currentPageSize();
+    const uvec3& offset = _transferState.mipOffset;

-#if SPARSE_TEXTURES
-    if (_transferState._mipLevel <= _transferState._maxSparseLevel) {
-        glTexturePageCommitmentEXT(_id, _transferState._mipLevel,
-            offset.x, offset.y, _transferState._face,
+    if (_sparseInfo.sparse && _transferState.mipLevel <= _sparseInfo.maxSparseLevel) {
+        if (_allocatedPages > _sparseInfo.maxPages) {
+            qCWarning(gpugl45logging) << "Exceeded max page allocation!";
+        }
+        glTexturePageCommitmentEXT(_id, _transferState.mipLevel,
+            offset.x, offset.y, _transferState.face,
            pageSize.x, pageSize.y, pageSize.z,
            GL_TRUE);
+        ++_allocatedPages;
    }
-#endif

-    if (_transferState._srcPointer) {
+    if (_transferState.srcPointer) {
        // Transfer the mip data
        _transferState.populatePage(buffer);
        if (GL_TEXTURE_2D == _target) {
-            glTextureSubImage2D(_id, _transferState._mipLevel,
+            glTextureSubImage2D(_id, _transferState.mipLevel,
                offset.x, offset.y,
                pageSize.x, pageSize.y,
-                _transferState._texelFormat.format, _transferState._texelFormat.type, &buffer[0]);
+                _transferState.texelFormat.format, _transferState.texelFormat.type, &buffer[0]);
        } else if (GL_TEXTURE_CUBE_MAP == _target) {
-            auto target = CUBE_FACE_LAYOUT[_transferState._face];
+            auto target = CUBE_FACE_LAYOUT[_transferState.face];
            // DSA ARB does not work on AMD, so use EXT
            // glTextureSubImage3D(_id, mipLevel, 0, 0, face, size.x, size.y, 1, texelFormat.format, texelFormat.type, mip->readData());
-            glTextureSubImage2DEXT(_id, target, _transferState._mipLevel,
+            glTextureSubImage2DEXT(_id, target, _transferState.mipLevel,
                offset.x, offset.y,
                pageSize.x, pageSize.y,
-                _transferState._texelFormat.format, _transferState._texelFormat.type, &buffer[0]);
+                _transferState.texelFormat.format, _transferState.texelFormat.type, &buffer[0]);
        }
    }

    serverWait();
-    return _transferState.increment();
+    auto currentMip = _transferState.mipLevel;
+    auto result = _transferState.increment();
+    if (_sparseInfo.sparse && _transferState.mipLevel != currentMip && currentMip <= _sparseInfo.maxSparseLevel) {
+        auto mipDimensions = _gpuObject.evalMipDimensions(currentMip);
+        auto mipExpectedPages = _sparseInfo.getPageCount(mipDimensions);
+        auto newPages = _allocatedPages - _lastMipAllocatedPages;
+        if (newPages != mipExpectedPages) {
+            qCWarning(gpugl45logging) << "Unexpected page allocation size... " << newPages << " " << mipExpectedPages;
+        }
+        _lastMipAllocatedPages = _allocatedPages;
+    }
+    return result;
 }

-void GL45Backend::GL45Texture::syncSampler() const {
+void GL45Texture::finishTransfer() {
+    Parent::finishTransfer();
+}
+
+void GL45Texture::syncSampler() const {
    const Sampler& sampler = _gpuObject.getSampler();

    const auto& fm = FILTER_MODES[sampler.getFilter()];
    glTextureParameteri(_id, GL_TEXTURE_MIN_FILTER, fm.minFilter);
    glTextureParameteri(_id, GL_TEXTURE_MAG_FILTER, fm.magFilter);
-    
+
    if (sampler.doComparison()) {
        glTextureParameteri(_id, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
        glTextureParameteri(_id, GL_TEXTURE_COMPARE_FUNC, COMPARISON_TO_GL[sampler.getComparisonFunction()]);
@ -257,9 +426,131 @@ void GL45Backend::GL45Texture::syncSampler() const {
    glTextureParameteri(_id, GL_TEXTURE_WRAP_T, WRAP_MODES[sampler.getWrapModeV()]);
    glTextureParameteri(_id, GL_TEXTURE_WRAP_R, WRAP_MODES[sampler.getWrapModeW()]);
    glTextureParameterfv(_id, GL_TEXTURE_BORDER_COLOR, (const float*)&sampler.getBorderColor());
-    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, (uint16)sampler.getMipOffset());
+    auto baseMip = std::max<uint16_t>(sampler.getMipOffset(), _minMip);
+    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, baseMip);
    glTextureParameterf(_id, GL_TEXTURE_MIN_LOD, (float)sampler.getMinMip());
    glTextureParameterf(_id, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
    glTextureParameterf(_id, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy());
 }

+void GL45Texture::postTransfer() {
+    Parent::postTransfer();
+    if (_sparseInfo.sparse) {
+        auto mipLevels = usedMipLevels();
+        if (mipLevels > 1 && _minMip < _sparseInfo.maxSparseLevel) {
+            Lock lock(texturesByMipCountsMutex);
+            texturesByMipCounts[mipLevels].insert(this);
+        }
+    }
+}
+
+void GL45Texture::stripToMip(uint16_t newMinMip) {
+    if (!_sparseInfo.sparse) {
+        return;
+    }
+
+    if (newMinMip < _minMip) {
+        qCWarning(gpugl45logging) << "Cannot decrease the min mip";
+        return;
+    }
+
+    if (newMinMip > _sparseInfo.maxSparseLevel) {
+        qCWarning(gpugl45logging) << "Cannot increase the min mip into the mip tail";
+        return;
+    }
+
+    auto mipLevels = usedMipLevels();
+    {
+        Lock lock(texturesByMipCountsMutex);
+        assert(0 != texturesByMipCounts.count(mipLevels));
+        assert(0 != texturesByMipCounts[mipLevels].count(this));
+        texturesByMipCounts[mipLevels].erase(this);
+        if (texturesByMipCounts[mipLevels].empty()) {
+            texturesByMipCounts.erase(mipLevels);
+        }
+    }
+
+    // If we weren't generating mips before, we need to now that we're stripping down mip levels.
+    if (!_gpuObject.isAutogenerateMips()) {
+        qCDebug(gpugl45logging) << "Force mip generation for texture";
+        glGenerateTextureMipmap(_id);
+    }
+
+
+    uint8_t maxFace = (uint8_t)((_target == GL_TEXTURE_CUBE_MAP) ? GLTexture::CUBE_NUM_FACES : 1);
+    for (uint16_t mip = _minMip; mip < newMinMip; ++mip) {
+        auto id = _id;
+        auto mipDimensions = _gpuObject.evalMipDimensions(mip);
+        _textureTransferHelper->queueExecution([id, mip, mipDimensions, maxFace] {
+            glTexturePageCommitmentEXT(id, mip, 0, 0, 0, mipDimensions.x, mipDimensions.y, maxFace, GL_FALSE);
+        });
+
+        auto deallocatedPages = _sparseInfo.getPageCount(mipDimensions) * maxFace;
+        assert(deallocatedPages < _allocatedPages);
+        _allocatedPages -= deallocatedPages;
+    }
+
+    _minMip = newMinMip;
+    // Re-sync the sampler to force access to the new mip level
+    syncSampler();
+    size_t oldSize = _size;
+    updateSize();
+    Q_ASSERT(_size > oldSize);
+
+
+    // Re-insert into the texture-by-mips map if appropriate
+    mipLevels = usedMipLevels();
+    if (_sparseInfo.sparse && mipLevels > 1 && _minMip < _sparseInfo.maxSparseLevel) {
+        Lock lock(texturesByMipCountsMutex);
+        texturesByMipCounts[mipLevels].insert(this);
+    }
+}
+
+void GL45Texture::updateMips() {
+    if (!_sparseInfo.sparse) {
+        return;
+    }
+    auto newMinMip = std::min<uint16_t>(_gpuObject.minMip(), _sparseInfo.maxSparseLevel);
+    if (_minMip < newMinMip) {
+        stripToMip(newMinMip);
+    }
+}
+
+void GL45Texture::derez() {
+    assert(_sparseInfo.sparse);
+    assert(_minMip < _sparseInfo.maxSparseLevel);
+    assert(_minMip < _maxMip);
+    assert(_transferrable);
+    stripToMip(_minMip + 1);
+}
+
+void GL45Backend::derezTextures() const {
+    if (GLTexture::getMemoryPressure() < 1.0f) {
+        return;
+    }
+
+    Lock lock(texturesByMipCountsMutex);
+    if (texturesByMipCounts.empty()) {
+        qCDebug(gpugl45logging) << "No available textures to derez";
+        return;
+    }
+
+    auto mipLevel = texturesByMipCounts.rbegin()->first;
+    if (mipLevel <= 1) {
+        qCDebug(gpugl45logging) << "Max mip levels " << mipLevel;
+        return;
+    }
+
+    qCDebug(gpugl45logging) << "Allowed texture memory " << Texture::getAllowedGPUMemoryUsage();
+    qCDebug(gpugl45logging) << "Used texture memory " << Context::getTextureGPUMemoryUsage();
+
+    GL45Texture* targetTexture = nullptr;
+    {
+        auto& textures = texturesByMipCounts[mipLevel];
+        assert(!textures.empty());
+        targetTexture = *textures.begin();
+    }
+    lock.unlock();
+    targetTexture->derez();
+    qCDebug(gpugl45logging) << "New Used texture memory " << Context::getTextureGPUMemoryUsage();
+}
--- a/libraries/gpu/src/gpu/Context.cpp
+++ b/libraries/gpu/src/gpu/Context.cpp
@ -10,6 +10,7 @@
 //
 #include "Context.h"
 #include "Frame.h"
+#include "GPULogging.h"
 using namespace gpu;

 Context::CreateBackend Context::_createBackendCallback = nullptr;
@ -161,8 +162,9 @@ Backend::TransformCamera Backend::TransformCamera::getEyeCamera(int eye, const S
 }

 // Counters for Buffer and Texture usage in GPU/Context
-std::atomic<uint32_t> Context::_bufferGPUCount{ 0 };
-std::atomic<Buffer::Size> Context::_bufferGPUMemoryUsage{ 0 };
+std::atomic<uint32_t> Context::_fenceCount { 0 };
+std::atomic<uint32_t> Context::_bufferGPUCount { 0 };
+std::atomic<Buffer::Size> Context::_bufferGPUMemoryUsage { 0 };

 std::atomic<uint32_t> Context::_textureGPUCount{ 0 };
 std::atomic<Texture::Size> Context::_textureGPUMemoryUsage{ 0 };
@ -170,10 +172,15 @@ std::atomic<Texture::Size> Context::_textureGPUVirtualMemoryUsage{ 0 };
 std::atomic<uint32_t> Context::_textureGPUTransferCount{ 0 };

 void Context::incrementBufferGPUCount() {
-    _bufferGPUCount++;
+    static std::atomic<uint32_t> max { 0 };
+    auto total = ++_bufferGPUCount;
+    if (total > max.load()) {
+        max = total;
+        qCDebug(gpulogging) << "New max GPU buffers " << total;
+    }
 }
 void Context::decrementBufferGPUCount() {
-    _bufferGPUCount--;
+    --_bufferGPUCount;
 }
 void Context::updateBufferGPUMemoryUsage(Size prevObjectSize, Size newObjectSize) {
    if (prevObjectSize == newObjectSize) {
@ -186,12 +193,30 @@ void Context::updateBufferGPUMemoryUsage(Size prevObjectSize, Size newObjectSize
    }
 }

+void Context::incrementFenceCount() {
+    static std::atomic<uint32_t> max { 0 };
+    auto total = ++_fenceCount;
+    if (total > max.load()) {
+        max = total;
+        qCDebug(gpulogging) << "New max Fences " << total;
+    }
+}
+void Context::decrementFenceCount() {
+    --_fenceCount;
+}
+
 void Context::incrementTextureGPUCount() {
-    _textureGPUCount++;
+    static std::atomic<uint32_t> max { 0 };
+    auto total = ++_textureGPUCount;
+    if (total > max.load()) {
+        max = total;
+        qCDebug(gpulogging) << "New max GPU textures " << total;
+    }
 }
 void Context::decrementTextureGPUCount() {
-    _textureGPUCount--;
+    --_textureGPUCount;
 }
+
 void Context::updateTextureGPUMemoryUsage(Size prevObjectSize, Size newObjectSize) {
    if (prevObjectSize == newObjectSize) {
        return;
@ -215,10 +240,15 @@ void Context::updateTextureGPUVirtualMemoryUsage(Size prevObjectSize, Size newOb
 }

 void Context::incrementTextureGPUTransferCount() {
-    _textureGPUTransferCount++;
+    static std::atomic<uint32_t> max { 0 };
+    auto total = ++_textureGPUTransferCount;
+    if (total > max.load()) {
+        max = total;
+        qCDebug(gpulogging) << "New max GPU textures transfers" << total;
+    }
 }
 void Context::decrementTextureGPUTransferCount() {
-    _textureGPUTransferCount--;
+    --_textureGPUTransferCount;
 }

 uint32_t Context::getBufferGPUCount() {
--- a/libraries/gpu/src/gpu/Context.h
+++ b/libraries/gpu/src/gpu/Context.h
@ -230,6 +230,9 @@ protected:
    static void decrementBufferGPUCount();
    static void updateBufferGPUMemoryUsage(Size prevObjectSize, Size newObjectSize);

+    static void incrementFenceCount();
+    static void decrementFenceCount();
+
    static void incrementTextureGPUCount();
    static void decrementTextureGPUCount();
    static void updateTextureGPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
@ -237,7 +240,9 @@ protected:
    static void incrementTextureGPUTransferCount();
    static void decrementTextureGPUTransferCount();

-    // Buffer and Texture Counters
+    // Buffer, Texture and Fence Counters
+    static std::atomic<uint32_t> _fenceCount;
+
    static std::atomic<uint32_t> _bufferGPUCount;
    static std::atomic<Size> _bufferGPUMemoryUsage;

--- a/libraries/gpu/src/gpu/Framebuffer.cpp
+++ b/libraries/gpu/src/gpu/Framebuffer.cpp
@ -32,6 +32,7 @@ Framebuffer* Framebuffer::create( const Format& colorBufferFormat, uint16 width,
    auto framebuffer = Framebuffer::create();

    auto colorTexture = TexturePointer(Texture::create2D(colorBufferFormat, width, height, Sampler(Sampler::FILTER_MIN_MAG_POINT)));
+    colorTexture->setSource("Framebuffer::colorTexture");

    framebuffer->setRenderBuffer(0, colorTexture);

@ -42,8 +43,9 @@ Framebuffer* Framebuffer::create( const Format& colorBufferFormat, const Format&
    auto framebuffer = Framebuffer::create();

    auto colorTexture = TexturePointer(Texture::create2D(colorBufferFormat, width, height, Sampler(Sampler::FILTER_MIN_MAG_POINT)));
+    colorTexture->setSource("Framebuffer::colorTexture");
    auto depthTexture = TexturePointer(Texture::create2D(depthStencilBufferFormat, width, height, Sampler(Sampler::FILTER_MIN_MAG_POINT)));
-
+    depthTexture->setSource("Framebuffer::depthTexture");
    framebuffer->setRenderBuffer(0, colorTexture);
    framebuffer->setDepthStencilBuffer(depthTexture, depthStencilBufferFormat);

@ -55,7 +57,7 @@ Framebuffer* Framebuffer::createShadowmap(uint16 width) {

    auto depthFormat = Element(gpu::SCALAR, gpu::FLOAT, gpu::DEPTH); // Depth32 texel format
    auto depthTexture = TexturePointer(Texture::create2D(depthFormat, width, width));
-        
+    depthTexture->setSource("Framebuffer::shadowMap");
    Sampler::Desc samplerDesc;
    samplerDesc._borderColor = glm::vec4(1.0f);
    samplerDesc._wrapModeU = Sampler::WRAP_BORDER;
@ -113,30 +115,6 @@ void Framebuffer::updateSize(const TexturePointer& texture) {
    }
 }

-void Framebuffer::resize(uint16 width, uint16 height, uint16 numSamples) {
-    if (width && height && numSamples && !isEmpty() && !isSwapchain()) {
-        if ((width != _width) || (height != _height) || (numSamples != _numSamples)) {
-            for (uint32 i = 0; i < _renderBuffers.size(); ++i) {
-                if (_renderBuffers[i]) {
-                    _renderBuffers[i]._texture->resize2D(width, height, numSamples);
-                    _numSamples = _renderBuffers[i]._texture->getNumSamples();
-                    ++_colorStamps[i];
-                }
-            }
-
-            if (_depthStencilBuffer) {
-                _depthStencilBuffer._texture->resize2D(width, height, numSamples);
-                _numSamples = _depthStencilBuffer._texture->getNumSamples();
-                ++_depthStamp;
-            }
-
-            _width = width;
-            _height = height;
-         //   _numSamples = numSamples;
-        }
-    }
-}
-
 uint16 Framebuffer::getWidth() const {
    if (isSwapchain()) {
        return getSwapchain()->getWidth();
--- a/libraries/gpu/src/gpu/Framebuffer.h
+++ b/libraries/gpu/src/gpu/Framebuffer.h
@ -130,9 +130,6 @@ public:

    float getAspectRatio() const { return getWidth() / (float) getHeight() ; }

-    // If not a swapchain canvas, resize can resize all the render buffers and depth stencil attached in one call
-    void resize( uint16 width, uint16 height, uint16 samples = 1 );
-
    static const uint32 MAX_NUM_RENDER_BUFFERS = 8; 
    static uint32 getMaxNumRenderBuffers() { return MAX_NUM_RENDER_BUFFERS; }

--- a/libraries/gpu/src/gpu/Texture.h
+++ b/libraries/gpu/src/gpu/Texture.h
@ -389,6 +389,8 @@ public:
    
    uint16 usedMipLevels() const { return (_maxMip - _minMip) + 1; }

+    const std::string& source() const { return _source; }
+    void setSource(const std::string& source) { _source = source; }
    bool setMinMip(uint16 newMinMip);
    bool incremementMinMip(uint16 count = 1);

@ -450,6 +452,8 @@ public:
    const GPUObjectPointer gpuObject {};

 protected:
+    // Not strictly necessary, but incredibly useful for debugging
+    std::string _source;
    std::unique_ptr< Storage > _storage;

    Stamp _stamp = 0;
--- a/libraries/model-networking/src/model-networking/TextureCache.cpp
+++ b/libraries/model-networking/src/model-networking/TextureCache.cpp
@ -35,8 +35,7 @@
 #include "ModelNetworkingLogging.h"

 TextureCache::TextureCache() {
-    const qint64 TEXTURE_DEFAULT_UNUSED_MAX_SIZE = DEFAULT_UNUSED_MAX_SIZE;
-    setUnusedResourceCacheSize(TEXTURE_DEFAULT_UNUSED_MAX_SIZE);
+    setUnusedResourceCacheSize(0);
    setObjectName("TextureCache");

    // Expose enum Type to JS/QML via properties
@ -118,6 +117,7 @@ const unsigned char OPAQUE_BLACK[] = { 0x00, 0x00, 0x00, 0xFF };
 const gpu::TexturePointer& TextureCache::getWhiteTexture() {
    if (!_whiteTexture) {
        _whiteTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, 1, 1));
+        _whiteTexture->setSource("TextureCache::_whiteTexture");
        _whiteTexture->assignStoredMip(0, _whiteTexture->getTexelFormat(), sizeof(OPAQUE_WHITE), OPAQUE_WHITE);
    }
    return _whiteTexture;
@ -126,6 +126,7 @@ const gpu::TexturePointer& TextureCache::getWhiteTexture() {
 const gpu::TexturePointer& TextureCache::getGrayTexture() {
    if (!_grayTexture) {
        _grayTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, 1, 1));
+        _grayTexture->setSource("TextureCache::_grayTexture");
        _grayTexture->assignStoredMip(0, _whiteTexture->getTexelFormat(), sizeof(OPAQUE_WHITE), OPAQUE_GRAY);
    }
    return _grayTexture;
@ -134,6 +135,7 @@ const gpu::TexturePointer& TextureCache::getGrayTexture() {
 const gpu::TexturePointer& TextureCache::getBlueTexture() {
    if (!_blueTexture) {
        _blueTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, 1, 1));
+        _blueTexture->setSource("TextureCache::_blueTexture");
        _blueTexture->assignStoredMip(0, _blueTexture->getTexelFormat(), sizeof(OPAQUE_BLUE), OPAQUE_BLUE);
    }
    return _blueTexture;
@ -142,6 +144,7 @@ const gpu::TexturePointer& TextureCache::getBlueTexture() {
 const gpu::TexturePointer& TextureCache::getBlackTexture() {
    if (!_blackTexture) {
        _blackTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, 1, 1));
+        _blackTexture->setSource("TextureCache::_blackTexture");
        _blackTexture->assignStoredMip(0, _whiteTexture->getTexelFormat(), sizeof(OPAQUE_BLACK), OPAQUE_BLACK);
    }
    return _blackTexture;
--- a/libraries/model/src/model/TextureMap.cpp
+++ b/libraries/model/src/model/TextureMap.cpp
@ -176,7 +176,7 @@ void generateFaceMips(gpu::Texture* texture, QImage& image, gpu::Element formatM
 #endif
 }

-gpu::Texture* TextureUsage::process2DTextureColorFromImage(const QImage& srcImage, bool isLinear, bool doCompress, bool generateMips) {
+gpu::Texture* TextureUsage::process2DTextureColorFromImage(const QImage& srcImage, const std::string& srcImageName, bool isLinear, bool doCompress, bool generateMips) {
    bool validAlpha = false;
    bool alphaAsMask = true;
    QImage image = process2DImageColor(srcImage, validAlpha, alphaAsMask);
@ -189,7 +189,7 @@ gpu::Texture* TextureUsage::process2DTextureColorFromImage(const QImage& srcImag
        defineColorTexelFormats(formatGPU, formatMip, image, isLinear, doCompress);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
-
+        theTexture->setSource(srcImageName);
        auto usage = gpu::Texture::Usage::Builder().withColor();
        if (validAlpha) {
            usage.withAlpha();
@ -210,20 +210,20 @@ gpu::Texture* TextureUsage::process2DTextureColorFromImage(const QImage& srcImag
 }

 gpu::Texture* TextureUsage::create2DTextureFromImage(const QImage& srcImage, const std::string& srcImageName) {
-    return process2DTextureColorFromImage(srcImage, false, false, true);
+    return process2DTextureColorFromImage(srcImage, srcImageName, false, false, true);
 }


 gpu::Texture* TextureUsage::createAlbedoTextureFromImage(const QImage& srcImage, const std::string& srcImageName) {
-    return process2DTextureColorFromImage(srcImage, false, true, true);
+    return process2DTextureColorFromImage(srcImage, srcImageName, false, true, true);
 }

 gpu::Texture* TextureUsage::createEmissiveTextureFromImage(const QImage& srcImage, const std::string& srcImageName) {
-    return process2DTextureColorFromImage(srcImage, false, true, true);
+    return process2DTextureColorFromImage(srcImage, srcImageName, false, true, true);
 }

 gpu::Texture* TextureUsage::createLightmapTextureFromImage(const QImage& srcImage, const std::string& srcImageName) {
-    return process2DTextureColorFromImage(srcImage, false, true, true);
+    return process2DTextureColorFromImage(srcImage, srcImageName, false, true, true);
 }


@ -241,6 +241,7 @@ gpu::Texture* TextureUsage::createNormalTextureFromNormalImage(const QImage& src
        gpu::Element formatMip = gpu::Element(gpu::VEC3, gpu::NUINT8, gpu::RGB);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
+        theTexture->setSource(srcImageName);
        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
        generateMips(theTexture, image, formatMip);
    }
@ -324,6 +325,7 @@ gpu::Texture* TextureUsage::createNormalTextureFromBumpImage(const QImage& srcIm
        gpu::Element formatMip = gpu::Element(gpu::VEC3, gpu::NUINT8, gpu::RGB);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
+        theTexture->setSource(srcImageName);
        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
        generateMips(theTexture, image, formatMip);
    }
@ -355,6 +357,7 @@ gpu::Texture* TextureUsage::createRoughnessTextureFromImage(const QImage& srcIma
        gpu::Element formatMip = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
+        theTexture->setSource(srcImageName);
        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
        generateMips(theTexture, image, formatMip);

@ -392,6 +395,7 @@ gpu::Texture* TextureUsage::createRoughnessTextureFromGlossImage(const QImage& s
        gpu::Element formatMip = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
+        theTexture->setSource(srcImageName);
        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
        generateMips(theTexture, image, formatMip);
        
@ -426,6 +430,7 @@ gpu::Texture* TextureUsage::createMetallicTextureFromImage(const QImage& srcImag
        gpu::Element formatMip = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);

        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
+        theTexture->setSource(srcImageName);
        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
        generateMips(theTexture, image, formatMip);

@ -737,6 +742,7 @@ gpu::Texture* TextureUsage::processCubeTextureColorFromImage(const QImage& srcIm
        // If the 6 faces have been created go on and define the true Texture
        if (faces.size() == gpu::Texture::NUM_FACES_PER_TYPE[gpu::Texture::TEX_CUBE]) {
            theTexture = gpu::Texture::createCube(formatGPU, faces[0].width(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR, gpu::Sampler::WRAP_CLAMP));
+            theTexture->setSource(srcImageName);
            int f = 0;
            for (auto& face : faces) {
                theTexture->assignStoredMipFace(0, formatMip, face.byteCount(), face.constBits(), f);
--- a/libraries/model/src/model/TextureMap.h
+++ b/libraries/model/src/model/TextureMap.h
@ -47,7 +47,7 @@ public:
    static const QImage process2DImageColor(const QImage& srcImage, bool& validAlpha, bool& alphaAsMask);
    static void defineColorTexelFormats(gpu::Element& formatGPU, gpu::Element& formatMip,
        const QImage& srcImage, bool isLinear, bool doCompress);
-    static gpu::Texture* process2DTextureColorFromImage(const QImage& srcImage, bool isLinear, bool doCompress, bool generateMips);
+    static gpu::Texture* process2DTextureColorFromImage(const QImage& srcImage, const std::string& srcImageName, bool isLinear, bool doCompress, bool generateMips);
    static gpu::Texture* processCubeTextureColorFromImage(const QImage& srcImage, const std::string& srcImageName, bool isLinear, bool doCompress, bool generateMips, bool generateIrradiance);

 };
--- a/libraries/networking/src/HifiSockAddr.cpp
+++ b/libraries/networking/src/HifiSockAddr.cpp
@ -124,36 +124,6 @@ QDataStream& operator>>(QDataStream& dataStream, HifiSockAddr& sockAddr) {
    return dataStream;
 }

-QHostAddress getGuessedLocalAddress() {
-
-    QHostAddress localAddress;
-
-    foreach(const QNetworkInterface &networkInterface, QNetworkInterface::allInterfaces()) {
-        if (networkInterface.flags() & QNetworkInterface::IsUp
-            && networkInterface.flags() & QNetworkInterface::IsRunning
-            && networkInterface.flags() & ~QNetworkInterface::IsLoopBack) {
-            // we've decided that this is the active NIC
-            // enumerate it's addresses to grab the IPv4 address
-            foreach(const QNetworkAddressEntry &entry, networkInterface.addressEntries()) {
-                // make sure it's an IPv4 address that isn't the loopback
-                if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol && !entry.ip().isLoopback()) {
-
-                    // set our localAddress and break out
-                    localAddress = entry.ip();
-                    break;
-                }
-            }
-        }
-
-        if (!localAddress.isNull()) {
-            break;
-        }
-    }
-
-    // return the looked up local address
-    return localAddress;
-}
-
 uint qHash(const HifiSockAddr& key, uint seed) {
    // use the existing QHostAddress and quint16 hash functions to get our hash
    return qHash(key.getAddress(), seed) ^ qHash(key.getPort(), seed);
--- a/libraries/networking/src/HifiSockAddr.h
+++ b/libraries/networking/src/HifiSockAddr.h
@ -91,9 +91,6 @@ namespace std {
    };
 }

-
-QHostAddress getGuessedLocalAddress();
-
 Q_DECLARE_METATYPE(HifiSockAddr);

 #endif // hifi_HifiSockAddr_h
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@ -25,6 +25,7 @@
 #include <tbb/parallel_for.h>

 #include <LogHandler.h>
+#include <shared/NetworkUtils.h>
 #include <NumericalConstants.h>
 #include <SettingHandle.h>
 #include <SharedUtil.h>
--- a/libraries/render-utils/src/AntialiasingEffect.cpp
+++ b/libraries/render-utils/src/AntialiasingEffect.cpp
@ -34,7 +34,21 @@ Antialiasing::Antialiasing() {
 const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {
    int width = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().width();
    int height = DependencyManager::get<FramebufferCache>()->getFrameBufferSize().height();
-    
+
+    if (_antialiasingBuffer && _antialiasingBuffer->getSize() != uvec2(width, height)) {
+        _antialiasingBuffer.reset();
+    }
+
+    if (!_antialiasingBuffer) {
+        // Link the antialiasing FBO to texture
+        _antialiasingBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
+        auto format = gpu::Element::COLOR_SRGBA_32; // DependencyManager::get<FramebufferCache>()->getLightingTexture()->getTexelFormat();
+        auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
+        _antialiasingTexture = gpu::TexturePointer(gpu::Texture::create2D(format, width, height, defaultSampler));
+        _antialiasingTexture->setSource("Antialiasing::_antialiasingTexture");
+        _antialiasingBuffer->setRenderBuffer(0, _antialiasingTexture);
+    }
+
    if (!_antialiasingPipeline) {
        auto vs = gpu::Shader::createVertex(std::string(fxaa_vert));
        auto ps = gpu::Shader::createPixel(std::string(fxaa_frag));
@ -51,21 +65,10 @@ const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {

        state->setDepthTest(false, false, gpu::LESS_EQUAL);

-        // Link the antialiasing FBO to texture
-        _antialiasingBuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
-        auto format = gpu::Element::COLOR_SRGBA_32; // DependencyManager::get<FramebufferCache>()->getLightingTexture()->getTexelFormat();
-        auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
-        _antialiasingTexture = gpu::TexturePointer(gpu::Texture::create2D(format, width, height, defaultSampler));
-        _antialiasingBuffer->setRenderBuffer(0, _antialiasingTexture);
-
        // Good to go add the brand new pipeline
        _antialiasingPipeline = gpu::Pipeline::create(program, state);
    }

-    if (width != _antialiasingBuffer->getWidth() || height != _antialiasingBuffer->getHeight()) {
-        _antialiasingBuffer->resize(width, height);
-    }
-
    return _antialiasingPipeline;
 }

--- a/libraries/render-utils/src/DeferredFramebuffer.cpp
+++ b/libraries/render-utils/src/DeferredFramebuffer.cpp
@ -54,9 +54,11 @@ void DeferredFramebuffer::allocate() {
    auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);

    _deferredColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
-
+    _deferredColorTexture->setSource("DeferredFramebuffer::_deferredColorTexture");
    _deferredNormalTexture = gpu::TexturePointer(gpu::Texture::create2D(linearFormat, width, height, defaultSampler));
+    _deferredNormalTexture->setSource("DeferredFramebuffer::_deferredNormalTexture");
    _deferredSpecularTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, width, height, defaultSampler));
+    _deferredSpecularTexture->setSource("DeferredFramebuffer::_deferredSpecularTexture");

    _deferredFramebuffer->setRenderBuffer(0, _deferredColorTexture);
    _deferredFramebuffer->setRenderBuffer(1, _deferredNormalTexture);
@ -67,6 +69,7 @@ void DeferredFramebuffer::allocate() {
    auto depthFormat = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::DEPTH_STENCIL); // Depth24_Stencil8 texel format
    if (!_primaryDepthTexture) {
        _primaryDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(depthFormat, width, height, defaultSampler));
+        _primaryDepthTexture->setSource("DeferredFramebuffer::_primaryDepthTexture");
    }

    _deferredFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
@ -77,6 +80,7 @@ void DeferredFramebuffer::allocate() {
    auto smoothSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR);

    _lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::R11G11B10), width, height, defaultSampler));
+    _lightingTexture->setSource("DeferredFramebuffer::_lightingTexture");
    _lightingFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _lightingFramebuffer->setRenderBuffer(0, _lightingTexture);
    _lightingFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
--- a/libraries/render-utils/src/DeferredLightingEffect.cpp
+++ b/libraries/render-utils/src/DeferredLightingEffect.cpp
@ -337,7 +337,13 @@ void PreparePrimaryFramebuffer::run(const SceneContextPointer& sceneContext, con

    auto framebufferCache = DependencyManager::get<FramebufferCache>();
    auto framebufferSize = framebufferCache->getFrameBufferSize();
-        glm::ivec2 frameSize(framebufferSize.width(), framebufferSize.height());
+    glm::uvec2 frameSize(framebufferSize.width(), framebufferSize.height());
+
+    // Resizing framebuffers instead of re-building them seems to cause issues with threaded 
+    // rendering
+    if (_primaryFramebuffer && _primaryFramebuffer->getSize() != frameSize) {
+        _primaryFramebuffer.reset();
+    }

    if (!_primaryFramebuffer) {
        _primaryFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
@ -345,6 +351,7 @@ void PreparePrimaryFramebuffer::run(const SceneContextPointer& sceneContext, con

        auto defaultSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_POINT);
        auto primaryColorTexture = gpu::TexturePointer(gpu::Texture::create2D(colorFormat, frameSize.x, frameSize.y, defaultSampler));
+        primaryColorTexture->setSource("PreparePrimaryFramebuffer::primaryColorTexture");


        _primaryFramebuffer->setRenderBuffer(0, primaryColorTexture);
@ -352,11 +359,10 @@ void PreparePrimaryFramebuffer::run(const SceneContextPointer& sceneContext, con

        auto depthFormat = gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::DEPTH_STENCIL); // Depth24_Stencil8 texel format
        auto primaryDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(depthFormat, frameSize.x, frameSize.y, defaultSampler));
+        primaryDepthTexture->setSource("PreparePrimaryFramebuffer::primaryDepthTexture");

        _primaryFramebuffer->setDepthStencilBuffer(primaryDepthTexture, depthFormat);
-
    }
-    _primaryFramebuffer->resize(frameSize.x, frameSize.y);

    primaryFramebuffer = _primaryFramebuffer;
 }
--- a/libraries/render-utils/src/SubsurfaceScattering.cpp
+++ b/libraries/render-utils/src/SubsurfaceScattering.cpp
@ -415,6 +415,7 @@ gpu::TexturePointer SubsurfaceScatteringResource::generateScatteringProfile(Rend
    //  const auto pixelFormat = gpu::Element::COLOR_SRGBA_32;
    const auto pixelFormat = gpu::Element::COLOR_R11G11B10;
    auto profileMap = gpu::TexturePointer(gpu::Texture::create2D(pixelFormat, PROFILE_RESOLUTION, 1, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR, gpu::Sampler::WRAP_CLAMP)));
+    profileMap->setSource("Generated Scattering Profile");
    diffuseProfileGPU(profileMap, args);
    return profileMap;
 }
@ -426,6 +427,7 @@ gpu::TexturePointer SubsurfaceScatteringResource::generatePreIntegratedScatterin
    const auto pixelFormat = gpu::Element::COLOR_R11G11B10;
    auto scatteringLUT = gpu::TexturePointer(gpu::Texture::create2D(pixelFormat, TABLE_RESOLUTION, TABLE_RESOLUTION, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR, gpu::Sampler::WRAP_CLAMP)));
    //diffuseScatter(scatteringLUT);
+    scatteringLUT->setSource("Generated pre-integrated scattering");
    diffuseScatterGPU(profile, scatteringLUT, args);
    return scatteringLUT;
 }
@ -433,6 +435,7 @@ gpu::TexturePointer SubsurfaceScatteringResource::generatePreIntegratedScatterin
 gpu::TexturePointer SubsurfaceScatteringResource::generateScatteringSpecularBeckmann(RenderArgs* args) {
    const int SPECULAR_RESOLUTION = 256;
    auto beckmannMap = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32 /*gpu::Element(gpu::SCALAR, gpu::HALF, gpu::RGB)*/, SPECULAR_RESOLUTION, SPECULAR_RESOLUTION, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR, gpu::Sampler::WRAP_CLAMP)));
+    beckmannMap->setSource("Generated beckmannMap");
    computeSpecularBeckmannGPU(beckmannMap, args);
    return beckmannMap;
 }
--- a/libraries/render-utils/src/SurfaceGeometryPass.cpp
+++ b/libraries/render-utils/src/SurfaceGeometryPass.cpp
@ -74,6 +74,7 @@ void LinearDepthFramebuffer::allocate() {
    // For Linear Depth:
    _linearDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RGB), width, height,
        gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _linearDepthTexture->setSource("LinearDepthFramebuffer::_linearDepthTexture");
    _linearDepthFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _linearDepthFramebuffer->setRenderBuffer(0, _linearDepthTexture);
    _linearDepthFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, _primaryDepthTexture->getTexelFormat());
@ -81,10 +82,12 @@ void LinearDepthFramebuffer::allocate() {
    // For Downsampling:
    _halfLinearDepthTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::RGB), _halfFrameSize.x, _halfFrameSize.y,
        gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _halfLinearDepthTexture->setSource("LinearDepthFramebuffer::_halfLinearDepthTexture");
    _halfLinearDepthTexture->autoGenerateMips(5);

    _halfNormalTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC3, gpu::NUINT8, gpu::RGB), _halfFrameSize.x, _halfFrameSize.y,
        gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _halfNormalTexture->setSource("LinearDepthFramebuffer::_halfNormalTexture");

    _downsampleFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _downsampleFramebuffer->setRenderBuffer(0, _halfLinearDepthTexture);
@ -301,14 +304,17 @@ void SurfaceGeometryFramebuffer::allocate() {
    auto height = _frameSize.y;

    _curvatureTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, width, height, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _curvatureTexture->setSource("SurfaceGeometryFramebuffer::_curvatureTexture");
    _curvatureFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _curvatureFramebuffer->setRenderBuffer(0, _curvatureTexture);

    _lowCurvatureTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, width, height, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _lowCurvatureTexture->setSource("SurfaceGeometryFramebuffer::_lowCurvatureTexture");
    _lowCurvatureFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _lowCurvatureFramebuffer->setRenderBuffer(0, _lowCurvatureTexture);

    _blurringTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, width, height, gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT)));
+    _blurringTexture->setSource("SurfaceGeometryFramebuffer::_blurringTexture");
    _blurringFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
    _blurringFramebuffer->setRenderBuffer(0, _blurringTexture);
 }
--- a/libraries/render/src/render/BlurTask.cpp
+++ b/libraries/render/src/render/BlurTask.cpp
@ -96,6 +96,9 @@ bool BlurInOutResource::updateResources(const gpu::FramebufferPointer& sourceFra
    if (!sourceFramebuffer) {
        return false;
    }
+    if (_blurredFramebuffer && _blurredFramebuffer->getSize() != sourceFramebuffer->getSize()) {
+        _blurredFramebuffer.reset();
+    }

    if (!_blurredFramebuffer) {
        _blurredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
@ -107,21 +110,17 @@ bool BlurInOutResource::updateResources(const gpu::FramebufferPointer& sourceFra
        auto blurringSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT);
        auto blurringTarget = gpu::TexturePointer(gpu::Texture::create2D(sourceFramebuffer->getRenderBuffer(0)->getTexelFormat(), sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), blurringSampler));
        _blurredFramebuffer->setRenderBuffer(0, blurringTarget);
-    } else {
-        // it would be easier to just call resize on the bluredFramebuffer and let it work if needed but the source might loose it's depth buffer when doing so
-        if ((_blurredFramebuffer->getWidth() != sourceFramebuffer->getWidth()) || (_blurredFramebuffer->getHeight() != sourceFramebuffer->getHeight())) {
-            _blurredFramebuffer->resize(sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), sourceFramebuffer->getNumSamples());
-            //if (sourceFramebuffer->hasDepthStencil()) {
-             //   _blurredFramebuffer->setDepthStencilBuffer(sourceFramebuffer->getDepthStencilBuffer(), sourceFramebuffer->getDepthStencilBufferFormat());
-            //}
-        }
-    }
+    } 

    blurringResources.sourceTexture = sourceFramebuffer->getRenderBuffer(0);
    blurringResources.blurringFramebuffer = _blurredFramebuffer;
    blurringResources.blurringTexture = _blurredFramebuffer->getRenderBuffer(0);

    if (_generateOutputFramebuffer) {
+        if (_outputFramebuffer && _outputFramebuffer->getSize() != sourceFramebuffer->getSize()) {
+            _outputFramebuffer.reset();
+        }
+
        // The job output the blur result in a new Framebuffer spawning here.
        // Let s make sure it s ready for this
        if (!_outputFramebuffer) {
@ -134,13 +133,6 @@ bool BlurInOutResource::updateResources(const gpu::FramebufferPointer& sourceFra
            auto blurringSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_LINEAR_MIP_POINT);
            auto blurringTarget = gpu::TexturePointer(gpu::Texture::create2D(sourceFramebuffer->getRenderBuffer(0)->getTexelFormat(), sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), blurringSampler));
            _outputFramebuffer->setRenderBuffer(0, blurringTarget);
-        } else {
-            if ((_outputFramebuffer->getWidth() != sourceFramebuffer->getWidth()) || (_outputFramebuffer->getHeight() != sourceFramebuffer->getHeight())) {
-                _outputFramebuffer->resize(sourceFramebuffer->getWidth(), sourceFramebuffer->getHeight(), sourceFramebuffer->getNumSamples());
-             /*   if (sourceFramebuffer->hasDepthStencil()) {
-                    _outputFramebuffer->setDepthStencilBuffer(sourceFramebuffer->getDepthStencilBuffer(), sourceFramebuffer->getDepthStencilBufferFormat());
-                }*/
-            }
        }

        // Should be good to use the output Framebuffer as final
--- a/libraries/shared/src/shared/AbstractLoggerInterface.h
+++ b/libraries/shared/src/shared/AbstractLoggerInterface.h
--- a/libraries/shared/src/shared/FileLogger.cpp
+++ b/libraries/shared/src/shared/FileLogger.cpp
@ -15,11 +15,12 @@
 #include <QtCore/QDir>
 #include <QtGui/QDesktopServices>

-#include <NumericalConstants.h>
-#include <FileUtils.h>
-#include <SharedUtil.h>
+#include "FileUtils.h"
+#include "NetworkUtils.h"
+
+#include "../NumericalConstants.h"
+#include "../SharedUtil.h"

-#include "HifiSockAddr.h"

 static const QString FILENAME_FORMAT = "hifi-log_%1_%2.txt";
 static const QString DATETIME_FORMAT = "yyyy-MM-dd_hh.mm.ss";
--- a/libraries/shared/src/shared/FileLogger.h
+++ b/libraries/shared/src/shared/FileLogger.h
@ -13,7 +13,7 @@
 #define hifi_FileLogger_h

 #include "AbstractLoggerInterface.h"
-#include <GenericQueueThread.h>
+#include "../GenericQueueThread.h"

 #include <QtCore/QFile>

--- a/libraries/shared/src/shared/FileUtils.cpp
+++ b/libraries/shared/src/shared/FileUtils.cpp
@ -9,14 +9,29 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //

-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qdesktopservices.h>
-#include <qprocess.h>
-#include <qurl.h>

 #include "FileUtils.h"

+#include <QtCore/QDir>
+#include <QtCore/QFileInfo>
+#include <QtCore/QProcess>
+#include <QtCore/QUrl>
+#include <QtCore/QTextStream>
+#include <QtCore/QRegularExpression>
+#include <QtGui/QDesktopServices>
+
+
+QString FileUtils::readFile(const QString& filename) {
+    QFile file(filename);
+    file.open(QFile::Text | QFile::ReadOnly);
+    QString result;
+    result.append(QTextStream(&file).readAll());
+    return result;
+}
+
+QStringList FileUtils::readLines(const QString& filename, QString::SplitBehavior splitBehavior) {
+    return readFile(filename).split(QRegularExpression("[\\r\\n]"), QString::SkipEmptyParts);
+}

 void FileUtils::locateFile(QString filePath) {

--- a/libraries/shared/src/shared/FileUtils.h
+++ b/libraries/shared/src/shared/FileUtils.h
@ -19,7 +19,8 @@ class FileUtils {
 public:
    static void locateFile(QString fileName);
    static QString standardPath(QString subfolder);
-
+    static QString readFile(const QString& filename);
+    static QStringList readLines(const QString& filename, QString::SplitBehavior splitBehavior = QString::KeepEmptyParts);
 };

 #endif // hifi_FileUtils_h
--- a/libraries/shared/src/shared/NetworkUtils.cpp
+++ b/libraries/shared/src/shared/NetworkUtils.cpp
@ -0,0 +1,42 @@
+//
+//  Created by Bradley Austin Davis on 2016/09/20
+//  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 "NetworkUtils.h"
+#include <QtNetwork/QNetworkInterface>
+
+QHostAddress getGuessedLocalAddress() {
+
+    QHostAddress localAddress;
+
+    foreach(const QNetworkInterface &networkInterface, QNetworkInterface::allInterfaces()) {
+        if (networkInterface.flags() & QNetworkInterface::IsUp
+            && networkInterface.flags() & QNetworkInterface::IsRunning
+            && networkInterface.flags() & ~QNetworkInterface::IsLoopBack) {
+            // we've decided that this is the active NIC
+            // enumerate it's addresses to grab the IPv4 address
+            foreach(const QNetworkAddressEntry &entry, networkInterface.addressEntries()) {
+                // make sure it's an IPv4 address that isn't the loopback
+                if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol && !entry.ip().isLoopback()) {
+
+                    // set our localAddress and break out
+                    localAddress = entry.ip();
+                    break;
+                }
+            }
+        }
+
+        if (!localAddress.isNull()) {
+            break;
+        }
+    }
+
+    // return the looked up local address
+    return localAddress;
+}
+
+
--- a/libraries/shared/src/shared/NetworkUtils.h
+++ b/libraries/shared/src/shared/NetworkUtils.h
@ -0,0 +1,17 @@
+//
+//  Created by Bradley Austin Davis on 2016/09/20
+//  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
+//
+
+#pragma once
+#ifndef hifi_shared_NetworkUtils_h
+#define hifi_shared_NetworkUtils_h
+
+#include <QtNetwork/QHostAddress>
+
+QHostAddress getGuessedLocalAddress();
+
+#endif // hifi_shared_NetworkUtils_h
--- a/tests/render-perf/src/Camera.hpp
+++ b/tests/render-perf/src/Camera.hpp
@ -14,9 +14,10 @@ protected:

 public:
    glm::quat getOrientation() const {
-        return glm::angleAxis(yaw, Vectors::UP);
+        return glm::angleAxis(yawPitch.x, Vectors::UP) * glm::angleAxis(yawPitch.y, Vectors::RIGHT);
    }
-    float yaw { 0 };
+
+    vec2 yawPitch { 0 };
    glm::vec3 position;
    float rotationSpeed { 1.0f };
    float movementSpeed { 1.0f };
@ -76,7 +77,12 @@ public:
    };

    void rotate(const float delta) {
-        yaw += delta;
+        yawPitch.x += delta;
+        updateViewMatrix();
+    }
+
+    void rotate(const glm::vec2& delta) {
+        yawPitch += delta;
        updateViewMatrix();
    }

@ -84,7 +90,11 @@ public:
        glm::vec3 f = rotation * Vectors::UNIT_NEG_Z;
        f.y = 0;
        f = glm::normalize(f);
-        yaw = angleBetween(Vectors::UNIT_NEG_Z, f);
+        yawPitch.x = angleBetween(Vectors::UNIT_NEG_Z, f);
+        f = rotation * Vectors::UNIT_NEG_Z;
+        f.x = 0;
+        f = glm::normalize(f);
+        yawPitch.y = angleBetween(Vectors::UNIT_NEG_Z, f);
        updateViewMatrix();
    }

--- a/tests/render-perf/src/main.cpp
+++ b/tests/render-perf/src/main.cpp
@ -17,6 +17,7 @@
 #include <QtCore/QDir>
 #include <QtCore/QElapsedTimer>
 #include <QtCore/QLoggingCategory>
+#include <QtCore/QRegularExpression>
 #include <QtCore/QTimer>
 #include <QtCore/QThread>
 #include <QtCore/QThreadPool>
@ -32,12 +33,12 @@


 #include <shared/RateCounter.h>
+#include <shared/NetworkUtils.h>
+#include <shared/FileLogger.h>
+#include <shared/FileUtils.h>
+#include <LogHandler.h>
 #include <AssetClient.h>

-//#include <gl/OffscreenGLCanvas.h>
-//#include <gl/GLHelpers.h>
-//#include <gl/QOpenGLContextWrapper.h>
-
 #include <gpu/gl/GLBackend.h>
 #include <gpu/gl/GLFramebuffer.h>
 #include <gpu/gl/GLTexture.h>
@ -99,56 +100,6 @@ public:
    }
 };

-#if 0
-class GlfwCamera : public Camera {
-    Key forKey(int key) {
-        switch (key) {
-        case GLFW_KEY_W: return FORWARD;
-        case GLFW_KEY_S: return BACK;
-        case GLFW_KEY_A: return LEFT;
-        case GLFW_KEY_D: return RIGHT;
-        case GLFW_KEY_E: return UP;
-        case GLFW_KEY_C: return DOWN;
-        case GLFW_MOUSE_BUTTON_LEFT: return MLEFT;
-        case GLFW_MOUSE_BUTTON_RIGHT: return MRIGHT;
-        case GLFW_MOUSE_BUTTON_MIDDLE: return MMIDDLE;
-        default: break;
-        }
-        return INVALID;
-    }
-
-    vec2 _lastMouse;
-public:
-    void keyHandler(int key, int scancode, int action, int mods) {
-        Key k = forKey(key);
-        if (k == INVALID) {
-            return;
-        }
-        if (action == GLFW_PRESS) {
-            keys.set(k);
-        } else if (action == GLFW_RELEASE) {
-            keys.reset(k);
-        }
-    }
-
-    //static void MouseMoveHandler(GLFWwindow* window, double posx, double posy);
-    //static void MouseScrollHandler(GLFWwindow* window, double xoffset, double yoffset);
-    void onMouseMove(double posx, double posy) {
-        vec2 mouse = vec2(posx, posy);
-        vec2 delta = mouse - _lastMouse;
-        if (keys.at(Key::MRIGHT)) {
-            dolly(delta.y * 0.01f);
-        } else if (keys.at(Key::MLEFT)) {
-            rotate(delta.x * -0.01f);
-        } else if (keys.at(Key::MMIDDLE)) {
-            delta.y *= -1.0f;
-            translate(delta * -0.01f);
-        }
-        _lastMouse = mouse;
-    }
-
-};
-#else
 class QWindowCamera : public Camera {
    Key forKey(int key) {
        switch (key) {
@ -188,7 +139,8 @@ public:
        if (buttons & Qt::RightButton) {
            dolly(delta.y * 0.01f);
        } else if (buttons & Qt::LeftButton) {
-            rotate(delta.x * -0.01f);
+            //rotate(delta.x * -0.01f);
+            rotate(delta * -0.01f);
        } else if (buttons & Qt::MiddleButton) {
            delta.y *= -1.0f;
            translate(delta * -0.01f);
@ -197,7 +149,6 @@ public:
        _lastMouse = mouse;
    }
 };
-#endif

 static QString toHumanSize(size_t size, size_t maxUnit = std::numeric_limits<size_t>::max()) {
    static const std::vector<QString> SUFFIXES{ { "B", "KB", "MB", "GB", "TB", "PB" } };
@ -240,7 +191,7 @@ public:
    std::mutex _mutex;
    std::shared_ptr<gpu::Backend> _backend;
    std::vector<uint64_t> _frameTimes;
-    size_t _frameIndex;
+    size_t _frameIndex { 0 };
    std::mutex _frameLock;
    std::queue<gpu::FramePointer> _pendingFrames;
    gpu::FramePointer _activeFrame;
@ -252,7 +203,6 @@ public:
        _pendingFrames.push(frame);
    }

-
    void initialize(QWindow* window, gl::Context& initContext) {
        setObjectName("RenderThread");
        _context.setWindow(window);
@ -286,10 +236,6 @@ public:
        }

        _context.makeCurrent();
-        glewExperimental = true;
-        glewInit();
-        glGetError();
-
        _frameTimes.resize(FRAME_TIME_BUFFER_SIZE, 0);
        {
            auto vs = gpu::StandardShaderLib::getDrawUnitQuadTexcoordVS();
@ -375,7 +321,6 @@ public:
        }
    }

-
    bool process() override {
        std::queue<gpu::FramePointer> pendingFrames;
        {
@ -420,6 +365,7 @@ public:
 };

 render::ItemID BackgroundRenderData::_item = 0;
+QSharedPointer<FileLogger> logger;

 namespace render {
    template <> const ItemKey payloadGetKey(const BackgroundRenderData::Pointer& stuff) {
@ -552,36 +498,6 @@ public:
        _renderThread.initialize(this, _initContext);
        _initContext.makeCurrent();

-#if 0
-        glfwInit();
-        glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
-        glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
-        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-        resizeWindow(QSize(800, 600));
-        _window = glfwCreateWindow(_size.width(), _size.height(), "Window Title", NULL, NULL);
-        if (!_window) {
-            throw std::runtime_error("Could not create window");
-        }
-
-        glfwSetWindowUserPointer(_window, this);
-        glfwSetKeyCallback(_window, KeyboardHandler);
-        glfwSetMouseButtonCallback(_window, MouseHandler);
-        glfwSetCursorPosCallback(_window, MouseMoveHandler);
-        glfwSetWindowCloseCallback(_window, CloseHandler);
-        glfwSetFramebufferSizeCallback(_window, FramebufferSizeHandler);
-        glfwSetScrollCallback(_window, MouseScrollHandler);
-
-
-        glfwMakeContextCurrent(_window);
-        GLDebug::setupLogger(this);
-#endif
-
-#ifdef Q_OS_WIN
-        //wglSwapIntervalEXT(0);
-#endif
-
        // FIXME use a wait condition
        QThread::msleep(1000);
        _renderThread.submitFrame(gpu::FramePointer());
@ -622,6 +538,16 @@ public:
        DependencyManager::destroy<NodeList>();
    }

+    void loadCommands(const QString& filename) {
+        QFileInfo fileInfo(filename);
+        if (!fileInfo.exists()) {
+            return;
+        }
+        _commandPath = fileInfo.absolutePath();
+        _commands = FileUtils::readLines(filename);
+        _commandIndex = 0;
+    }
+
 protected:

    bool eventFilter(QObject *obj, QEvent *event) override {
@ -666,6 +592,14 @@ protected:
            toggleCulling();
            return;

+        case Qt::Key_Home:
+            gpu::Texture::setAllowedGPUMemoryUsage(0);
+            return;
+
+        case Qt::Key_End:
+            gpu::Texture::setAllowedGPUMemoryUsage(MB_TO_BYTES(256));
+            return;
+

        default:
            break;
@ -776,10 +710,11 @@ private:
    };

    void updateText() {
-        QString title = QString("FPS %1 Culling %2 TextureMemory GPU %3 CPU %4")
+        QString title = QString("FPS %1 Culling %2 TextureMemory GPU %3 CPU %4 Max GPU %5")
            .arg(_fps).arg(_cullingEnabled)
            .arg(toHumanSize(gpu::Context::getTextureGPUMemoryUsage(), 2))
-            .arg(toHumanSize(gpu::Texture::getTextureCPUMemoryUsage(), 2));
+            .arg(toHumanSize(gpu::Texture::getTextureCPUMemoryUsage(), 2))
+            .arg(toHumanSize(gpu::Texture::getAllowedGPUMemoryUsage(), 2));
        setTitle(title);
 #if 0
        {
@ -803,10 +738,77 @@ private:
 #endif
    }

+    void runCommand(const QString& command) {
+        qDebug() << "Running command: " << command;
+        QStringList commandParams = command.split(QRegularExpression(QString("\\s")));
+        QString verb = commandParams[0].toLower();
+        if (verb == "loop") {
+            if (commandParams.length() > 1) {
+                int maxLoops = commandParams[1].toInt();
+                if (maxLoops < ++_commandLoops) {
+                    qDebug() << "Exceeded loop count";
+                    return;
+                }
+            }
+            _commandIndex = 0;
+        } else if (verb == "wait") {
+            if (commandParams.length() < 2) {
+                qDebug() << "No wait time specified";
+                return;
+            }
+            int seconds = commandParams[1].toInt();
+            _nextCommandTime = usecTimestampNow() + seconds * USECS_PER_SECOND;
+        } else if (verb == "load") {
+            if (commandParams.length() < 2) {
+                qDebug() << "No load file specified";
+                return;
+            }
+            QString file = commandParams[1];
+            if (QFileInfo(file).isRelative()) {
+                file = _commandPath + "/" + file;
+            }
+            if (!QFileInfo(file).exists()) {
+                qDebug() << "Cannot find scene file " + file;
+                return;
+            }
+
+            importScene(file);
+        } else if (verb == "go") {
+            if (commandParams.length() < 2) {
+                qDebug() << "No destination specified for go command";
+                return;
+            }
+            parsePath(commandParams[1]);
+        } else {
+            qDebug() << "Unknown command " << command;
+        }
+    }
+
+    void runNextCommand(quint64 now) {
+        if (_commands.empty()) {
+            return;
+        }
+
+        if (_commandIndex >= _commands.size()) {
+            _commands.clear();
+            return;
+        }
+
+        if (now < _nextCommandTime) {
+            return;
+        }
+
+        _nextCommandTime = 0;
+        QString command = _commands[_commandIndex++];
+        runCommand(command);
+    }
+
    void update() {
        auto now = usecTimestampNow();
        static auto last = now;

+        runNextCommand(now);
+
        float delta = now - last;
        // Update the camera
        _camera.update(delta / USECS_PER_SECOND);
@ -959,7 +961,6 @@ private:
            QString atpUrl = QUrl::fromLocalFile(atpPath).toString();
            ResourceManager::setUrlPrefixOverride("atp:/", atpUrl + "/");
        }
-        _settings.setValue(LAST_SCENE_KEY, fileName);
        _octree->clear();
        _octree->getTree()->readFromURL(fileName);
    }
@ -978,6 +979,7 @@ private:
        if (fileName.isNull()) {
            return;
        }
+        _settings.setValue(LAST_SCENE_KEY, fileName);
        importScene(fileName);
    }

@ -1015,7 +1017,7 @@ private:
    }

    void resetPosition() {
-        _camera.yaw = 0;
+        _camera.yawPitch = vec3(0);
        _camera.setPosition(vec3());
    }

@ -1077,6 +1079,13 @@ private:
    model::SunSkyStage _sunSkyStage;
    model::LightPointer _globalLight { std::make_shared<model::Light>() };
    bool _ready { false };
+
+    QStringList _commands;
+    QString _commandPath;
+    int _commandLoops { 0 };
+    int _commandIndex { -1 };
+    uint64_t _nextCommandTime { 0 };
+
    //TextOverlay* _textOverlay;
    static bool _cullingEnabled;

@ -1093,12 +1102,14 @@ private:
 bool QTestWindow::_cullingEnabled = true;

 void messageHandler(QtMsgType type, const QMessageLogContext& context, const QString& message) {
-    if (!message.isEmpty()) {
+    QString logMessage = LogHandler::getInstance().printMessage((LogMsgType)type, context, message);
+
+    if (!logMessage.isEmpty()) {
 #ifdef Q_OS_WIN
-        OutputDebugStringA(message.toLocal8Bit().constData());
+        OutputDebugStringA(logMessage.toLocal8Bit().constData());
        OutputDebugStringA("\n");
 #endif
-        std::cout << message.toLocal8Bit().constData() << std::endl;
+        logger->addMessage(qPrintable(logMessage + "\n"));
    }
 }

@ -1106,16 +1117,19 @@ const char * LOG_FILTER_RULES = R"V0G0N(
 hifi.gpu=true
 )V0G0N";

+
 int main(int argc, char** argv) {
    QApplication app(argc, argv);
    QCoreApplication::setApplicationName("RenderPerf");
    QCoreApplication::setOrganizationName("High Fidelity");
    QCoreApplication::setOrganizationDomain("highfidelity.com");
+    logger.reset(new FileLogger());

    qInstallMessageHandler(messageHandler);
    QLoggingCategory::setFilterRules(LOG_FILTER_RULES);
    QTestWindow::setup();
    QTestWindow window;
+    //window.loadCommands("C:/Users/bdavis/Git/dreaming/exports/commands.txt");
    app.exec();
    return 0;
 }
--- a/tests/render-texture-load/src/main.cpp
+++ b/tests/render-texture-load/src/main.cpp
@ -297,8 +297,6 @@ public:
    };

    QTestWindow() {
-
-        _currentTexture = _textures.end();
        {
            QStringList stringList;
            QFile textFile(DATA_DIR.path() + "/loads.txt");
@ -318,12 +316,13 @@ public:
                QString timeStr = s.left(index);
                auto time = timeStr.toUInt();
                QString path = DATA_DIR.path() + "/" + s.right(s.length() - index).trimmed();
-                qDebug() << "Path " << path;
                if (!QFileInfo(path).exists()) {
                    continue;
                }
-                _textureLoads.push({ time, path, s });
+                qDebug() << "Path " << path;
+                _texturesFiles.push_back({ time, path, s });
            }
+            _textures.resize(_texturesFiles.size());
        }

        installEventFilter(this);
@ -383,6 +382,33 @@ protected:
    }

    void keyPressEvent(QKeyEvent* event) override {
+        switch (event->key()) {
+            case Qt::Key_Left:
+                prevTexture();
+                break;
+            case Qt::Key_Right:
+                nextTexture();
+                break;
+            case Qt::Key_Return:
+                reportMemory();
+                break;
+            case Qt::Key_PageDown:
+                derezTexture();
+                break;
+            case Qt::Key_Home:
+                unloadAll();
+                break;
+            case Qt::Key_End:
+                loadAll();
+                break;
+            case Qt::Key_Down:
+                loadTexture();
+                break;
+            case Qt::Key_Up:
+                unloadTexture();
+                break;
+        }
+        QWindow::keyPressEvent(event);
    }

    void keyReleaseEvent(QKeyEvent* event) override {
@ -395,10 +421,80 @@ protected:
        resizeWindow(ev->size());
    }

+    void nextTexture() {
+        if (_textures.empty()) {
+            return;
+        }
+        auto textureCount = _textures.size();
+        _currentTextureIndex = (_currentTextureIndex + 1) % textureCount;
+        loadTexture();
+    }
+
+    void prevTexture() {
+        if (_textures.empty()) {
+            return;
+        }
+        auto textureCount = _textures.size();
+        _currentTextureIndex = (_currentTextureIndex + textureCount - 1) % textureCount;
+        loadTexture();
+    }
+
+    void reportMemory() {
+        static GLint lastMemory = 0;
+        GLint availableMem;
+        glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &availableMem);
+        qDebug() << "Memory available " << availableMem;
+        if (lastMemory != 0) {
+            qDebug() << "Delta " << availableMem - lastMemory;
+        }
+        lastMemory = availableMem;
+    }
+
+    void derezTexture() {
+        if (!_textures[_currentTextureIndex]) {
+            return;
+        }
+        auto texture = _textures[_currentTextureIndex];
+        texture->setMinMip(texture->minMip() + 1);
+    }
+
+    void loadTexture() {
+        if (_textures[_currentTextureIndex]) {
+            return;
+        }
+        auto file = _texturesFiles[_currentTextureIndex].file;
+        qDebug() << "Loading texture " << file;
+        _textures[_currentTextureIndex] = DependencyManager::get<TextureCache>()->getImageTexture(file);
+    }
+
+    void unloadTexture() {
+        if (_textures.empty()) {
+            return;
+        }
+        _textures[_currentTextureIndex].reset();
+    }
+
+    void loadAll() {
+        for (size_t i = 0; i < _texturesFiles.size(); ++i) {
+            if (_textures[i]) {
+                continue;
+            }
+            auto file = _texturesFiles[i].file;
+            qDebug() << "Loading texture " << file;
+            _textures[i] = DependencyManager::get<TextureCache>()->getImageTexture(file);
+        }
+    }
+
+    void unloadAll() {
+        for (auto& texture : _textures) {
+            texture.reset();
+        }
+    }
+
 private:
-    std::queue<TextureLoad> _textureLoads;
-    std::list<gpu::TexturePointer> _textures;
-    std::list<gpu::TexturePointer>::iterator _currentTexture;
+    size_t _currentTextureIndex { 0 };
+    std::vector<TextureLoad> _texturesFiles;
+    std::vector<gpu::TexturePointer> _textures;

    uint16_t _fps;
    gpu::PipelinePointer _simplePipeline;
@ -438,7 +534,9 @@ private:
        auto now = usecTimestampNow();
        static auto last = now;
        auto delta = (now - last) / USECS_PER_MSEC;
-        if (!_textureLoads.empty()) {
+        Q_UNUSED(delta);
+#if 0
+        if (!_textures.empty()) {
            const auto& front = _textureLoads.front();
            if (delta >= front.time) {
                QFileInfo fileInfo(front.file);
@ -456,6 +554,7 @@ private:
                }
            }
        }
+#endif
    }

    void render() {
@ -474,14 +573,8 @@ private:
            auto vpsize = framebuffer->getSize();
            auto vppos = ivec2(0);
            batch.setViewportTransform(ivec4(vppos, vpsize));
-            if (_currentTexture != _textures.end()) {
-                ++_currentTexture;
-            }
-            if (_currentTexture == _textures.end()) {
-                _currentTexture = _textures.begin();
-            }
-            if (_currentTexture != _textures.end()) {
-                batch.setResourceTexture(0, *_currentTexture);
+            if (!_textures.empty()) {
+                batch.setResourceTexture(0, _textures[_currentTextureIndex]);
            }
            batch.setPipeline(_simplePipeline);
            batch.draw(gpu::TRIANGLE_STRIP, 4);
@ -564,7 +657,6 @@ int main(int argc, char** argv) {
        }).waitForDownload();
    }

-
    QTestWindow::setup();
    QTestWindow window;
    app.exec();