Add Light Usercommand and include Light parameters in the componentInspector

include/ignition/gazebo/Model.hh

@@ -28,6 +28,8 @@
 #include <ignition/gazebo/Export.hh>
 #include <ignition/gazebo/Types.hh>
 
+#include <sdf/Light.hh>
+
 namespace ignition
 {
   namespace gazebo
@@ -169,6 +171,12 @@ namespace ignition
       public: void SetWorldPoseCmd(EntityComponentManager &_ecm,
           const math::Pose3d &_pose);
 
+      /// \brief Set a command to change the light.
+      /// \param[in] _ecm Entity-component manager.
+      /// \param[in] _light New model light.
+      public: void SetLightCmd(EntityComponentManager &_ecm,
+          const sdf::Light &_light);
+
       /// \brief Pointer to private data.
       private: std::unique_ptr<ModelPrivate> dataPtr;
     };

include/ignition/gazebo/components/LightCmd.hh

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2020 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#ifndef IGNITION_GAZEBO_COMPONENTS_LIGHTCMD_HH_
+#define IGNITION_GAZEBO_COMPONENTS_LIGHTCMD_HH_
+
+#include <sdf/Light.hh>
+
+#include <ignition/gazebo/config.hh>
+#include <ignition/gazebo/Export.hh>
+
+#include <ignition/gazebo/components/Factory.hh>
+#include "ignition/gazebo/components/Component.hh"
+#include <ignition/gazebo/components/Serialization.hh>
+
+namespace ignition
+{
+namespace gazebo
+{
+// Inline bracket to help doxygen filtering.
+inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
+namespace serializers
+{
+  using LightCmdSerializer =
+      serializers::ComponentToMsgSerializer<sdf::Light, msgs::Light>;
+}
+
+namespace components
+{
+  /// \brief A component type that contains commanded light of an
+  /// entity in the world frame represented by sdf::Light.
+  using LightCmd =
+    Component<sdf::Light, class LightCmdTag, serializers::LightCmdSerializer>;
+  IGN_GAZEBO_REGISTER_COMPONENT("ign_gazebo_components.LightCmd",
+      LightCmd)
+}
+}
+}
+}
+#endif

include/ignition/gazebo/rendering/RenderUtil.hh

@@ -66,6 +66,10 @@ inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
     /// \return Pointer to the scene
     public: rendering::ScenePtr Scene() const;
 
+    /// \brief Helper Update function for updating the scene
+    public: void UpdateECM(const UpdateInfo &_info,
+                               EntityComponentManager &_ecm);
+
     /// \brief Helper PostUpdate function for updating the scene
     public: void UpdateFromECM(const UpdateInfo &_info,
                                const EntityComponentManager &_ecm);

src/Model.cc

@@ -16,6 +16,7 @@
 */
 
 #include "ignition/gazebo/components/Joint.hh"
+#include "ignition/gazebo/components/LightCmd.hh"
 #include "ignition/gazebo/components/Link.hh"
 #include "ignition/gazebo/components/Model.hh"
 #include "ignition/gazebo/components/Name.hh"
@@ -193,3 +194,21 @@ void Model::SetWorldPoseCmd(EntityComponentManager &_ecm,
   }
 }
 
+//////////////////////////////////////////////////
+void Model::SetLightCmd(EntityComponentManager &_ecm,
+    const sdf::Light &_light)
+{
+  auto lightCmdComp = _ecm.Component<components::LightCmd>(
+      this->dataPtr->id);
+  if (!lightCmdComp)
+  {
+    _ecm.CreateComponent(this->dataPtr->id, components::LightCmd(_light));
+  }
+  else
+  {
+    lightCmdComp->SetData(_light,
+        [](const sdf::Light &, const sdf::Light &){return false;});
+    _ecm.SetChanged(this->dataPtr->id,
+        components::LightCmd::typeId, ComponentState::OneTimeChange);
+  }
+}

src/gui/plugins/component_inspector/ComponentInspector.cc

@@ -35,6 +35,7 @@
 #include "ignition/gazebo/components/Joint.hh"
 #include "ignition/gazebo/components/Level.hh"
 #include "ignition/gazebo/components/Light.hh"
+#include "ignition/gazebo/components/LightCmd.hh"
 #include "ignition/gazebo/components/LinearAcceleration.hh"
 #include "ignition/gazebo/components/LinearVelocity.hh"
 #include "ignition/gazebo/components/LinearVelocitySeed.hh"
@@ -76,6 +77,9 @@ namespace ignition::gazebo
     /// \brief Name of the world
     public: std::string worldName;
 
+    /// \brief Entity name
+    public: std::string entityName;
+
     /// \brief Entity type, such as 'world' or 'model'.
     public: QString type;
 
@@ -112,6 +116,50 @@ void ignition::gazebo::setData(QStandardItem *_item, const math::Pose3d &_data)
   }), ComponentsModel::RoleNames().key("data"));
 }
 
+//////////////////////////////////////////////////
+template<>
+void ignition::gazebo::setData(QStandardItem *_item, const sdf::Light &_data)
+{
+  int lightType = -1;
+  if (_data.Type() == sdf::LightType::POINT)
+  {
+    lightType = 0;
+  }
+  else if (_data.Type() == sdf::LightType::SPOT)
+  {
+    lightType = 1;
+  }
+  else if (_data.Type() == sdf::LightType::DIRECTIONAL)
+  {
+    lightType = 2;
+  }
+
+  _item->setData(QString("Light"),
+      ComponentsModel::RoleNames().key("dataType"));
+  _item->setData(QList({
+    QVariant(_data.Specular().R()),
+    QVariant(_data.Specular().G()),
+    QVariant(_data.Specular().B()),
+    QVariant(_data.Specular().A()),
+    QVariant(_data.Diffuse().R()),
+    QVariant(_data.Diffuse().G()),
+    QVariant(_data.Diffuse().B()),
+    QVariant(_data.Diffuse().A()),
+    QVariant(_data.AttenuationRange()),
+    QVariant(_data.LinearAttenuationFactor()),
+    QVariant(_data.ConstantAttenuationFactor()),
+    QVariant(_data.QuadraticAttenuationFactor()),
+    QVariant(_data.CastShadows()),
+    QVariant(_data.Direction().X()),
+    QVariant(_data.Direction().Y()),
+    QVariant(_data.Direction().Z()),
+    QVariant(_data.SpotInnerAngle().Radian()),
+    QVariant(_data.SpotOuterAngle().Radian()),
+    QVariant(_data.SpotFalloff()),
+    QVariant(lightType)
+  }), ComponentsModel::RoleNames().key("data"));
+}
+
 //////////////////////////////////////////////////
 template<>
 void ignition::gazebo::setData(QStandardItem *_item,
@@ -370,12 +418,6 @@ void ComponentInspector::Update(const UpdateInfo &,
       continue;
     }
 
-    if (typeId == components::Light::typeId)
-    {
-      this->SetType("light");
-      continue;
-    }
-
     if (typeId == components::Actor::typeId)
     {
       this->SetType("actor");
@@ -499,6 +541,7 @@ void ComponentInspector::Update(const UpdateInfo &,
 
       if (this->dataPtr->entity == this->dataPtr->worldEntity)
         this->dataPtr->worldName = comp->Data();
+      this->dataPtr->entityName = comp->Data();
     }
     else if (typeId == components::ParentEntity::typeId)
     {
@@ -521,6 +564,19 @@ void ComponentInspector::Update(const UpdateInfo &,
       if (comp)
         setData(item, comp->Data());
     }
+    else if (typeId == components::Light::typeId)
+    {
+      this->SetType("light");
+      auto comp = _ecm.Component<components::Light>(this->dataPtr->entity);
+      if (comp)
+        setData(item, comp->Data());
+    }
+    else if (typeId == components::LightCmd::typeId)
+    {
+      auto comp = _ecm.Component<components::LightCmd>(this->dataPtr->entity);
+      if (comp)
+        setData(item, comp->Data());
+    }
     else if (typeId == components::Pose::typeId)
     {
       auto comp = _ecm.Component<components::Pose>(this->dataPtr->entity);
@@ -728,6 +784,59 @@ void ComponentInspector::OnPose(double _x, double _y, double _z, double _roll,
   this->dataPtr->node.Request(poseCmdService, req, cb);
 }
 
+/////////////////////////////////////////////////
+void ComponentInspector::OnLight(
+  double _rSpecular, double _gSpecular, double _bSpecular, double _aSpecular,
+  double _rDiffuse, double _gDiffuse, double _bDiffuse, double _aDiffuse,
+  double _attRange, double _attLinear, double _attConstant,
+  double _attQuadratic, bool _castShadows, double _directionX,
+  double _directionY, double _directionZ, double _innerAngle,
+  double _outerAngle, double _falloff, int _type)
+{
+  std::function<void(const ignition::msgs::Boolean &, const bool)> cb =
+      [](const ignition::msgs::Boolean &/*_rep*/, const bool _result)
+  {
+    if (!_result)
+      ignerr << "Error setting light configuration" << std::endl;
+  };
+
+  ignition::msgs::Light req;
+  req.set_name(this->dataPtr->entityName);
+  req.set_id(this->dataPtr->entity);
+  ignition::msgs::Set(req.mutable_diffuse(),
+    ignition::math::Color(_rDiffuse, _gDiffuse, _bDiffuse, _aDiffuse));
+  ignition::msgs::Set(req.mutable_specular(),
+    ignition::math::Color(_rSpecular, _gSpecular, _bSpecular, _aSpecular));
+  req.set_range(_attRange);
+  req.set_attenuation_linear(_attLinear);
+  req.set_attenuation_constant(_attConstant);
+  req.set_attenuation_quadratic(_attQuadratic);
+  req.set_cast_shadows(_castShadows);
+  if (_type == 0)
+    req.set_type(ignition::msgs::Light::POINT);
+  else if (_type == 1)
+    req.set_type(ignition::msgs::Light::SPOT);
+  else
+    req.set_type(ignition::msgs::Light::DIRECTIONAL);
+
+  if (_type == 1)  // sdf::LightType::SPOT
+  {
+    req.set_spot_inner_angle(_innerAngle);
+    req.set_spot_outer_angle(_outerAngle);
+    req.set_spot_falloff(_falloff);
+  }
+
+  // if sdf::LightType::SPOT || sdf::LightType::DIRECTIONAL
+  if (_type == 1 || _type == 2) {
+    ignition::msgs::Set(req.mutable_direction(),
+      ignition::math::Vector3d(_directionX, _directionY, _directionZ));
+  }
+
+  auto lightConfigService = "/world/" + this->dataPtr->worldName +
+    "/light_config";
+  this->dataPtr->node.Request(lightConfigService, req, cb);
+}
+
 /////////////////////////////////////////////////
 bool ComponentInspector::NestedModel() const
 {

src/gui/plugins/component_inspector/ComponentInspector.hh

@@ -28,6 +28,8 @@
 #include <ignition/gazebo/gui/GuiSystem.hh>
 #include <ignition/gazebo/Types.hh>
 
+#include <sdf/Light.hh>
+
 Q_DECLARE_METATYPE(ignition::gazebo::ComponentTypeId)
 
 namespace ignition
@@ -69,6 +71,12 @@ namespace gazebo
   template<>
   void setData(QStandardItem *_item, const math::Pose3d &_data);
 
+  /// \brief Specialized to set light data.
+  /// \param[in] _item Item whose data will be set.
+  /// \param[in] _data Data to set.
+  template<>
+  void setData(QStandardItem *_item, const sdf::Light &_data);
+
   /// \brief Specialized to set vector data.
   /// \param[in] _item Item whose data will be set.
   /// \param[in] _data Data to set.
@@ -207,6 +215,36 @@ namespace gazebo
     public: Q_INVOKABLE void OnPose(double _x, double _y, double _z,
         double _roll, double _pitch, double _yaw);
 
+    /// \brief Callback in Qt thread when specular changes.
+    /// \param[in] _rSpecular specular red
+    /// \param[in] _gSpecular specular green
+    /// \param[in] _bSpecular specular blue
+    /// \param[in] _aSpecular specular alpha
+    /// \param[in] _rDiffuse Diffuse red
+    /// \param[in] _gDiffuse Diffuse green
+    /// \param[in] _bDiffuse Diffuse blue
+    /// \param[in] _aDiffuse Diffuse alpha
+    /// \param[in] _attRange Range attenuation
+    /// \param[in] _attLinear Linear attenuation
+    /// \param[in] _attConstant Constant attenuation
+    /// \param[in] _attQuadratic Quadratic attenuation
+    /// \param[in] _castShadows Specify if this light should cast shadows
+    /// \param[in] _directionX X direction of the light
+    /// \param[in] _directionY Y direction of the light
+    /// \param[in] _directionZ Z direction of the light
+    /// \param[in] _innerAngle Inner angle of the spotlight
+    /// \param[in] _outerAngle Outer angle of the spotlight
+    /// \param[in] _falloff Falloff of the spotlight
+    /// \param[in] _type light type
+    public: Q_INVOKABLE void OnLight(
+      double _rSpecular, double _gSpecular, double _bSpecular,
+      double _aSpecular, double _rDiffuse, double _gDiffuse,
+      double _bDiffuse, double _aDiffuse, double _attRange,
+      double _attLinear, double _attConstant, double _attQuadratic,
+      bool _castShadows, double _directionX, double _directionY,
+      double _directionZ, double _innerAngle, double _outerAngle,
+      double _falloff, int _type);
+
     /// \brief Get whether the entity is a nested model or not
     /// \return True if the entity is a nested model, false otherwise
     public: Q_INVOKABLE bool NestedModel() const;

src/gui/plugins/component_inspector/ComponentInspector.qml

@@ -85,6 +85,21 @@ Rectangle {
     ComponentInspector.OnPose(_x, _y, _z, _roll, _pitch, _yaw)
   }
 
+  /**
+   * Forward light changes to C++
+   */
+  function onLight(_rSpecular, _gSpecular, _bSpecular, _aSpecular,
+                   _rDiffuse, _gDiffuse, _bDiffuse, _aDiffuse,
+                   _attRange, _attLinear, _attConstant, _attQuadratic,
+                   _castShadows, _directionX, _directionY, _directionZ,
+                   _innerAngle, _outerAngle, _falloff, _type) {
+    ComponentInspector.OnLight(_rSpecular, _gSpecular, _bSpecular, _aSpecular,
+                               _rDiffuse, _gDiffuse, _bDiffuse, _aDiffuse,
+                               _attRange, _attLinear, _attConstant, _attQuadratic,
+                               _castShadows, _directionX, _directionY, _directionZ,
+                               _innerAngle, _outerAngle, _falloff, _type)
+  }
+
   Rectangle {
     id: header
     height: lockButton.height

src/gui/plugins/component_inspector/ComponentInspector.qrc

@@ -2,6 +2,7 @@
 <qresource prefix="ComponentInspector/">
   <file>Boolean.qml</file>
   <file>ComponentInspector.qml</file>
+  <file>Light.qml</file>
   <file>NoData.qml</file>
   <file>Pose3d.qml</file>
   <file>String.qml</file>