Added new texture types : sky and ambient in place of just cube

libraries/baking/src/TextureBaker.cpp

@@ -206,7 +206,7 @@ void TextureBaker::processTexture() {
     }
 
     // Uncompressed KTX
-    if (_textureType == image::TextureUsage::Type::CUBE_TEXTURE) {
+    if (_textureType == image::TextureUsage::Type::SKY_TEXTURE || _textureType == image::TextureUsage::Type::AMBIENT_TEXTURE) {
         buffer->reset();
         auto processedTexture = image::processImage(std::move(buffer), _textureURL.toString().toStdString(), image::ColorChannel::NONE,
                                                     ABSOLUTE_MAX_TEXTURE_NUM_PIXELS, _textureType, false, gpu::BackendTarget::GL45, _abortProcessing);

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -465,7 +465,7 @@ void ZoneEntityRenderer::setAmbientURL(const QString& ambientUrl) {
     } else {
         _pendingAmbientTexture = true;
         auto textureCache = DependencyManager::get<TextureCache>();
-        _ambientTexture = textureCache->getTexture(_ambientTextureURL, image::TextureUsage::CUBE_TEXTURE);
+        _ambientTexture = textureCache->getTexture(_ambientTextureURL, image::TextureUsage::AMBIENT_TEXTURE);
 
         // keep whatever is assigned on the ambient map/sphere until texture is loaded
     }
@@ -506,7 +506,7 @@ void ZoneEntityRenderer::setSkyboxURL(const QString& skyboxUrl) {
     } else {
         _pendingSkyboxTexture = true;
         auto textureCache = DependencyManager::get<TextureCache>();
-        _skyboxTexture = textureCache->getTexture(_skyboxTextureURL, image::TextureUsage::CUBE_TEXTURE);
+        _skyboxTexture = textureCache->getTexture(_skyboxTextureURL, image::TextureUsage::SKY_TEXTURE);
     }
 }
 

libraries/image/src/image/Image.cpp

@@ -100,7 +100,9 @@ TextureUsage::TextureLoader TextureUsage::getTextureLoaderForType(Type type, con
             return image::TextureUsage::createEmissiveTextureFromImage;
         case LIGHTMAP_TEXTURE:
             return image::TextureUsage::createLightmapTextureFromImage;
-        case CUBE_TEXTURE:
+        case SKY_TEXTURE:
+            return image::TextureUsage::createCubeTextureFromImageWithoutIrradiance;
+        case AMBIENT_TEXTURE:
             if (options.value("generateIrradiance", true).toBool()) {
                 return image::TextureUsage::createCubeTextureFromImage;
             } else {

libraries/image/src/image/Image.h

@@ -41,7 +41,8 @@ enum Type {
     ROUGHNESS_TEXTURE,
     GLOSS_TEXTURE,
     EMISSIVE_TEXTURE,
-    CUBE_TEXTURE,
+    SKY_TEXTURE,
+    AMBIENT_TEXTURE,
     OCCLUSION_TEXTURE,
     SCATTERING_TEXTURE = OCCLUSION_TEXTURE,
     LIGHTMAP_TEXTURE,

libraries/material-networking/src/material-networking/TextureCache.cpp

@@ -224,10 +224,14 @@ NetworkTexturePointer TextureCache::getTexture(const QUrl& url, image::TextureUs
         return getResourceTexture(url);
     }
     auto modifiedUrl = url;
-    if (type == image::TextureUsage::CUBE_TEXTURE) {
+    if (type == image::TextureUsage::SKY_TEXTURE) {
         QUrlQuery query { url.query() };
         query.addQueryItem("skybox", "");
         modifiedUrl.setQuery(query.toString());
+    } else if (type == image::TextureUsage::AMBIENT_TEXTURE) {
+        QUrlQuery query{ url.query() };
+        query.addQueryItem("ambient", "");
+        modifiedUrl.setQuery(query.toString());
     }
     TextureExtra extra = { type, content, maxNumPixels, sourceChannel };
     return ResourceCache::getResource(modifiedUrl, QUrl(), &extra, std::hash<TextureExtra>()(extra)).staticCast<NetworkTexture>();
@@ -283,7 +287,8 @@ gpu::TexturePointer getFallbackTextureForType(image::TextureUsage::Type type) {
         case image::TextureUsage::BUMP_TEXTURE:
         case image::TextureUsage::SPECULAR_TEXTURE:
         case image::TextureUsage::GLOSS_TEXTURE:
-        case image::TextureUsage::CUBE_TEXTURE:
+        case image::TextureUsage::SKY_TEXTURE:
+        case image::TextureUsage::AMBIENT_TEXTURE:
         case image::TextureUsage::STRICT_TEXTURE:
         default:
             break;
@@ -408,7 +413,7 @@ void NetworkTexture::setExtra(void* extra) {
 
     _shouldFailOnRedirect = _currentlyLoadingResourceType != ResourceType::KTX;
 
-    if (_type == image::TextureUsage::CUBE_TEXTURE) {
+    if (_type == image::TextureUsage::SKY_TEXTURE) {
         setLoadPriority(this, SKYBOX_LOAD_PRIORITY);
     } else if (_currentlyLoadingResourceType == ResourceType::KTX) {
         setLoadPriority(this, HIGH_MIPS_LOAD_PRIORITY);

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -647,20 +647,34 @@ void RenderDeferred::run(const RenderContextPointer& renderContext, const Inputs
 void DefaultLightingSetup::run(const RenderContextPointer& renderContext) {
 
     if (!_defaultLight || !_defaultBackground) {
+        auto defaultSkyboxURL = PathUtils::resourcesUrl() + "images/Default-Sky-9-cubemap/Default-Sky-9-cubemap.texmeta.json";
+
         if (!_defaultSkyboxNetworkTexture) {
             PROFILE_RANGE(render, "Process Default Skybox");
             _defaultSkyboxNetworkTexture = DependencyManager::get<TextureCache>()->getTexture(
-                PathUtils::resourcesUrl() + "images/Default-Sky-9-cubemap/Default-Sky-9-cubemap.texmeta.json", image::TextureUsage::CUBE_TEXTURE);
+                defaultSkyboxURL, image::TextureUsage::SKY_TEXTURE);
+        }
+
+        if (!_defaultSkyboxAmbientTexture) {
+            PROFILE_RANGE(render, "Process Default Ambient map");
+            _defaultSkyboxAmbientTexture = DependencyManager::get<TextureCache>()->getTexture(
+                defaultSkyboxURL, image::TextureUsage::AMBIENT_TEXTURE);
         }
 
         if (_defaultSkyboxNetworkTexture && _defaultSkyboxNetworkTexture->isLoaded() && _defaultSkyboxNetworkTexture->getGPUTexture()) {
-            _defaultSkyboxAmbientTexture = _defaultSkyboxNetworkTexture->getGPUTexture();
             _defaultSkybox->setCubemap(_defaultSkyboxAmbientTexture);
         } else {
             // Don't do anything until the skybox has loaded
             return;
         }
 
+        if (_defaultSkyboxAmbientTexture && _defaultSkyboxAmbientTexture->isLoaded() && _defaultSkyboxAmbientTexture->getGPUTexture()) {
+            _defaultSkyboxAmbientTexture = _defaultSkyboxAmbientTexture->getGPUTexture();
+        } else {
+            // Don't do anything until the ambient box has been loaded
+            return;
+        }
+
         auto lightStage = renderContext->_scene->getStage<LightStage>();
         if (lightStage) { 
 

tools/oven/src/BakerCLI.cpp

@@ -82,8 +82,9 @@ void BakerCLI::bakeFile(QUrl inputUrl, const QString& outputPath, const QString&
                 { "roughness", image::TextureUsage::ROUGHNESS_TEXTURE },
                 { "gloss", image::TextureUsage::GLOSS_TEXTURE },
                 { "emissive", image::TextureUsage::EMISSIVE_TEXTURE },
-                { "cube", image::TextureUsage::CUBE_TEXTURE },
+                { "cube", image::TextureUsage::SKY_TEXTURE },
-                { "skybox", image::TextureUsage::CUBE_TEXTURE },
+                { "skybox", image::TextureUsage::SKY_TEXTURE },
+                { "ambient", image::TextureUsage::AMBIENT_TEXTURE },
                 { "occlusion", image::TextureUsage::OCCLUSION_TEXTURE },
                 { "scattering", image::TextureUsage::SCATTERING_TEXTURE },
                 { "lightmap", image::TextureUsage::LIGHTMAP_TEXTURE },

tools/oven/src/DomainBaker.cpp

@@ -390,13 +390,13 @@ void DomainBaker::enumerateEntities() {
             if (entity.contains(AMBIENT_LIGHT_KEY)) {
                 auto ambientLight = entity[AMBIENT_LIGHT_KEY].toObject();
                 if (ambientLight.contains(AMBIENT_URL_KEY)) {
-                    addTextureBaker(AMBIENT_LIGHT_KEY + "." + AMBIENT_URL_KEY, ambientLight[AMBIENT_URL_KEY].toString(), image::TextureUsage::CUBE_TEXTURE, *it);
+                    addTextureBaker(AMBIENT_LIGHT_KEY + "." + AMBIENT_URL_KEY, ambientLight[AMBIENT_URL_KEY].toString(), image::TextureUsage::AMBIENT_TEXTURE, *it);
                 }
             }
             if (entity.contains(SKYBOX_KEY)) {
                 auto skybox = entity[SKYBOX_KEY].toObject();
                 if (skybox.contains(SKYBOX_URL_KEY)) {
-                    addTextureBaker(SKYBOX_KEY + "." + SKYBOX_URL_KEY, skybox[SKYBOX_URL_KEY].toString(), image::TextureUsage::CUBE_TEXTURE, *it);
+                    addTextureBaker(SKYBOX_KEY + "." + SKYBOX_URL_KEY, skybox[SKYBOX_URL_KEY].toString(), image::TextureUsage::SKY_TEXTURE, *it);
                 }
             }
 

tools/oven/src/ui/SkyboxBakeWidget.cpp

@@ -181,7 +181,7 @@ void SkyboxBakeWidget::bakeButtonClicked() {
 
         // everything seems to be in place, kick off a bake for this skybox now
         auto baker = std::unique_ptr<TextureBaker> {
-            new TextureBaker(skyboxToBakeURL, image::TextureUsage::CUBE_TEXTURE, outputDirectory.absolutePath())
+            new TextureBaker(skyboxToBakeURL, image::TextureUsage::SKY_TEXTURE, outputDirectory.absolutePath())
         };
 
         // move the baker to a worker thread