[URP] Port HDRP Mip Bias Logic to URP (#6229)

* Port HDRP Mip Bias Logic to URP

This change integrates the mip bias logic from HDRP into URP. This logic
ensures that shaders select their mips based on the final screen
resolution rather than the current render resolution. In cases where
aggressive upscaling is taking place, this can significantly improve
texture detail in the final image.

* Combined Mip Bias Constants Into Vector

This change combines the mip bias shader constants into a single vector
rather than having two separate scalar values. This may improve
performance on older mobile devices and shouldn't hurt performance on
modern ones.

Author: gmitrano-unity

com.unity.render-pipelines.universal/Runtime/ScriptableRenderer.cs

@@ -217,6 +217,11 @@ void SetPerCameraShaderVariables(CommandBuffer cmd, ref CameraData cameraData)
 
             cmd.SetGlobalVector(ShaderPropertyId.screenSize, new Vector4(cameraWidth, cameraHeight, 1.0f / cameraWidth, 1.0f / cameraHeight));
 
+            // Calculate a bias value which corrects the mip lod selection logic when image scaling is active.
+            // We clamp this value to 0.0 or less to make sure we don't end up reducing image detail in the downsampling case.
+            float mipBias = Math.Min((float)-Math.Log(cameraWidth / scaledCameraWidth, 2.0f), 0.0f);
+            cmd.SetGlobalVector(ShaderPropertyId.globalMipBias, new Vector2(mipBias, Mathf.Pow(2.0f, mipBias)));
+
             //Set per camera matrices.
             SetCameraMatrices(cmd, ref cameraData, true);
         }

com.unity.render-pipelines.universal/Runtime/UniversalRenderPipelineCore.cs

@@ -339,6 +339,7 @@ internal static class ShaderPropertyId
         public static readonly int projectionParams = Shader.PropertyToID("_ProjectionParams");
         public static readonly int zBufferParams = Shader.PropertyToID("_ZBufferParams");
         public static readonly int orthoParams = Shader.PropertyToID("unity_OrthoParams");
+        public static readonly int globalMipBias = Shader.PropertyToID("_GlobalMipBias");
 
         public static readonly int screenSize = Shader.PropertyToID("_ScreenSize");
 

com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl

@@ -103,6 +103,77 @@
     #define GATHER_BLUE_TEXTURE2D_X(textureName, samplerName, coord2)       GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)
 #endif
 
+///
+/// Texture Sampling Macro Overrides for Scaling
+///
+/// When mip bias is supported by the underlying platform, the following section redefines all 2d texturing operations to support a global mip bias feature.
+/// This feature is used to improve rendering quality when image scaling is active. It achieves this by adding a bias value to the standard mip lod calculation
+/// which allows us to select the mip level based on the final image resolution rather than the current rendering resolution.
+
+#ifdef PLATFORM_SAMPLE_TEXTURE2D_BIAS
+    #ifdef  SAMPLE_TEXTURE2D
+        #undef  SAMPLE_TEXTURE2D
+        #define SAMPLE_TEXTURE2D(textureName, samplerName, coord2) \
+            PLATFORM_SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2,  _GlobalMipBias.x)
+    #endif
+    #ifdef  SAMPLE_TEXTURE2D_BIAS
+        #undef  SAMPLE_TEXTURE2D_BIAS
+        #define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias) \
+            PLATFORM_SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2,  (bias + _GlobalMipBias.x))
+    #endif
+#endif
+
+#ifdef PLATFORM_SAMPLE_TEXTURE2D_GRAD
+    #ifdef  SAMPLE_TEXTURE2D_GRAD
+        #undef  SAMPLE_TEXTURE2D_GRAD
+        #define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy) \
+            PLATFORM_SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, (dpdx * _GlobalMipBias.y), (dpdy * _GlobalMipBias.y))
+    #endif
+#endif
+
+#ifdef PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS
+    #ifdef  SAMPLE_TEXTURE2D_ARRAY
+        #undef  SAMPLE_TEXTURE2D_ARRAY
+        #define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) \
+            PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, _GlobalMipBias.x)
+    #endif
+    #ifdef  SAMPLE_TEXTURE2D_ARRAY_BIAS
+        #undef  SAMPLE_TEXTURE2D_ARRAY_BIAS
+        #define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias) \
+            PLATFORM_SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, (bias + _GlobalMipBias.x))
+    #endif
+#endif
+
+#ifdef PLATFORM_SAMPLE_TEXTURECUBE_BIAS
+    #ifdef  SAMPLE_TEXTURECUBE
+        #undef  SAMPLE_TEXTURECUBE
+        #define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3) \
+            PLATFORM_SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, _GlobalMipBias.x)
+    #endif
+    #ifdef  SAMPLE_TEXTURECUBE_BIAS
+        #undef  SAMPLE_TEXTURECUBE_BIAS
+        #define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias) \
+            PLATFORM_SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, (bias + _GlobalMipBias.x))
+    #endif
+#endif
+
+#ifdef PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS
+
+    #ifdef  SAMPLE_TEXTURECUBE_ARRAY
+        #undef  SAMPLE_TEXTURECUBE_ARRAY
+        #define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)\
+            PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, _GlobalMipBias.x)
+    #endif
+
+    #ifdef  SAMPLE_TEXTURECUBE_ARRAY_BIAS
+        #undef  SAMPLE_TEXTURECUBE_ARRAY_BIAS
+        #define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)\
+            PLATFORM_SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, (bias + _GlobalMipBias.x))
+    #endif
+#endif
+
+#define VT_GLOBAL_MIP_BIAS_MULTIPLIER (_GlobalMipBias.y)
+
 // Structs
 struct VertexPositionInputs
 {

com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl

@@ -59,6 +59,10 @@ float4 _ProjectionParams;
 // w = 1 + 1.0/height
 float4 _ScreenParams;
 
+// x = Mip Bias
+// y = 2.0 ^ [Mip Bias]
+float2 _GlobalMipBias;
+
 // Values used to linearize the Z buffer (http://www.humus.name/temp/Linearize%20depth.txt)
 // x = 1-far/near
 // y = far/near