Lens flare cleanup and colorization (gazebosim#2927)

* Added color setting to LensFlare and LensFlareSensorPlugin.
Added methods to expose scale and color to derived plugins.
* Removed unused animated lens flare effect.
* Removed noise_rgba.png, which is no longer used.
* Changed a value in the lens flare shader back to its original 1.0.
This means there will be no compensation for the removal of the
legacy animation effect and the lens flares will look less intense.

gazebo/rendering/LensFlare.cc

@@ -35,8 +35,7 @@ namespace gazebo
   namespace rendering
   {
     /// \brief We'll create an instance of this class for each camera, to be
-    /// used to inject lens flare uniforms and time (for animating flare)
-    /// in each render call.
+    /// used to inject lens flare uniforms in each render call.
     class LensFlareCompositorListener
       : public Ogre::CompositorInstance::Listener
     {
@@ -71,6 +70,13 @@ namespace gazebo
         this->scale = _scale;
       }
 
+      /// \brief Set the color of lens flare.
+      /// \param[in] _color Color of lens flare
+      public: void SetColor(const ignition::math::Vector3d &_color)
+      {
+        this->color = _color;
+      }
+
       /// \brief Callback that OGRE will invoke for us on each render call
       /// \param[in] _passID OGRE material pass ID.
       /// \param[in] _mat Pointer to OGRE material.
@@ -96,9 +102,6 @@ namespace gazebo
             pass->getFragmentProgramParameters();
         GZ_ASSERT(!params.isNull(), "Null OGRE material GPU parameters");
 
-        // used for animating flare
-        params->setNamedConstant("time", static_cast<Ogre::Real>(
-            common::Time::GetWallTime().Double()));
         // for adjusting aspect ratio of flare
         params->setNamedConstant("viewport",
             Ogre::Vector3(static_cast<double>(this->camera->ViewportWidth()),
@@ -132,6 +135,8 @@ namespace gazebo
         params->setNamedConstant("lightPos", Conversions::Convert(pos));
         params->setNamedConstant("scale",
             static_cast<Ogre::Real>(lensFlareScale));
+        params->setNamedConstant("color",
+            Ogre::Vector3(this->color.X(), this->color.Y(), this->color.Z()));
       }
 
       /// \brief Get the lens flare position and scale for a normal camera
@@ -337,6 +342,10 @@ namespace gazebo
 
       /// \brief Scale of lens flare.
       private: double scale = 1.0;
+
+      /// \brief Color of lens flare.
+      private: ignition::math::Vector3d color
+          = ignition::math::Vector3d(1.0, 1.0, 1.0);
     };
 
     /// \brief Private data class for LensFlare
@@ -372,6 +381,10 @@ namespace gazebo
 
       /// \brief Scale of lens flare.
       public: double lensFlareScale = 1.0;
+
+      /// \brief Color of lens flare.
+      public: ignition::math::Vector3d lensFlareColor
+          = ignition::math::Vector3d(1.0, 1.0, 1.0);
     };
   }
 }
@@ -414,6 +427,8 @@ void LensFlare::SetCamera(CameraPtr _camera)
           LensFlareCompositorListener(this->dataPtr->camera, nullptr));
     this->dataPtr->lensFlareCompositorListener->SetScale(
         this->dataPtr->lensFlareScale);
+    this->dataPtr->lensFlareCompositorListener->SetColor(
+        this->dataPtr->lensFlareColor);
 
     this->dataPtr->lensFlareInstance =
         Ogre::CompositorManager::getSingleton().addCompositor(
@@ -441,6 +456,19 @@ void LensFlare::SetScale(const double _scale)
   }
 }
 
+//////////////////////////////////////////////////
+void LensFlare::SetColor(const ignition::math::Vector3d &_color)
+{
+  // lensFlareColor is intentionally not clamped so the user can work in
+  // HDR color spaces or be artistic.
+  this->dataPtr->lensFlareColor = _color;
+  if (this->dataPtr->lensFlareCompositorListener)
+  {
+    this->dataPtr->lensFlareCompositorListener->SetColor(
+        this->dataPtr->lensFlareColor);
+  }
+}
+
 //////////////////////////////////////////////////
 void LensFlare::Update()
 {

gazebo/rendering/LensFlare.hh

@@ -58,6 +58,10 @@ namespace gazebo
       /// \param[in] _scale Scale of lens flare
       public: void SetScale(const double _scale);
 
+      /// \brief Set the color of lens flare.
+      /// \param[in] _color Color of lens flare
+      public: void SetColor(const ignition::math::Vector3d &_color);
+
       /// \brief Update function to search light source
       private: void Update();
 

media/materials/programs/camera_lens_flare_fs.glsl

@@ -1,8 +1,6 @@
 // The input texture, which is set up by the Ogre Compositor infrastructure.
 uniform sampler2D RT;
-uniform sampler2D noiseRGBA;
 
-uniform float time;
 uniform vec3 viewport;
 
 // light pos in clip space
@@ -11,16 +9,8 @@ uniform vec3 lightPos;
 // lens flare scale
 uniform float scale;
 
-float noise(float t)
-{
-  // 256 is the size of noiseRGBA texture
-  return texture2D(noiseRGBA, vec2(t, 0.0) / vec2(256.0)).x;
-}
-
-float noise(vec2 t)
-{
-  return texture2D(noiseRGBA,(t + vec2(time)) / vec2(256.0)).x;
-}
+// lens flare color
+uniform vec3 color;
 
 vec3 lensflare(vec2 uv,vec2 pos)
 {
@@ -30,12 +20,9 @@ vec3 lensflare(vec2 uv,vec2 pos)
 
   float ang = atan(main.y, main.x);
   float dist = length(main); dist = pow(dist,.1);
-  float n = noise(vec2((ang-time/9.0)*16.0,dist*32.0));
 
   float f0 = 1.0/(length(uv-pos)*16.0/scale+1.0);
 
-  f0 = f0+f0*(sin((ang+time/18.0 + noise(abs(ang)+n/2.0)*2.0)*12.0)*.1+dist*.1+.8);
-
   float f2 = max(1.0/(1.0+32.0*pow(length(uvd+0.8*pos),2.0)),.0)*00.25;
   float f22 = max(1.0/(1.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*00.23;
   float f23 = max(1.0/(1.0+32.0*pow(length(uvd+0.9*pos),2.0)),.0)*00.21;
@@ -67,13 +54,6 @@ vec3 lensflare(vec2 uv,vec2 pos)
   return c;
 }
 
-// color modifier
-vec3 cc(vec3 color, float factor, float factor2)
-{
-  float w = color.x+color.y+color.z;
-  return mix(color,vec3(w)*factor,w*factor2);
-}
-
 void main()
 {
   // return if light is behind the view
@@ -97,9 +77,8 @@ void main()
   pos.x *= aspect;
 
   // compute lens flare
-  vec3 color = vec3(1.4,1.2,1.0)*lensflare(uv, pos.xy);
-  color = cc(color,.5,.1);
+  vec3 finalColor = color * lensflare(uv, pos.xy);
 
   // apply lens flare
-  gl_FragColor = texture2D(RT, gl_TexCoord[0].xy) + vec4(color, 1.0);
+  gl_FragColor = texture2D(RT, gl_TexCoord[0].xy) + vec4(finalColor, 1.0);
 }

media/materials/scripts/gazebo.material

@@ -1545,23 +1545,22 @@ material Gazebo/WideLensMap
 }
 
 
-vertex_program Gazebo/CameraLesnFlareVS glsl
+vertex_program Gazebo/CameraLensFlareVS glsl
 {
   source camera_lens_flare_vs.glsl
 }
 
-fragment_program Gazebo/CameraLesnFlareFS glsl
+fragment_program Gazebo/CameraLensFlareFS glsl
 {
   source camera_lens_flare_fs.glsl
 
   default_params
   {
     param_named RT int 0
-    param_named noiseRGBA int 1
-    param_named time float 0.0
     param_named viewport float3 0.0 0.0 0.0
     param_named lightPos float3 0 0 0
     param_named scale float 1.0
+    param_named color float3 1.4 1.2 1.0
   }
 }
 
@@ -1571,19 +1570,15 @@ material Gazebo/CameraLensFlare
   {
     pass
     {
-      vertex_program_ref Gazebo/CameraLesnFlareVS { }
-      fragment_program_ref Gazebo/CameraLesnFlareFS { }
+      vertex_program_ref Gazebo/CameraLensFlareVS { }
+      fragment_program_ref Gazebo/CameraLensFlareFS { }
 
       texture_unit RT
       {
         tex_coord_set 0
         tex_address_mode border
         filtering linear linear linear
       }
-      texture_unit noiseRGBA
-      {
-        texture noise_rgba.png
-      }
     }
   }
 }

media/materials/textures/CMakeLists.txt

@@ -18,7 +18,6 @@ set (files
   hardwood_floor.jpg
   heightmap_bowl.png
   motorway.jpg
-  noise_rgba.png
   paintedWall.jpg
   pioneerBody.jpg
   primary.jpg

plugins/LensFlareSensorPlugin.cc

@@ -35,6 +35,10 @@ namespace gazebo
 
     /// \brief Lens flare scale
     public: double scale = 1.0;
+
+    /// \brief Lens flare color
+    public: ignition::math::Vector3d color
+        = ignition::math::Vector3d(1.4, 1.2, 1.0);
   };
 }
 
@@ -75,6 +79,11 @@ void LensFlareSensorPlugin::Load(sensors::SensorPtr _sensor,
       gzerr << "Lens flare scale must be greater than 0" << std::endl;
   }
 
+  if (_sdf->HasElement("color"))
+  {
+    this->dataPtr->color = _sdf->Get<ignition::math::Vector3d>("color");
+  }
+
   sensors::CameraSensorPtr cameraSensor =
     std::dynamic_pointer_cast<sensors::CameraSensor>(_sensor);
 
@@ -101,6 +110,28 @@ void LensFlareSensorPlugin::Load(sensors::SensorPtr _sensor,
   return;
 }
 
+/////////////////////////////////////////////////
+void LensFlareSensorPlugin::SetScale(const double _scale)
+{
+  this->dataPtr->scale = _scale;
+
+  for (auto flare : this->dataPtr->lensFlares)
+  {
+    flare->SetScale(_scale);
+  }
+}
+
+/////////////////////////////////////////////////
+void LensFlareSensorPlugin::SetColor(const ignition::math::Vector3d &_color)
+{
+  this->dataPtr->color = _color;
+
+  for (auto flare : this->dataPtr->lensFlares)
+  {
+    flare->SetColor(_color);
+  }
+}
+
 /////////////////////////////////////////////////
 void LensFlareSensorPlugin::AddLensFlare(rendering::CameraPtr _camera)
 {
@@ -111,5 +142,6 @@ void LensFlareSensorPlugin::AddLensFlare(rendering::CameraPtr _camera)
   lensFlare.reset(new rendering::LensFlare);
   lensFlare->SetCamera(_camera);
   lensFlare->SetScale(this->dataPtr->scale);
+  lensFlare->SetColor(this->dataPtr->color);
   this->dataPtr->lensFlares.push_back(lensFlare);
 }

plugins/LensFlareSensorPlugin.hh

@@ -28,7 +28,10 @@ namespace gazebo
   /// \brief Plugin that adds lens flare effect to a camera or multicamera
   /// sensor
   /// The plugin has the following optional parameter:
-  /// <scale>     Scale of lens flare. Must be greater than 0
+  /// <scale>       Scale of lens flare. Must be greater than 0
+  /// <color>       Color of lens flare.
+  /// \todo A potentially useful feature would be an option for constantly
+  /// updating the flare color to match the light source color.
   class GAZEBO_VISIBLE LensFlareSensorPlugin : public SensorPlugin
   {
     /// \brief Constructor.
@@ -41,6 +44,14 @@ namespace gazebo
     public: virtual void Load(sensors::SensorPtr _sensor,
         sdf::ElementPtr _sdf);
 
+    /// \brief Set the scale of lens flare.
+    /// \param[in] _scale Scale of lens flare
+    public: void SetScale(const double _scale);
+
+    /// \brief Set the color of lens flare.
+    /// \param[in] _color Color of lens flare
+    public: void SetColor(const ignition::math::Vector3d &_color);
+
     /// \brief Add lens flare effect to a camera
     /// \param[in] _camera Camera to add the lens flare effect to.
     private: void AddLensFlare(rendering::CameraPtr _camera);