diff --git a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp index 0d286c46eb..20e4f4bc18 100644 --- a/libraries/entities-renderer/src/RenderableWebEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableWebEntityItem.cpp @@ -31,7 +31,7 @@ const float METERS_TO_INCHES = 39.3701f; static uint32_t _currentWebCount { 0 }; // Don't allow more than 100 concurrent web views -static const uint32_t MAX_CONCURRENT_WEB_VIEWS = 20; +static const uint32_t MAX_CONCURRENT_WEB_VIEWS = 0; // If a web-view hasn't been rendered for 30 seconds, de-allocate the framebuffer static uint64_t MAX_NO_RENDER_INTERVAL = 30 * USECS_PER_SECOND; @@ -71,7 +71,7 @@ RenderableWebEntityItem::~RenderableWebEntityItem() { bool RenderableWebEntityItem::buildWebSurface(QSharedPointer renderer) { if (_currentWebCount >= MAX_CONCURRENT_WEB_VIEWS) { - qWarning() << "Too many concurrent web views to create new view"; + //qWarning() << "Too many concurrent web views to create new view"; return false; } QString javaScriptToInject; diff --git a/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp b/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp index c37ee46bfd..09361689d8 100644 --- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp +++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp @@ -181,13 +181,13 @@ void GL45ResourceTexture::populateTransferQueue() { const uint8_t maxFace = GLTexture::getFaceCount(_target); uint16_t sourceMip = _populatedMip; - qDebug() << "populateTransferQueue info : " << _populatedMip << " " << _maxAllocatedMip << " " << _allocatedMip; + //qDebug() << "populateTransferQueue info : " << _populatedMip << " " << _maxAllocatedMip << " " << _allocatedMip; do { --sourceMip; auto targetMip = sourceMip - _allocatedMip; auto mipDimensions = _gpuObject.evalMipDimensions(sourceMip); bool transferQueued = false; - qDebug() << "populateTransferQueue " << QString::fromStdString(_gpuObject.source()) << sourceMip << " " << targetMip; + //qDebug() << "populateTransferQueue " << QString::fromStdString(_gpuObject.source()) << sourceMip << " " << targetMip; for (uint8_t face = 0; face < maxFace; ++face) { if (!_gpuObject.isStoredMipFaceAvailable(sourceMip, face)) { const_cast(_gpuObject).requestInterestInMip(sourceMip); diff --git a/libraries/gpu/src/gpu/Texture.h b/libraries/gpu/src/gpu/Texture.h index 8c9d62e3b8..e71cd63fbd 100755 --- a/libraries/gpu/src/gpu/Texture.h +++ b/libraries/gpu/src/gpu/Texture.h @@ -34,6 +34,8 @@ namespace ktx { namespace gpu { +extern const std::string SOURCE_HASH_KEY; + // THe spherical harmonics is a nice tool for cubemap, so if required, the irradiance SH can be automatically generated // with the cube texture class Texture; diff --git a/libraries/gpu/src/gpu/Texture_ktx.cpp b/libraries/gpu/src/gpu/Texture_ktx.cpp index 1eb6d6b10f..eb6bb169ce 100644 --- a/libraries/gpu/src/gpu/Texture_ktx.cpp +++ b/libraries/gpu/src/gpu/Texture_ktx.cpp @@ -11,6 +11,7 @@ #include "Texture.h" +#include #include using namespace gpu; @@ -41,6 +42,7 @@ struct GPUKTXPayload { } }; +const std::string gpu::SOURCE_HASH_KEY { "hifi.sourceHash" }; std::string GPUKTXPayload::KEY{ "hifi.gpu" }; KtxStorage::KtxStorage(const std::string& filename) : _filename(filename) { @@ -91,7 +93,7 @@ std::shared_ptr KtxStorage::maybeOpenFile() { } PixelsPointer KtxStorage::getMipFace(uint16 level, uint8 face) const { - qDebug() << "getMipFace: " << QString::fromStdString(_filename) << ": " << level << " " << face; + //qDebug() << "getMipFace: " << QString::fromStdString(_filename) << ": " << level << " " << face; storage::StoragePointer result; auto faceOffset = _ktxDescriptor->getMipFaceTexelsOffset(level, face); auto faceSize = _ktxDescriptor->getMipFaceTexelsSize(level, face); @@ -108,14 +110,14 @@ Size KtxStorage::getMipFaceSize(uint16 level, uint8 face) const { bool KtxStorage::isMipAvailable(uint16 level, uint8 face) const { auto avail = level >= _minMipLevelAvailable; - qDebug() << "isMipAvailable: " << QString::fromStdString(_filename) << ": " << level << " " << face << avail << _minMipLevelAvailable << " " << _ktxDescriptor->header.numberOfMipmapLevels; + //qDebug() << "isMipAvailable: " << QString::fromStdString(_filename) << ": " << level << " " << face << avail << _minMipLevelAvailable << " " << _ktxDescriptor->header.numberOfMipmapLevels; //return true; return avail; } void KtxStorage::assignMipData(uint16 level, const storage::StoragePointer& storage) { if (level != _minMipLevelAvailable - 1) { - qWarning() << "Invalid level to be stored"; + qWarning() << "Invalid level to be stored, expected: " << (_minMipLevelAvailable - 1) << ", got: " << level; return; } @@ -124,7 +126,10 @@ void KtxStorage::assignMipData(uint16 level, const storage::StoragePointer& stor } if (storage->size() != _ktxDescriptor->images[level]._imageSize) { - throw std::runtime_error("Invalid image size for level"); + qDebug() << "Invalid image size: " << storage->size() << ", expected: " << _ktxDescriptor->images[level]._imageSize + << ", filename: " << QString::fromStdString(_filename); + //throw std::runtime_error("Invalid image size for level"); + return; } @@ -258,7 +263,6 @@ ktx::KTXUniquePointer Texture::serialize(const Texture& texture) { ktx::KeyValues keyValues; keyValues.emplace_back(ktx::KeyValue(GPUKTXPayload::KEY, sizeof(GPUKTXPayload), (ktx::Byte*) &keyval)); - static const std::string SOURCE_HASH_KEY = "hifi.sourceHash"; auto hash = texture.sourceHash(); if (!hash.empty()) { keyValues.emplace_back(ktx::KeyValue(SOURCE_HASH_KEY, static_cast(hash.size()), (ktx::Byte*) hash.c_str())); diff --git a/libraries/ktx/src/ktx/KTX.cpp b/libraries/ktx/src/ktx/KTX.cpp index 73751bdef2..45820b9351 100644 --- a/libraries/ktx/src/ktx/KTX.cpp +++ b/libraries/ktx/src/ktx/KTX.cpp @@ -34,30 +34,75 @@ uint32_t Header::evalMaxDimension() const { return std::max(getPixelWidth(), std::max(getPixelHeight(), getPixelDepth())); } -uint32_t Header::evalPixelWidth(uint32_t level) const { - return std::max(getPixelWidth() >> level, 1U); +uint32_t Header::evalPixelOrBlockWidth(uint32_t level) const { + auto pixelWidth = std::max(getPixelWidth() >> level, 1U); + if (getGLType() == GLType::COMPRESSED_TYPE) { + return (pixelWidth + 3) / 4; + } else { + return pixelWidth; + } } -uint32_t Header::evalPixelHeight(uint32_t level) const { - return std::max(getPixelHeight() >> level, 1U); +uint32_t Header::evalPixelOrBlockHeight(uint32_t level) const { + auto pixelWidth = std::max(getPixelHeight() >> level, 1U); + if (getGLType() == GLType::COMPRESSED_TYPE) { + auto format = getGLInternaFormat_Compressed(); + switch (format) { + case GLInternalFormat_Compressed::COMPRESSED_SRGB_S3TC_DXT1_EXT: // BC1 + case GLInternalFormat_Compressed::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: // BC1A + case GLInternalFormat_Compressed::COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: // BC3 + case GLInternalFormat_Compressed::COMPRESSED_RED_RGTC1: // BC4 + case GLInternalFormat_Compressed::COMPRESSED_RG_RGTC2: // BC5 + return (pixelWidth + 3) / 4; + default: + throw std::runtime_error("Unknown format"); + } + } else { + return pixelWidth; + } } -uint32_t Header::evalPixelDepth(uint32_t level) const { +uint32_t Header::evalPixelOrBlockDepth(uint32_t level) const { return std::max(getPixelDepth() >> level, 1U); } -size_t Header::evalPixelSize() const { - return 4;//glTypeSize; // Really we should generate the size from the FOrmat etc +size_t Header::evalPixelOrBlockSize() const { + if (getGLType() == GLType::COMPRESSED_TYPE) { + auto format = getGLInternaFormat_Compressed(); + if (format == GLInternalFormat_Compressed::COMPRESSED_SRGB_S3TC_DXT1_EXT) { + return 8; + } else if (format == GLInternalFormat_Compressed::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) { + return 8; + } else if (format == GLInternalFormat_Compressed::COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT) { + return 16; + } else if (format == GLInternalFormat_Compressed::COMPRESSED_RED_RGTC1) { + return 8; + } else if (format == GLInternalFormat_Compressed::COMPRESSED_RG_RGTC2) { + return 16; + } + } else { + auto baseFormat = getGLBaseInternalFormat(); + if (baseFormat == GLBaseInternalFormat::RED) { + return 1; + } else if (baseFormat == GLBaseInternalFormat::RG) { + return 2; + } else if (baseFormat == GLBaseInternalFormat::RGB) { + return 3; + } else if (baseFormat == GLBaseInternalFormat::RGBA) { + return 4; + } + } + throw std::runtime_error("Unknown format"); } size_t Header::evalRowSize(uint32_t level) const { - auto pixWidth = evalPixelWidth(level); - auto pixSize = evalPixelSize(); + auto pixWidth = evalPixelOrBlockWidth(level); + auto pixSize = evalPixelOrBlockSize(); auto netSize = pixWidth * pixSize; auto padding = evalPadding(netSize); return netSize + padding; } size_t Header::evalFaceSize(uint32_t level) const { - auto pixHeight = evalPixelHeight(level); - auto pixDepth = evalPixelDepth(level); + auto pixHeight = evalPixelOrBlockHeight(level); + auto pixDepth = evalPixelOrBlockDepth(level); auto rowSize = evalRowSize(level); return pixDepth * pixHeight * rowSize; } diff --git a/libraries/ktx/src/ktx/KTX.h b/libraries/ktx/src/ktx/KTX.h index e8ed7da8e3..7f6f2da939 100644 --- a/libraries/ktx/src/ktx/KTX.h +++ b/libraries/ktx/src/ktx/KTX.h @@ -336,11 +336,11 @@ namespace ktx { uint32_t getNumberOfLevels() const { return (numberOfMipmapLevels ? numberOfMipmapLevels : 1); } uint32_t evalMaxDimension() const; - uint32_t evalPixelWidth(uint32_t level) const; - uint32_t evalPixelHeight(uint32_t level) const; - uint32_t evalPixelDepth(uint32_t level) const; + uint32_t evalPixelOrBlockWidth(uint32_t level) const; + uint32_t evalPixelOrBlockHeight(uint32_t level) const; + uint32_t evalPixelOrBlockDepth(uint32_t level) const; - size_t evalPixelSize() const; + size_t evalPixelOrBlockSize() const; size_t evalRowSize(uint32_t level) const; size_t evalFaceSize(uint32_t level) const; size_t evalImageSize(uint32_t level) const; diff --git a/libraries/ktx/src/ktx/Writer.cpp b/libraries/ktx/src/ktx/Writer.cpp index 4596bf00c0..0d3d4e1d60 100644 --- a/libraries/ktx/src/ktx/Writer.cpp +++ b/libraries/ktx/src/ktx/Writer.cpp @@ -155,7 +155,7 @@ namespace ktx { ptr++; #ifdef DEBUG for (size_t k = 0; k < descriptors[i]._imageSize/4; k++) { - *(ptr + k) = 0xFFFF00FF; + *(ptr + k) = 0xFFFFFFFF; } #endif currentDestPtr += descriptors[i]._imageSize + sizeof(uint32_t); diff --git a/libraries/model-networking/src/model-networking/TextureCache.cpp b/libraries/model-networking/src/model-networking/TextureCache.cpp index abc7ecfc41..3e06142d8e 100644 --- a/libraries/model-networking/src/model-networking/TextureCache.cpp +++ b/libraries/model-networking/src/model-networking/TextureCache.cpp @@ -245,7 +245,10 @@ gpu::TexturePointer getFallbackTextureForType(image::TextureUsage::Type type) { } NetworkTexture::~NetworkTexture() { - _textureSource->getGPUTexture()->unregisterMipInterestListener(this); + auto texture = _textureSource->getGPUTexture(); + if (texture) { + texture->unregisterMipInterestListener(this); + } } /// Returns a texture version of an image file @@ -412,7 +415,6 @@ void NetworkTexture::startMipRangeRequest(uint16_t low, uint16_t high) { range.fromInclusive = -15000; _ktxMipRequest->setByteRange(range); } else { - // TODO: Discover range for other mips ByteRange range; range.fromInclusive = ktx::KTX_HEADER_SIZE + _originalKtxDescriptor->header.bytesOfKeyValueData + _originalKtxDescriptor->images[low]._imageOffset + 4; @@ -431,6 +433,7 @@ void NetworkTexture::startMipRangeRequest(uint16_t low, uint16_t high) { void NetworkTexture::ktxHeaderRequestFinished() { assert(!_ktxHeaderLoaded); + _headerRequestFinished = true; if (_ktxHeaderRequest->getResult() == ResourceRequest::Success) { _ktxHeaderLoaded = true; _ktxHeaderData = _ktxHeaderRequest->getData(); @@ -447,7 +450,7 @@ void NetworkTexture::ktxMipRequestFinished() { && _ktxMipLevelRangeInFlight.second == NULL_MIP_LEVEL; if (_ktxMipRequest->getResult() == ResourceRequest::Success) { - if (_initialKtxLoaded) { + if (_highMipRequestFinished) { assert(_ktxMipLevelRangeInFlight.second - _ktxMipLevelRangeInFlight.first == 0); _lowestKnownPopulatedMip = _ktxMipLevelRangeInFlight.first; @@ -456,6 +459,7 @@ void NetworkTexture::ktxMipRequestFinished() { _ktxMipRequest->getData().size(), reinterpret_cast(_ktxMipRequest->getData().data())); //texture->assignStoredMip(level, image._imageSize, ktxData); } else { + _highMipRequestFinished = true; _ktxHighMipData = _ktxMipRequest->getData(); maybeCreateKTX(); } @@ -469,118 +473,144 @@ void NetworkTexture::ktxMipRequestFinished() { // This is called when the header or top mips have been loaded void NetworkTexture::maybeCreateKTX() { - if (_ktxHeaderData.size() > 0 && _ktxHighMipData.size() > 0) { - // create ktx... - auto header = reinterpret_cast(_ktxHeaderData.data()); + if (_headerRequestFinished && _highMipRequestFinished) { + ResourceCache::requestCompleted(_self); + + if (_ktxHeaderData.size() > 0 && _ktxHighMipData.size() > 0) { + // create ktx... + auto header = reinterpret_cast(_ktxHeaderData.data()); + + qDebug() << "Creating KTX"; + qDebug() << "Identifier:" << QString(QByteArray((char*)header->identifier, 12)); + qDebug() << "Type:" << header->glType; + qDebug() << "TypeSize:" << header->glTypeSize; + qDebug() << "numberOfArrayElements:" << header->numberOfArrayElements; + qDebug() << "numberOfFaces:" << header->numberOfFaces; + qDebug() << "numberOfMipmapLevels:" << header->numberOfMipmapLevels; + auto kvSize = header->bytesOfKeyValueData; + if (kvSize > _ktxHeaderData.size() - ktx::KTX_HEADER_SIZE) { + qWarning() << "Cannot load " << _url << ", did not receive all kv data with initial request"; + return; + } + + auto keyValues = ktx::KTX::parseKeyValues(header->bytesOfKeyValueData, reinterpret_cast(_ktxHeaderData.data()) + ktx::KTX_HEADER_SIZE); + + auto imageDescriptors = header->generateImageDescriptors(); + _originalKtxDescriptor.reset(new ktx::KTXDescriptor(*header, keyValues, imageDescriptors)); + + // Create bare ktx in memory + auto found = std::find_if(keyValues.begin(), keyValues.end(), [](const ktx::KeyValue& val) -> bool { + return val._key.compare(gpu::SOURCE_HASH_KEY) == 0; + }); + std::string filename; + if (found == keyValues.end()) { + qWarning("Source hash key not found, bailing"); + filename = "test"; + //return; + + } + else { + if (found->_value.size() < 16) { + filename = _activeUrl.fileName().toStdString(); + } + else { + filename = std::string(reinterpret_cast(found->_value.data()), 32); + } + } + + auto memKtx = ktx::KTX::createBare(*header, keyValues); + + auto d = const_cast(memKtx->getStorage()->data()); + ///memcpy(d + memKtx->_storage->size() - _ktxHighMipData.size(), _ktxHighMipData.data(), _ktxHighMipData.size()); + + auto textureCache = DependencyManager::get(); + + // Move ktx to file + const char* data = reinterpret_cast(memKtx->_storage->data()); + size_t length = memKtx->_storage->size(); + KTXFilePointer file; + auto& ktxCache = textureCache->_ktxCache; + if (!memKtx || !(file = ktxCache.writeFile(data, KTXCache::Metadata(filename, length)))) { + qCWarning(modelnetworking) << _url << "file cache failed"; + return; + } + else { + _file = file; + } + + //_ktxDescriptor.reset(new ktx::KTXDescriptor(memKtx->toDescriptor())); + auto newKtxDescriptor = memKtx->toDescriptor(); + + //auto texture = gpu::Texture::serializeHeader("test.ktx", *header, keyValues); + gpu::TexturePointer texture; + texture.reset(gpu::Texture::unserialize(_file->getFilepath(), newKtxDescriptor)); + texture->setKtxBacking(file->getFilepath()); + texture->setSource(filename); + texture->registerMipInterestListener(this); + + auto& images = _originalKtxDescriptor->images; + size_t imageSizeRemaining = _ktxHighMipData.size(); + uint8_t* ktxData = reinterpret_cast(_ktxHighMipData.data()); + ktxData += _ktxHighMipData.size(); + // TODO Move image offset calculation to ktx ImageDescriptor + int level; + for (level = images.size() - 1; level >= 0; --level) { + auto& image = images[level]; + if (image._imageSize > imageSizeRemaining) { + break; + } + qDebug() << "Transferring " << level; + ktxData -= image._imageSize; + texture->assignStoredMip(level, image._imageSize, ktxData); + ktxData -= 4; + imageSizeRemaining - image._imageSize - 4; + } + + // We replace the texture with the one stored in the cache. This deals with the possible race condition of two different + // images with the same hash being loaded concurrently. Only one of them will make it into the cache by hash first and will + // be the winner + if (textureCache) { + texture = textureCache->cacheTextureByHash(filename, texture); + } + + + _lowestKnownPopulatedMip = _originalKtxDescriptor->header.numberOfMipmapLevels; + for (uint16_t l = 0; l < 200; l++) { + if (texture->isStoredMipFaceAvailable(l)) { + _lowestKnownPopulatedMip = l; + break; + } + } + ResourceCache::requestCompleted(_self); + + setImage(texture, header->getPixelWidth(), header->getPixelHeight()); - qDebug() << "Identifier:" << QString(QByteArray((char*)header->identifier, 12)); - qDebug() << "Type:" << header->glType; - qDebug() << "TypeSize:" << header->glTypeSize; - qDebug() << "numberOfArrayElements:" << header->numberOfArrayElements; - qDebug() << "numberOfFaces:" << header->numberOfFaces; - qDebug() << "numberOfMipmapLevels:" << header->numberOfMipmapLevels; - auto kvSize = header->bytesOfKeyValueData; - if (kvSize > _ktxHeaderData.size() - ktx::KTX_HEADER_SIZE) { - qWarning() << "Cannot load " << _url << ", did not receive all kv data with initial request"; return; - } - auto keyValues = ktx::KTX::parseKeyValues(header->bytesOfKeyValueData, reinterpret_cast(_ktxHeaderData.data()) + ktx::KTX_HEADER_SIZE); - - auto imageDescriptors = header->generateImageDescriptors(); - _originalKtxDescriptor.reset(new ktx::KTXDescriptor(*header, keyValues, imageDescriptors)); - - // Create bare ktx in memory - std::string filename = "test"; - auto memKtx = ktx::KTX::createBare(*header, keyValues); - - auto d = const_cast(memKtx->getStorage()->data()); - ///memcpy(d + memKtx->_storage->size() - _ktxHighMipData.size(), _ktxHighMipData.data(), _ktxHighMipData.size()); - - auto textureCache = DependencyManager::get(); - - // Move ktx to file - const char* data = reinterpret_cast(memKtx->_storage->data()); - size_t length = memKtx->_storage->size(); - KTXFilePointer file; - auto& ktxCache = textureCache->_ktxCache; - if (!memKtx || !(file = ktxCache.writeFile(data, KTXCache::Metadata(filename, length)))) { - qCWarning(modelnetworking) << _url << "file cache failed"; - } else { - _file = file; - } - - //_ktxDescriptor.reset(new ktx::KTXDescriptor(memKtx->toDescriptor())); - auto newKtxDescriptor = memKtx->toDescriptor(); - - //auto texture = gpu::Texture::serializeHeader("test.ktx", *header, keyValues); - gpu::TexturePointer texture; - texture.reset(gpu::Texture::unserialize(_file->getFilepath(), newKtxDescriptor)); - texture->setKtxBacking(file->getFilepath()); - texture->setSource(filename); - texture->registerMipInterestListener(this); - - auto& images = _originalKtxDescriptor->images; - size_t imageSizeRemaining = _ktxHighMipData.size(); - uint8_t* ktxData = reinterpret_cast(_ktxHighMipData.data()); - ktxData += _ktxHighMipData.size(); - // TODO Move image offset calculation to ktx ImageDescriptor - uint16_t level; - for (level = images.size() - 1; level >= 0; --level) { - auto& image = images[level]; - if (image._imageSize > imageSizeRemaining) { - break; + /* + // Force load the next two levels + { + QTimer* timer = new QTimer(); + connect(timer, &QTimer::timeout, this, [=]() { + //startMipRangeRequest(level, level); + startRequestForNextMipLevel(); + }); + timer->setSingleShot(true); + timer->setInterval(4000); + timer->start(); } - qDebug() << "Transferring " << level; - ktxData -= image._imageSize; - texture->assignStoredMip(level, image._imageSize, ktxData); - ktxData -= 4; - imageSizeRemaining - image._imageSize - 4; - } - _initialKtxLoaded = true; - - // We replace the texture with the one stored in the cache. This deals with the possible race condition of two different - // images with the same hash being loaded concurrently. Only one of them will make it into the cache by hash first and will - // be the winner - if (textureCache) { - texture = textureCache->cacheTextureByHash(filename, texture); - } - - - _lowestKnownPopulatedMip = _originalKtxDescriptor->header.numberOfMipmapLevels; - for (uint16_t l = 0; l < 200; l++) { - if (texture->isStoredMipFaceAvailable(l)) { - _lowestKnownPopulatedMip = l; - break; + { + QTimer* timer = new QTimer(); + connect(timer, &QTimer::timeout, this, [=]() { + //startMipRangeRequest(level - 1, level - 1); + startRequestForNextMipLevel(); + }); + timer->setSingleShot(true); + timer->setInterval(6000); + timer->start(); } - } - - setImage(texture, header->getPixelWidth(), header->getPixelHeight()); - - return; - - // Force load the next two levels - { - QTimer* timer = new QTimer(); - connect(timer, &QTimer::timeout, this, [=]() { - //startMipRangeRequest(level, level); - startRequestForNextMipLevel(); - }); - timer->setSingleShot(true); - timer->setInterval(4000); - timer->start(); - } - - { - QTimer* timer = new QTimer(); - connect(timer, &QTimer::timeout, this, [=]() { - //startMipRangeRequest(level - 1, level - 1); - startRequestForNextMipLevel(); - }); - timer->setSingleShot(true); - timer->setInterval(6000); - timer->start(); + */ } } } diff --git a/libraries/model-networking/src/model-networking/TextureCache.h b/libraries/model-networking/src/model-networking/TextureCache.h index 50c8ecf352..30eb9d2d2e 100644 --- a/libraries/model-networking/src/model-networking/TextureCache.h +++ b/libraries/model-networking/src/model-networking/TextureCache.h @@ -46,6 +46,7 @@ class NetworkTexture : public Resource, public Texture, public gpu::Texture::Mip public: NetworkTexture(const QUrl& url, image::TextureUsage::Type type, const QByteArray& content, int maxNumPixels); + NetworkTexture::~NetworkTexture() override; QString getType() const override { return "NetworkTexture"; } @@ -91,13 +92,6 @@ private: image::TextureUsage::Type _type; - enum KTXLoadState { - LOADING_HEADER, - LOADING_LOWEST_SIX, - DONE_LOADING - }; - - bool _initialKtxLoaded { false }; KTXFilePointer _file; static const uint16_t NULL_MIP_LEVEL; bool _sourceIsKTX { false }; @@ -105,6 +99,8 @@ private: std::pair _ktxMipLevelRangeInFlight{ NULL_MIP_LEVEL, NULL_MIP_LEVEL }; ResourceRequest* _ktxHeaderRequest { nullptr }; ResourceRequest* _ktxMipRequest { nullptr }; + bool _headerRequestFinished{ false }; + bool _highMipRequestFinished{ false }; uint16_t _lowestRequestedMipLevel { NULL_MIP_LEVEL }; uint16_t _lowestKnownPopulatedMip { NULL_MIP_LEVEL }; QByteArray _ktxHeaderData; diff --git a/libraries/shared/src/shared/Storage.cpp b/libraries/shared/src/shared/Storage.cpp index 0f2b696a66..6eb311fa60 100644 --- a/libraries/shared/src/shared/Storage.cpp +++ b/libraries/shared/src/shared/Storage.cpp @@ -70,7 +70,7 @@ StoragePointer FileStorage::create(const QString& filename, size_t size, const u // Represents a memory mapped file FileStorage::FileStorage(const QString& filename) : _file(filename) { if (_file.open(QFile::ReadWrite)) { - qDebug() << ">>> Opening mmapped file: " << filename; + //qDebug() << ">>> Opening mmapped file: " << filename; _mapped = _file.map(0, _file.size()); if (_mapped) { _valid = true; @@ -83,7 +83,7 @@ FileStorage::FileStorage(const QString& filename) : _file(filename) { } FileStorage::~FileStorage() { - qDebug() << ">>> Closing mmapped file: " << _file.fileName(); + //qDebug() << ">>> Closing mmapped file: " << _file.fileName(); if (_mapped) { if (!_file.unmap(_mapped)) { throw std::runtime_error("Unable to unmap file");