Rename "NonLinear" to "SRGB".

src/common/utilities.h

@@ -235,7 +235,7 @@ enum class SrgbOverride
 {
     Default = 0,
     Linear,
-    NonLinear
+    SRGB
 };
 
 }  // namespace gl

src/libANGLE/Texture.cpp

@@ -892,8 +892,7 @@ GLenum Texture::getSRGBDecode() const
 void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride)
 {
     SrgbOverride oldOverride = mState.mSrgbOverride;
-    mState.mSrgbOverride =
-        (sRGBOverride == GL_SRGB) ? SrgbOverride::NonLinear : SrgbOverride::Default;
+    mState.mSrgbOverride = (sRGBOverride == GL_SRGB) ? SrgbOverride::SRGB : SrgbOverride::Default;
     if (mState.mSrgbOverride != oldOverride)
     {
         signalDirtyState(DIRTY_BIT_SRGB_OVERRIDE);
@@ -902,7 +901,7 @@ void Texture::setSRGBOverride(const Context *context, GLenum sRGBOverride)
 
 GLenum Texture::getSRGBOverride() const
 {
-    return (mState.mSrgbOverride == SrgbOverride::NonLinear) ? GL_SRGB : GL_NONE;
+    return (mState.mSrgbOverride == SrgbOverride::SRGB) ? GL_SRGB : GL_NONE;
 }
 
 const SamplerState &Texture::getSamplerState() const

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -2255,14 +2255,13 @@ bool TextureVk::shouldUseLinearColorspaceWithSampler(const SamplerVk *samplerVk)
         (mState.getSamplerState().getSRGBDecode() == GL_SKIP_DECODE_EXT);
 
     // True if GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT == GL_SRGB in the texture state
-    bool textureSRGBOverriddenToNonLinear =
-        (mState.getSRGBOverride() == gl::SrgbOverride::NonLinear);
+    bool textureSRGBOverriddenToSRGB = (mState.getSRGBOverride() == gl::SrgbOverride::SRGB);
 
     gl::SrgbOverride samplerDecodeOverride = gl::SrgbOverride::Default;
     if (samplerVk != nullptr)
     {
         samplerDecodeOverride = (samplerVk->skipSamplerSRGBDecode() ? gl::SrgbOverride::Linear
-                                                                    : gl::SrgbOverride::NonLinear);
+                                                                    : gl::SrgbOverride::SRGB);
     }
 
     switch (samplerDecodeOverride)
@@ -2271,11 +2270,11 @@ bool TextureVk::shouldUseLinearColorspaceWithSampler(const SamplerVk *samplerVk)
             // If the sampler state skips decoding, we must choose the linear imageview,
             // regardless of the texture state. This takes precedence over sRGB_override
             return true;
-        case gl::SrgbOverride::NonLinear:
+        case gl::SrgbOverride::SRGB:
             // If the sampler state does not skip decoding, we should choose the imageview
-            // required by sRGB_override- we should not force a linear format to use a nonlinear
+            // required by sRGB_override- we should not force a linear format to use a SRGB
             // imageview if sRGB_override has not forced that
-            if (textureSRGBOverriddenToNonLinear)
+            if (textureSRGBOverriddenToSRGB)
             {
                 return false;
             }
@@ -2292,7 +2291,7 @@ bool TextureVk::shouldUseLinearColorspaceWithSampler(const SamplerVk *samplerVk)
             {
                 return true;
             }
-            else if (textureSRGBOverriddenToNonLinear)
+            else if (textureSRGBOverriddenToSRGB)
             {
                 return false;
             }
@@ -2313,8 +2312,7 @@ bool TextureVk::shouldUseLinearColorspaceWithTexelFetch(bool colorspaceWithSampl
     ASSERT(mImage->valid());
 
     // True if GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT == GL_SRGB in the texture state
-    bool textureSRGBOverriddenToNonLinear =
-        (mState.getSRGBOverride() == gl::SrgbOverride::NonLinear);
+    bool textureSRGBOverriddenToSRGB = (mState.getSRGBOverride() == gl::SrgbOverride::SRGB);
 
     // Enable sRGB decoding regardless of skipSamplerSRGBDecode, due to an edge
     // case in the EXT_texture_sRGB_decode spec:
@@ -2330,7 +2328,7 @@ bool TextureVk::shouldUseLinearColorspaceWithTexelFetch(bool colorspaceWithSampl
     {
         // This imageview is used with a texelFetch invocation, so we must ignore all sRGB_decode
         // state. sRGB_override state should still be considered.
-        if (textureSRGBOverriddenToNonLinear)
+        if (textureSRGBOverriddenToSRGB)
         {
             return false;
         }
@@ -2367,8 +2365,8 @@ const vk::ImageView &TextureVk::getReadImageViewAndRecordUse(ContextVk *contextV
     }
     else
     {
-        ASSERT(imageViews.getNonLinearReadImageView().valid());
-        return imageViews.getNonLinearReadImageView();
+        ASSERT(imageViews.getSRGBReadImageView().valid());
+        return imageViews.getSRGBReadImageView();
     }
 }
 
@@ -2390,8 +2388,8 @@ const vk::ImageView &TextureVk::getFetchImageViewAndRecordUse(ContextVk *context
     }
     else
     {
-        return (imageViews.hasFetchImageView() ? imageViews.getNonLinearFetchImageView()
-                                               : imageViews.getNonLinearReadImageView());
+        return (imageViews.hasFetchImageView() ? imageViews.getSRGBFetchImageView()
+                                               : imageViews.getSRGBReadImageView());
     }
 }
 
@@ -2410,7 +2408,7 @@ const vk::ImageView &TextureVk::getCopyImageViewAndRecordUse(ContextVk *contextV
     }
     else
     {
-        return imageViews.getNonLinearCopyImageView();
+        return imageViews.getSRGBCopyImageView();
     }
 }
 

src/libANGLE/renderer/vulkan/vk_caps_utils.cpp

@@ -44,7 +44,7 @@ bool FormatReinterpretationSupported(const std::vector<GLenum> &optionalSizedFor
 
             VkFormat reinterpretedFormat = checkLinearColorspace
                                                ? vk::ConvertToLinear(vkFormat.vkImageFormat)
-                                               : vk::ConvertToNonLinear(vkFormat.vkImageFormat);
+                                               : vk::ConvertToSRGB(vkFormat.vkImageFormat);
             ASSERT(reinterpretedFormat != VK_FORMAT_UNDEFINED);
 
             constexpr uint32_t kBitsSampleFilter =
@@ -67,7 +67,7 @@ bool GetTextureSRGBDecodeSupport(const RendererVk *rendererVk)
     // GL_SRGB and GL_SRGB_ALPHA unsized formats are also required by the spec, but the only valid
     // type for them is GL_UNSIGNED_BYTE, so they are fully included in the sized formats listed
     // here
-    std::vector<GLenum> optionalSizedNonLinearFormats = {
+    std::vector<GLenum> optionalSizedSRGBFormats = {
         GL_SRGB8,
         GL_SRGB8_ALPHA8_EXT,
         GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
@@ -76,8 +76,7 @@ bool GetTextureSRGBDecodeSupport(const RendererVk *rendererVk)
         GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
     };
 
-    if (!FormatReinterpretationSupported(optionalSizedNonLinearFormats, rendererVk,
-                                         kLinearColorspace))
+    if (!FormatReinterpretationSupported(optionalSizedSRGBFormats, rendererVk, kLinearColorspace))
     {
         return false;
     }

src/libANGLE/renderer/vulkan/vk_format_utils.h

@@ -195,7 +195,7 @@ gl::SwizzleState ApplySwizzle(const gl::SwizzleState &formatSwizzle,
 namespace vk
 {
 
-ANGLE_INLINE VkFormat ConvertToNonLinear(VkFormat format)
+ANGLE_INLINE VkFormat ConvertToSRGB(VkFormat format)
 {
     switch (format)
     {
@@ -325,17 +325,17 @@ ANGLE_INLINE VkFormat ConvertToLinear(VkFormat format)
     }
 }
 
-ANGLE_INLINE bool IsNonLinearFormat(VkFormat format)
+ANGLE_INLINE bool IsSRGBFormat(VkFormat format)
 {
     return ConvertToLinear(format) != VK_FORMAT_UNDEFINED;
 }
 ANGLE_INLINE bool IsOverridableLinearFormat(VkFormat format)
 {
-    return ConvertToNonLinear(format) != VK_FORMAT_UNDEFINED;
+    return ConvertToSRGB(format) != VK_FORMAT_UNDEFINED;
 }
 ANGLE_INLINE bool IsLinearFormat(VkFormat format)
 {
-    return !IsNonLinearFormat(format);
+    return !IsSRGBFormat(format);
 }
 
 }  // namespace vk

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -5816,11 +5816,11 @@ ImageViewHelper::ImageViewHelper(ImageViewHelper &&other)
 {
     std::swap(mCurrentMaxLevel, other.mCurrentMaxLevel);
     std::swap(mPerLevelLinearReadImageViews, other.mPerLevelLinearReadImageViews);
-    std::swap(mPerLevelNonLinearReadImageViews, other.mPerLevelNonLinearReadImageViews);
+    std::swap(mPerLevelSRGBReadImageViews, other.mPerLevelSRGBReadImageViews);
     std::swap(mPerLevelLinearFetchImageViews, other.mPerLevelLinearFetchImageViews);
-    std::swap(mPerLevelNonLinearFetchImageViews, other.mPerLevelNonLinearFetchImageViews);
+    std::swap(mPerLevelSRGBFetchImageViews, other.mPerLevelSRGBFetchImageViews);
     std::swap(mPerLevelLinearCopyImageViews, other.mPerLevelLinearCopyImageViews);
-    std::swap(mPerLevelNonLinearCopyImageViews, other.mPerLevelNonLinearCopyImageViews);
+    std::swap(mPerLevelSRGBCopyImageViews, other.mPerLevelSRGBCopyImageViews);
     std::swap(mLinearColorspace, other.mLinearColorspace);
 
     std::swap(mPerLevelStencilReadImageViews, other.mPerLevelStencilReadImageViews);
@@ -5850,11 +5850,11 @@ void ImageViewHelper::release(RendererVk *renderer)
 
     // Release the read views
     ReleaseImageViews(&mPerLevelLinearReadImageViews, &garbage);
-    ReleaseImageViews(&mPerLevelNonLinearReadImageViews, &garbage);
+    ReleaseImageViews(&mPerLevelSRGBReadImageViews, &garbage);
     ReleaseImageViews(&mPerLevelLinearFetchImageViews, &garbage);
-    ReleaseImageViews(&mPerLevelNonLinearFetchImageViews, &garbage);
+    ReleaseImageViews(&mPerLevelSRGBFetchImageViews, &garbage);
     ReleaseImageViews(&mPerLevelLinearCopyImageViews, &garbage);
-    ReleaseImageViews(&mPerLevelNonLinearCopyImageViews, &garbage);
+    ReleaseImageViews(&mPerLevelSRGBCopyImageViews, &garbage);
     ReleaseImageViews(&mPerLevelStencilReadImageViews, &garbage);
 
     // Release the draw views
@@ -5889,11 +5889,11 @@ void ImageViewHelper::destroy(VkDevice device)
 
     // Release the read views
     DestroyImageViews(&mPerLevelLinearReadImageViews, device);
-    DestroyImageViews(&mPerLevelNonLinearReadImageViews, device);
+    DestroyImageViews(&mPerLevelSRGBReadImageViews, device);
     DestroyImageViews(&mPerLevelLinearFetchImageViews, device);
-    DestroyImageViews(&mPerLevelNonLinearFetchImageViews, device);
+    DestroyImageViews(&mPerLevelSRGBFetchImageViews, device);
     DestroyImageViews(&mPerLevelLinearCopyImageViews, device);
-    DestroyImageViews(&mPerLevelNonLinearCopyImageViews, device);
+    DestroyImageViews(&mPerLevelSRGBCopyImageViews, device);
     DestroyImageViews(&mPerLevelStencilReadImageViews, device);
 
     // Release the draw views
@@ -5927,11 +5927,11 @@ angle::Result ImageViewHelper::initReadViews(ContextVk *contextVk,
     if (levelCount > mPerLevelLinearReadImageViews.size())
     {
         mPerLevelLinearReadImageViews.resize(levelCount);
-        mPerLevelNonLinearReadImageViews.resize(levelCount);
+        mPerLevelSRGBReadImageViews.resize(levelCount);
         mPerLevelLinearFetchImageViews.resize(levelCount);
-        mPerLevelNonLinearFetchImageViews.resize(levelCount);
+        mPerLevelSRGBFetchImageViews.resize(levelCount);
         mPerLevelLinearCopyImageViews.resize(levelCount);
-        mPerLevelNonLinearCopyImageViews.resize(levelCount);
+        mPerLevelSRGBCopyImageViews.resize(levelCount);
         mPerLevelStencilReadImageViews.resize(levelCount);
     }
     mCurrentMaxLevel = LevelIndex(levelCount - 1);
@@ -6020,13 +6020,12 @@ angle::Result ImageViewHelper::initSRGBReadViewsImpl(ContextVk *contextVk,
                                                      uint32_t layerCount,
                                                      VkImageUsageFlags imageUsageFlags)
 {
-    // When we select the linear/nonlinear counterpart formats, we must first make sure they're
+    // When we select the linear/srgb counterpart formats, we must first make sure they're
     // actually supported by the ICD. If they are not supported by the ICD, then we treat that as if
     // there is no counterpart format. (In this case, the relevant extension should not be exposed)
-    VkFormat nonLinearOverrideFormat = ConvertToNonLinear(image.getFormat().vkImageFormat);
-    ASSERT(
-        (nonLinearOverrideFormat == VK_FORMAT_UNDEFINED) ||
-        (HasNonRenderableTextureFormatSupport(contextVk->getRenderer(), nonLinearOverrideFormat)));
+    VkFormat srgbOverrideFormat = ConvertToSRGB(image.getFormat().vkImageFormat);
+    ASSERT((srgbOverrideFormat == VK_FORMAT_UNDEFINED) ||
+           (HasNonRenderableTextureFormatSupport(contextVk->getRenderer(), srgbOverrideFormat)));
 
     VkFormat linearOverrideFormat = ConvertToLinear(image.getFormat().vkImageFormat);
     ASSERT((linearOverrideFormat == VK_FORMAT_UNDEFINED) ||
@@ -6045,13 +6044,13 @@ angle::Result ImageViewHelper::initSRGBReadViewsImpl(ContextVk *contextVk,
             &mPerLevelLinearReadImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
             baseLayer, layerCount, imageUsageFlags, linearFormat));
     }
-    if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
-        !mPerLevelNonLinearReadImageViews[mCurrentMaxLevel.get()].valid())
+    if (srgbOverrideFormat != VK_FORMAT_UNDEFINED &&
+        !mPerLevelSRGBReadImageViews[mCurrentMaxLevel.get()].valid())
     {
         ANGLE_TRY(image.initAliasedLayerImageView(
             contextVk, viewType, aspectFlags, readSwizzle,
-            &mPerLevelNonLinearReadImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
-            baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
+            &mPerLevelSRGBReadImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount, baseLayer,
+            layerCount, imageUsageFlags, srgbOverrideFormat));
     }
 
     gl::TextureType fetchType = viewType;
@@ -6069,13 +6068,13 @@ angle::Result ImageViewHelper::initSRGBReadViewsImpl(ContextVk *contextVk,
                 &mPerLevelLinearFetchImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
                 baseLayer, layerCount, imageUsageFlags, linearFormat));
         }
-        if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
-            !mPerLevelNonLinearFetchImageViews[mCurrentMaxLevel.get()].valid())
+        if (srgbOverrideFormat != VK_FORMAT_UNDEFINED &&
+            !mPerLevelSRGBFetchImageViews[mCurrentMaxLevel.get()].valid())
         {
             ANGLE_TRY(image.initAliasedLayerImageView(
                 contextVk, fetchType, aspectFlags, readSwizzle,
-                &mPerLevelNonLinearFetchImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
-                baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
+                &mPerLevelSRGBFetchImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
+                baseLayer, layerCount, imageUsageFlags, srgbOverrideFormat));
         }
     }
 
@@ -6086,13 +6085,13 @@ angle::Result ImageViewHelper::initSRGBReadViewsImpl(ContextVk *contextVk,
             &mPerLevelLinearCopyImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
             baseLayer, layerCount, imageUsageFlags, linearFormat));
     }
-    if (nonLinearOverrideFormat != VK_FORMAT_UNDEFINED &&
-        !mPerLevelNonLinearCopyImageViews[mCurrentMaxLevel.get()].valid())
+    if (srgbOverrideFormat != VK_FORMAT_UNDEFINED &&
+        !mPerLevelSRGBCopyImageViews[mCurrentMaxLevel.get()].valid())
     {
         ANGLE_TRY(image.initAliasedLayerImageView(
             contextVk, fetchType, aspectFlags, formatSwizzle,
-            &mPerLevelNonLinearCopyImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount,
-            baseLayer, layerCount, imageUsageFlags, nonLinearOverrideFormat));
+            &mPerLevelSRGBCopyImageViews[mCurrentMaxLevel.get()], baseLevel, levelCount, baseLayer,
+            layerCount, imageUsageFlags, srgbOverrideFormat));
     }
 
     return angle::Result::Continue;

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -1883,25 +1883,25 @@ class ImageViewHelper : angle::NonCopyable
     {
         return getValidReadViewImpl(mPerLevelLinearReadImageViews);
     }
-    const ImageView &getNonLinearReadImageView() const
+    const ImageView &getSRGBReadImageView() const
     {
-        return getValidReadViewImpl(mPerLevelNonLinearReadImageViews);
+        return getValidReadViewImpl(mPerLevelSRGBReadImageViews);
     }
     const ImageView &getLinearFetchImageView() const
     {
         return getValidReadViewImpl(mPerLevelLinearFetchImageViews);
     }
-    const ImageView &getNonLinearFetchImageView() const
+    const ImageView &getSRGBFetchImageView() const
     {
-        return getValidReadViewImpl(mPerLevelNonLinearFetchImageViews);
+        return getValidReadViewImpl(mPerLevelSRGBFetchImageViews);
     }
     const ImageView &getLinearCopyImageView() const
     {
         return getValidReadViewImpl(mPerLevelLinearCopyImageViews);
     }
-    const ImageView &getNonLinearCopyImageView() const
+    const ImageView &getSRGBCopyImageView() const
     {
-        return getValidReadViewImpl(mPerLevelNonLinearCopyImageViews);
+        return getValidReadViewImpl(mPerLevelSRGBCopyImageViews);
     }
     const ImageView &getStencilReadImageView() const
     {
@@ -1911,19 +1911,19 @@ class ImageViewHelper : angle::NonCopyable
     const ImageView &getReadImageView() const
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearReadImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearReadImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBReadImageViews);
     }
 
     const ImageView &getFetchImageView() const
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearFetchImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearFetchImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBFetchImageViews);
     }
 
     const ImageView &getCopyImageView() const
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearCopyImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearCopyImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBCopyImageViews);
     }
 
     // Used when initialized RenderTargets.
@@ -1937,8 +1937,7 @@ class ImageViewHelper : angle::NonCopyable
     bool hasFetchImageView() const
     {
         if ((mLinearColorspace && mCurrentMaxLevel.get() < mPerLevelLinearFetchImageViews.size()) ||
-            (!mLinearColorspace &&
-             mCurrentMaxLevel.get() < mPerLevelNonLinearFetchImageViews.size()))
+            (!mLinearColorspace && mCurrentMaxLevel.get() < mPerLevelSRGBFetchImageViews.size()))
         {
             return getFetchImageView().valid();
         }
@@ -1951,8 +1950,7 @@ class ImageViewHelper : angle::NonCopyable
     bool hasCopyImageView() const
     {
         if ((mLinearColorspace && mCurrentMaxLevel.get() < mPerLevelLinearCopyImageViews.size()) ||
-            (!mLinearColorspace &&
-             mCurrentMaxLevel.get() < mPerLevelNonLinearCopyImageViews.size()))
+            (!mLinearColorspace && mCurrentMaxLevel.get() < mPerLevelSRGBCopyImageViews.size()))
         {
             return getCopyImageView().valid();
         }
@@ -2008,17 +2006,17 @@ class ImageViewHelper : angle::NonCopyable
     ImageView &getReadImageView()
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearReadImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearReadImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBReadImageViews);
     }
     ImageView &getFetchImageView()
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearFetchImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearFetchImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBFetchImageViews);
     }
     ImageView &getCopyImageView()
     {
         return mLinearColorspace ? getReadViewImpl(mPerLevelLinearCopyImageViews)
-                                 : getReadViewImpl(mPerLevelNonLinearCopyImageViews);
+                                 : getReadViewImpl(mPerLevelSRGBCopyImageViews);
     }
 
     // Used by public get*ImageView() methods to do proper assert based on vector size and validity
@@ -2078,11 +2076,11 @@ class ImageViewHelper : angle::NonCopyable
 
     // Read views (one per max-level)
     ImageViewVector mPerLevelLinearReadImageViews;
-    ImageViewVector mPerLevelNonLinearReadImageViews;
+    ImageViewVector mPerLevelSRGBReadImageViews;
     ImageViewVector mPerLevelLinearFetchImageViews;
-    ImageViewVector mPerLevelNonLinearFetchImageViews;
+    ImageViewVector mPerLevelSRGBFetchImageViews;
     ImageViewVector mPerLevelLinearCopyImageViews;
-    ImageViewVector mPerLevelNonLinearCopyImageViews;
+    ImageViewVector mPerLevelSRGBCopyImageViews;
     ImageViewVector mPerLevelStencilReadImageViews;
 
     bool mLinearColorspace;