cleaning up macos warnings, separating Metallic maps from the default, gamma corrected gray textures

examples/utilities/tools/render/framebuffer.qml

@@ -31,8 +31,7 @@ Column {
                 "Albedo",
                 "Normal",
                 "Roughness",
-                "Metallic",              
+                "Metallic",     
-                "Fresnel",
                 "Emissive",
                 "Occlusion",
                 "Lightmap",

interface/src/Application.cpp

@@ -3818,18 +3818,10 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         });
     }
 
-    // Setup the current Zone Entity lighting and skybox
+    // Setup the current Zone Entity lighting
     {
-        // FIXME: Use a zone setting to determine the ambient light mode
+        auto stage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
-        DependencyManager::get<DeferredLightingEffect>()->setAmbientLightMode(-1);
+        DependencyManager::get<DeferredLightingEffect>()->setGlobalLight(stage->getSunLight(), stage->getSkybox()->getCubemap());
-        auto skyStage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
-        DependencyManager::get<DeferredLightingEffect>()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity(), skyStage->getSunLight()->getAmbientIntensity());
-
-        auto skybox = model::SkyboxPointer();
-        if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) {
-            skybox = skyStage->getSkybox();
-        }
-        DependencyManager::get<DeferredLightingEffect>()->setGlobalSkybox(skybox);
     }
 
     {

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -140,7 +140,8 @@ void EntityTreeRenderer::update() {
         // even if we haven't changed positions, if we previously attempted to set the skybox, but
         // have a pending download of the skybox texture, then we should attempt to reapply to 
         // get the correct texture.
-        if (_pendingSkyboxTexture && _skyboxTexture && _skyboxTexture->isLoaded()) {
+        if ((_pendingSkyboxTexture && _skyboxTexture && _skyboxTexture->isLoaded()) ||
+            (_pendingAmbientTexture && _ambientTexture && _ambientTexture->isLoaded())) {
             applyZonePropertiesToScene(_bestZone);
         }
 
@@ -253,6 +254,7 @@ void EntityTreeRenderer::forceRecheckEntities() {
 
 
 void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityItem> zone) {
+    auto textureCache = DependencyManager::get<TextureCache>();
     auto scene = DependencyManager::get<SceneScriptingInterface>();
     auto sceneStage = scene->getStage();
     auto skyStage = scene->getSkyStage();
@@ -264,7 +266,11 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
         _pendingSkyboxTexture = false;
         _skyboxTexture.clear();
 
+        _pendingAmbientTexture = false;
+        _ambientTexture.clear();
+
         if (_hasPreviousZone) {
+            sceneKeyLight->resetAmbientSphere();
             sceneKeyLight->setColor(_previousKeyLightColor);
             sceneKeyLight->setIntensity(_previousKeyLightIntensity);
             sceneKeyLight->setAmbientIntensity(_previousKeyLightAmbientIntensity);
@@ -274,6 +280,7 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
                                     _previousStageAltitude);
             sceneTime->setHour(_previousStageHour);
             sceneTime->setDay(_previousStageDay);
+
             _hasPreviousZone = false;
         }
 
@@ -306,6 +313,23 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
     sceneTime->setHour(zone->getStageProperties().calculateHour());
     sceneTime->setDay(zone->getStageProperties().calculateDay());
 
+    bool isAmbientTextureSet = false;
+    if (zone->getKeyLightProperties().getAmbientURL().isEmpty()) {
+        _pendingAmbientTexture = false;
+        _ambientTexture.clear();
+    } else {
+        _ambientTexture = textureCache->getTexture(zone->getKeyLightProperties().getAmbientURL(), CUBE_TEXTURE);
+        if (_ambientTexture->getGPUTexture()) {
+            _pendingAmbientTexture = false;
+            if (_ambientTexture->getGPUTexture()->getIrradiance()) {
+                sceneKeyLight->setAmbientSphere(_ambientTexture->getGPUTexture()->getIrradiance());
+                isAmbientTextureSet = true;
+            }
+        } else {
+            _pendingAmbientTexture = true;
+        }
+    }
+
     switch (zone->getBackgroundMode()) {
         case BACKGROUND_MODE_SKYBOX: {
             auto skybox = std::dynamic_pointer_cast<ProceduralSkybox>(skyStage->getSkybox());
@@ -326,12 +350,16 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
                 _skyboxTexture.clear();
             } else {
                 // Update the Texture of the Skybox with the one pointed by this zone
-                auto textureCache = DependencyManager::get<TextureCache>();
                 _skyboxTexture = textureCache->getTexture(zone->getSkyboxProperties().getURL(), CUBE_TEXTURE);
 
                 if (_skyboxTexture->getGPUTexture()) {
-                    skybox->setCubemap(_skyboxTexture->getGPUTexture());
+                    auto texture = _skyboxTexture->getGPUTexture();
+                    skybox->setCubemap(texture);
                     _pendingSkyboxTexture = false;
+                    if (!isAmbientTextureSet && texture->getIrradiance()) {
+                        sceneKeyLight->setAmbientSphere(texture->getIrradiance());
+                        isAmbientTextureSet = true;
+                    }
                 } else {
                     _pendingSkyboxTexture = true;
                 }
@@ -348,6 +376,10 @@ void EntityTreeRenderer::applyZonePropertiesToScene(std::shared_ptr<ZoneEntityIt
             _skyboxTexture.clear();
             break;
     }
+
+    if (!isAmbientTextureSet) {
+        sceneKeyLight->resetAmbientSphere();
+    }
 }
 
 const FBXGeometry* EntityTreeRenderer::getGeometryForEntity(EntityItemPointer entityItem) {

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -146,6 +146,9 @@ private:
     bool _pendingSkyboxTexture { false };
     NetworkTexturePointer _skyboxTexture;
 
+    bool _pendingAmbientTexture { false };
+    NetworkTexturePointer _ambientTexture;
+
     bool _wantScripts;
     ScriptEngine* _entitiesScriptEngine;
 

libraries/entities/src/KeyLightPropertyGroup.cpp

@@ -30,7 +30,7 @@ void KeyLightPropertyGroup::copyToScriptValue(const EntityPropertyFlags& desired
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_INTENSITY, KeyLight, keyLight, Intensity, intensity);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_AMBIENT_INTENSITY, KeyLight, keyLight, AmbientIntensity, ambientIntensity);
     COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_DIRECTION, KeyLight, keyLight, Direction, direction);
-    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_AMBIENT_URL, KeyLight, keyLight, AmbientURL, ambientUrl);
+    COPY_GROUP_PROPERTY_TO_QSCRIPTVALUE(PROP_KEYLIGHT_AMBIENT_URL, KeyLight, keyLight, AmbientURL, ambientURL);
 
 }
 

libraries/fbx/src/FBXReader.h

@@ -131,11 +131,10 @@ class FBXMaterial {
 public:
     FBXMaterial() {};
     FBXMaterial(const glm::vec3& diffuseColor, const glm::vec3& specularColor, const glm::vec3& emissiveColor,
-        const glm::vec2& emissiveParams, float shininess, float opacity) :
+         float shininess, float opacity) :
         diffuseColor(diffuseColor),
         specularColor(specularColor),
         emissiveColor(emissiveColor),
-        lightmapParams(emissiveParams),
         shininess(shininess),
         opacity(opacity)  {}
 

libraries/fbx/src/FBXReader_Material.cpp

@@ -185,8 +185,6 @@ void FBXReader::consolidateFBXMaterials() {
         } else {
             material._material->setRoughness(model::Material::shininessToRoughness(material.shininess));
             float metallic = std::max(material.specularColor.x, std::max(material.specularColor.y, material.specularColor.z));
-            // FIXME: Do not use the Specular Factor yet as some FBX models have it set to 0
-            // metallic *= material.specularFactor;
             material._material->setMetallic(metallic);
         }
 

libraries/fbx/src/OBJReader.cpp

@@ -558,7 +558,6 @@ FBXGeometry* OBJReader::readOBJ(QByteArray& model, const QVariantHash& mapping,
         geometry.materials[materialID] = FBXMaterial(objMaterial.diffuseColor,
                                                      objMaterial.specularColor,
                                                      glm::vec3(0.0f),
-                                                     glm::vec2(0.0f, 1.0f),
                                                      objMaterial.shininess,
                                                      objMaterial.opacity);
         FBXMaterial& fbxMaterial = geometry.materials[materialID];

libraries/gpu/src/gpu/GLBackendTexture.cpp

@@ -145,6 +145,8 @@ public:
                 switch(dstFormat.getSemantic()) {
                 case gpu::RGB:
                 case gpu::RGBA:
+                case gpu::SRGB:
+                case gpu::SRGBA:
                     texel.internalFormat = GL_RED;
                     switch (dstFormat.getType()) {
                         case gpu::UINT32: {
@@ -196,7 +198,11 @@ public:
                             break;
                             }
                         case gpu::NUINT8: {
-                            texel.internalFormat = GL_R8;
+                            if ((dstFormat.getSemantic() == gpu::SRGB || dstFormat.getSemantic() == gpu::SRGBA)) {
+                                texel.internalFormat = GL_SLUMINANCE8;
+                            } else {
+                                texel.internalFormat = GL_R8;
+                            }
                             break;
                             }
                         case gpu::NINT8: {
@@ -209,6 +215,7 @@ public:
                         
                     }
                     break;
+
                 case gpu::DEPTH:
                     texel.format = GL_DEPTH_COMPONENT; // It's depth component to load it
                     texel.internalFormat = GL_DEPTH_COMPONENT;

libraries/model-networking/src/model-networking/ModelCache.cpp

@@ -363,7 +363,7 @@ static NetworkMaterial* buildNetworkMaterial(NetworkGeometry* geometry, const FB
         material._material->setTextureMap(model::MaterialKey::METALLIC_MAP, metallicMap);
     }
     if (!material.roughnessTexture.filename.isEmpty()) {
-        material.roughnessTexture.isGlossmap;
+        // FIXME: COnvert from gloss to roughness if material.roughnessTexture.isGlossmap;
         networkMaterial->roughnessTexture = textureCache->getTexture(textureBaseUrl.resolved(QUrl(material.roughnessTexture.filename)), ROUGHNESS_TEXTURE, material.roughnessTexture.content);
         networkMaterial->roughnessTextureName = material.roughnessTexture.name;
 

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

@@ -216,12 +216,15 @@ NetworkTexture::TextureLoaderFunc NetworkTexture::getTextureLoader() const {
             return TextureLoaderFunc(model::TextureUsage::createRoughnessTextureFromImage);
             break;
         }
+        case SPECULAR_TEXTURE: {
+            return TextureLoaderFunc(model::TextureUsage::createMetallicTextureFromImage);
+            break;
+        }
         case CUSTOM_TEXTURE: {
             return _textureLoader;
             break;
         }
         case DEFAULT_TEXTURE:
-        case SPECULAR_TEXTURE:
         case EMISSIVE_TEXTURE:
         default: {
             return TextureLoaderFunc(model::TextureUsage::create2DTextureFromImage);

libraries/model/src/model/Stage.cpp

@@ -202,14 +202,13 @@ void SunSkyStage::setSunModelEnable(bool isEnabled) {
     invalidate();
 }
 
-void SunSkyStage::setSunColor(const Vec3& color) {
+void SunSkyStage::setSunAmbientSphere(const gpu::SHPointer& sphere) {
-    _sunLight->setColor(color);
+    if (sphere) {
-}
+        _sunLight->setAmbientSphere(*sphere);
-void SunSkyStage::setSunIntensity(float intensity) {
+    } else {
-    _sunLight->setIntensity(intensity);
+        const gpu::SphericalHarmonics::Preset DEFAULT_AMBIENT_SPHERE = gpu::SphericalHarmonics::OLD_TOWN_SQUARE;
-}
+        _sunLight->setAmbientSpherePreset(DEFAULT_AMBIENT_SPHERE);
-void SunSkyStage::setSunAmbientIntensity(float intensity) {
+    }
-    _sunLight->setAmbientIntensity(intensity);
 }
 
 void SunSkyStage::setSunDirection(const Vec3& direction) {

libraries/model/src/model/Stage.h

@@ -11,7 +11,7 @@
 #ifndef hifi_model_Stage_h
 #define hifi_model_Stage_h
 
-#include "gpu/Pipeline.h"
+#include <gpu/Pipeline.h>
 
 #include "Light.h"
 #include "Skybox.h"
@@ -143,12 +143,13 @@ public:
     bool isSunModelEnabled() const { return _sunModelEnable; }
 
     // Sun properties
-    void setSunColor(const Vec3& color);
+    void setSunColor(const Vec3& color) { _sunLight->setColor(color); }
     const Vec3& getSunColor() const { return getSunLight()->getColor(); }
-    void setSunIntensity(float intensity);
+    void setSunIntensity(float intensity) { _sunLight->setIntensity(intensity); }
     float getSunIntensity() const { return getSunLight()->getIntensity(); }
-    void setSunAmbientIntensity(float intensity);
+    void setSunAmbientIntensity(float intensity) { _sunLight->setAmbientIntensity(intensity); }
     float getSunAmbientIntensity() const { return getSunLight()->getAmbientIntensity(); }
+    void setSunAmbientSphere(const gpu::SHPointer& sphere);
 
     // The sun direction is expressed in the world space
     void setSunDirection(const Vec3& direction);

libraries/model/src/model/TextureMap.cpp

@@ -264,27 +264,38 @@ gpu::Texture* TextureUsage::createRoughnessTextureFromImage(const QImage& srcIma
 
     image = image.convertToFormat(QImage::Format_Grayscale8);
 
- /*   gpu::Texture* theTexture = nullptr;
+    gpu::Texture* theTexture = nullptr;
     if ((image.width() > 0) && (image.height() > 0)) {
 
-    // Actual alpha channel?
+        gpu::Element formatGPU = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);
-    for (int y = 0; y < image.height(); ++y) {
+        gpu::Element formatMip = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);
-        QRgb* data = reinterpret_cast<QRgb*>(image.scanLine(y));
+
-        for (int x = 0; x < image.width(); ++x) {
+        theTexture = (gpu::Texture::create2D(formatGPU, image.width(), image.height(), gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR)));
-            data[x]auto alpha = q(data[x]);
+        theTexture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
-            if (alpha != 255) {
+        theTexture->autoGenerateMips(-1);
-                validAlpha = true;
+
-                break;
+        // FIXME queue for transfer to GPU and block on completion
-            }
+    }
+
+    return theTexture;
+}
+
+gpu::Texture* TextureUsage::createMetallicTextureFromImage(const QImage& srcImage, const std::string& srcImageName) {
+    QImage image = srcImage;
+    if (!image.hasAlphaChannel()) {
+        if (image.format() != QImage::Format_RGB888) {
+            image = image.convertToFormat(QImage::Format_RGB888);
+        }
+    } else {
+        if (image.format() != QImage::Format_ARGB32) {
+            image = image.convertToFormat(QImage::Format_ARGB32);
         }
     }
-    */
 
+    image = image.convertToFormat(QImage::Format_Grayscale8);
 
     gpu::Texture* theTexture = nullptr;
     if ((image.width() > 0) && (image.height() > 0)) {
-        // bool isLinearRGB = true; //(_type == NORMAL_TEXTURE) || (_type == EMISSIVE_TEXTURE);
-        bool isLinearRGB = false; //(_type == NORMAL_TEXTURE) || (_type == EMISSIVE_TEXTURE);
 
         gpu::Element formatGPU = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);
         gpu::Element formatMip = gpu::Element(gpu::SCALAR, gpu::NUINT8, gpu::RGB);

libraries/model/src/model/TextureMap.h

@@ -35,6 +35,7 @@ public:
     static gpu::Texture* createNormalTextureFromNormalImage(const QImage& image, const std::string& srcImageName);
     static gpu::Texture* createNormalTextureFromBumpImage(const QImage& image, const std::string& srcImageName);
     static gpu::Texture* createRoughnessTextureFromImage(const QImage& image, const std::string& srcImageName);
+    static gpu::Texture* createMetallicTextureFromImage(const QImage& image, const std::string& srcImageName);
     static gpu::Texture* createCubeTextureFromImage(const QImage& image, const std::string& srcImageName);
     static gpu::Texture* createLightmapTextureFromImage(const QImage& image, const std::string& srcImageName);
 

libraries/render-utils/src/DebugDeferredBuffer.cpp

@@ -60,29 +60,23 @@ static const std::string DEFAULT_ALBEDO_SHADER {
     " }"
 };
 
-static const std::string DEFAULT_FRESNEL_SHADER{
-    "vec4 getFragmentColor() {"
-    "    DeferredFragment frag = unpackDeferredFragmentNoPosition(uv);"
-    "    return vec4(pow(frag.specular, vec3(1.0 / 2.2)), 1.0);"
-    " }"
-};
-
 static const std::string DEFAULT_METALLIC_SHADER {
     "vec4 getFragmentColor() {"
     "    DeferredFragment frag = unpackDeferredFragmentNoPosition(uv);"
-    "    return vec4(vec3(frag.metallic), 1.0);"
+    "    return vec4(vec3(pow(frag.metallic, 1.0 / 2.2)), 1.0);"
     " }"
 };
+
 static const std::string DEFAULT_ROUGHNESS_SHADER {
     "vec4 getFragmentColor() {"
     "    DeferredFragment frag = unpackDeferredFragmentNoPosition(uv);"
-    "    return vec4(vec3(frag.roughness), 1.0);"
+    "    return vec4(vec3(pow(frag.roughness, 1.0 / 2.2)), 1.0);"
     " }"
 };
 static const std::string DEFAULT_NORMAL_SHADER {
     "vec4 getFragmentColor() {"
     "    DeferredFragment frag = unpackDeferredFragmentNoPosition(uv);"
-    "    return vec4(normalize(frag.normal), 1.0);"
+    "    return vec4(vec3(0.5) + (frag.normal * 0.5), 1.0);"
     " }"
 };
 
@@ -180,8 +174,6 @@ std::string DebugDeferredBuffer::getShaderSourceCode(Mode mode, std::string cust
     switch (mode) {
         case AlbedoMode:
             return DEFAULT_ALBEDO_SHADER;
-        case FresnelMode:
-            return DEFAULT_FRESNEL_SHADER;
         case MetallicMode:
             return DEFAULT_METALLIC_SHADER;
         case RoughnessMode:

libraries/render-utils/src/DebugDeferredBuffer.h

@@ -52,7 +52,6 @@ protected:
         NormalMode,
         RoughnessMode,
         MetallicMode,
-        FresnelMode,
         EmissiveMode,
         OcclusionMode,
         LightmapMode,

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -312,15 +312,13 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
 
             // First Global directional light and ambient pass
             {
-                bool useSkyboxCubemap = (_skybox) && (_skybox->getCubemap());
-
                 auto& program = _shadowMapEnabled ? _directionalLightShadow : _directionalLight;
                 LightLocationsPtr locations = _shadowMapEnabled ? _directionalLightShadowLocations : _directionalLightLocations;
 
                 // Setup the global directional pass pipeline
                 {
                     if (_shadowMapEnabled) {
-                        if (useSkyboxCubemap) {
+                        if (_skyboxTexture) {
                             program = _directionalSkyboxLightShadow;
                             locations = _directionalSkyboxLightShadowLocations;
                         } else if (_ambientLightMode > -1) {
@@ -328,7 +326,7 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
                             locations = _directionalAmbientSphereLightShadowLocations;
                         }
                     } else {
-                        if (useSkyboxCubemap) {
+                        if (_skyboxTexture) {
                             program = _directionalSkyboxLight;
                             locations = _directionalSkyboxLightLocations;
                         } else if (_ambientLightMode > -1) {
@@ -356,7 +354,7 @@ void DeferredLightingEffect::render(const render::RenderContextPointer& renderCo
                    geometryCache->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
                 }
 
-                if (useSkyboxCubemap) {
+                if (_skyboxTexture) {
                     batch.setResourceTexture(SKYBOX_MAP_UNIT, nullptr);
                 }
             }
@@ -501,9 +499,8 @@ void DeferredLightingEffect::setupKeyLightBatch(gpu::Batch& batch, int lightBuff
         batch.setUniformBuffer(lightBufferUnit, globalLight->getSchemaBuffer());
     }
 
-    bool useSkyboxCubemap = (_skybox) && (_skybox->getCubemap());
+    if (_skyboxTexture && (skyboxCubemapUnit >= 0)) {
-    if (useSkyboxCubemap && (skyboxCubemapUnit >= 0)) {
+        batch.setResourceTexture(skyboxCubemapUnit, _skyboxTexture);
-        batch.setResourceTexture(skyboxCubemapUnit, _skybox->getCubemap());
     }
 }
 
@@ -562,32 +559,9 @@ static void loadLightProgram(const char* vertSource, const char* fragSource, boo
 
 }
 
-void DeferredLightingEffect::setAmbientLightMode(int preset) {
+void DeferredLightingEffect::setGlobalLight(const model::LightPointer& light, const gpu::TexturePointer& skyboxTexture) {
-    if ((preset >= 0) && (preset < gpu::SphericalHarmonics::NUM_PRESET)) {
+    _allocatedLights.front() = light;
-        _ambientLightMode = preset;
+    _skyboxTexture = skyboxTexture;
-        auto light = _allocatedLights.front();
-        light->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset(preset % gpu::SphericalHarmonics::NUM_PRESET));
-    } else {
-        // force to preset 0
-        setAmbientLightMode(0);
-    }
-}
-
-void DeferredLightingEffect::setGlobalLight(const glm::vec3& direction, const glm::vec3& color, float intensity, float ambientIntensity) {
-    auto light = _allocatedLights.front();
-    light->setDirection(direction);
-    light->setColor(color);
-    light->setIntensity(intensity);
-    light->setAmbientIntensity(ambientIntensity);
-}
-
-void DeferredLightingEffect::setGlobalSkybox(const model::SkyboxPointer& skybox) {
-    _skybox = skybox;
-    auto light = _allocatedLights.front();
-
-    if (_skybox && _skybox->getCubemap() && _skybox->getCubemap()->isDefined() && _skybox->getCubemap()->getIrradiance()) {
-        light->setAmbientSphere( (*_skybox->getCubemap()->getIrradiance()) );
-    }
 }
 
 model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {

libraries/render-utils/src/DeferredLightingEffect.h

@@ -18,7 +18,6 @@
 #include <NumericalConstants.h>
 
 #include "model/Light.h"
-#include "model/Stage.h"
 #include "model/Geometry.h"
 
 #include "render/Context.h"
@@ -49,9 +48,7 @@ public:
     void setupKeyLightBatch(gpu::Batch& batch, int lightBufferUnit, int skyboxCubemapUnit);
 
     // update global lighting
-    void setAmbientLightMode(int preset);
+    void setGlobalLight(const model::LightPointer& light, const gpu::TexturePointer& skyboxTexture);
-    void setGlobalLight(const glm::vec3& direction, const glm::vec3& color, float intensity, float ambientIntensity);
-    void setGlobalSkybox(const model::SkyboxPointer& skybox);
 
     const LightStage& getLightStage() { return _lightStage; }
     void setShadowMapEnabled(bool enable) { _shadowMapEnabled = enable; };
@@ -99,7 +96,7 @@ private:
     std::vector<int> _spotLights;
 
     int _ambientLightMode = 0;
-    model::SkyboxPointer _skybox;
+    gpu::TexturePointer _skyboxTexture;
 
     // Class describing the uniform buffer with all the parameters common to the deferred shaders
     class DeferredTransform {

libraries/render-utils/src/MaterialTextures.slh

@@ -23,7 +23,7 @@ vec4 fetchAlbedoMap(vec2 uv) {
 <@if withRoughness@>
 uniform sampler2D roughnessMap;
 float fetchRoughnessMap(vec2 uv) {
-    return texture(roughnessMap, uv).r;
+    return pow(texture(roughnessMap, uv).r, 2.2);
 }
 <@endif@>
 
@@ -37,7 +37,7 @@ vec3 fetchNormalMap(vec2 uv) {
 <@if withMetallic@>
 uniform sampler2D specularMap;
 float fetchMetallicMap(vec2 uv) {
-    return texture(specularMap, uv).r;
+    return pow(texture(specularMap, uv).r, 2.2);
 }
 <@endif@>
 

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -77,6 +77,10 @@ void SceneScripting::KeyLight::setAmbientIntensity(float intensity) {
     _skyStage->setSunAmbientIntensity(intensity);
 }
 
+void SceneScripting::KeyLight::setAmbientSphere(const gpu::SHPointer& sphere) {
+    _skyStage->setSunAmbientSphere(sphere);
+}
+
 glm::vec3 SceneScripting::KeyLight::getDirection() const {
     return _skyStage->getSunDirection();
 }

libraries/script-engine/src/SceneScriptingInterface.h

@@ -81,6 +81,10 @@ namespace SceneScripting {
         // setDirection is only effective if stage Sun model is disabled
         void setDirection(const glm::vec3& direction);
 
+        // AmbientTexture is unscriptable - it must be set through the zone entity
+        void setAmbientSphere(const gpu::SHPointer& sphere);
+        void resetAmbientSphere() { setAmbientSphere(nullptr); }
+
     protected:
         model::SunSkyStagePointer _skyStage;
     };