Remove redundant namespace references

Signed-off-by: methylDragon <[email protected]>

examples/gazebo_scene_viewer/GazeboWorldDemo.cc

@@ -28,7 +28,7 @@ using namespace rendering;
 
 void Connect()
 {
-  ignition::common::Console::SetVerbosity(4);
+  common::Console::SetVerbosity(4);
   gazebo::transport::init();
   gazebo::transport::run();
 

examples/gazebo_scene_viewer/SceneManager.cc

@@ -945,7 +945,7 @@ DirectionalLightPtr SubSceneManager::DirectionalLight(
   LightPtr light = this->activeScene->LightByName(name);
 
   DirectionalLightPtr dirLight =
-      std::dynamic_pointer_cast<rendering::DirectionalLight>(light);
+      std::dynamic_pointer_cast<DirectionalLight>(light);
 
   // check if not found
   if (!dirLight)
@@ -989,7 +989,7 @@ PointLightPtr SubSceneManager::PointLight(
   std::string name = _lightMsg.name();
   LightPtr light = this->activeScene->LightByName(name);
   PointLightPtr pointLight =
-      std::dynamic_pointer_cast<rendering::PointLight>(light);
+      std::dynamic_pointer_cast<PointLight>(light);
 
   // check if not found
   if (!pointLight)
@@ -1061,7 +1061,7 @@ SpotLightPtr SubSceneManager::SpotLight(const gazebo::msgs::Light &_lightMsg,
   std::string name = _lightMsg.name();
   LightPtr light = this->activeScene->LightByName(name);
   SpotLightPtr spotLight =
-      std::dynamic_pointer_cast<rendering::SpotLight>(light);
+      std::dynamic_pointer_cast<SpotLight>(light);
 
   // check if not found
   if (!spotLight)
@@ -1176,7 +1176,7 @@ CameraPtr SubSceneManager::Camera(const gazebo::msgs::Sensor &_sensorMsg,
   // find existing camera with name
   std::string name = _sensorMsg.name();
   SensorPtr sensor = this->activeScene->SensorByName(name);
-  CameraPtr camera = std::dynamic_pointer_cast<rendering::Camera>(sensor);
+  CameraPtr camera = std::dynamic_pointer_cast<Camera>(sensor);
 
   // check if not found
   if (!camera)

ogre/src/OgreCamera.cc

@@ -201,7 +201,7 @@ void OgreCamera::SetSelectionBuffer()
 }
 
 //////////////////////////////////////////////////
-VisualPtr OgreCamera::VisualAt(const ignition::math::Vector2i
+VisualPtr OgreCamera::VisualAt(const math::Vector2i
     &_mousePos)
 {
   VisualPtr result;
@@ -217,7 +217,7 @@ VisualPtr OgreCamera::VisualAt(const ignition::math::Vector2i
   }
 
   float ratio = screenScalingFactor();
-  ignition::math::Vector2i mousePos(
+  math::Vector2i mousePos(
       static_cast<int>(std::rint(ratio * _mousePos.X())),
       static_cast<int>(std::rint(ratio * _mousePos.Y())));
 

ogre/src/OgreDepthCamera.cc

@@ -528,15 +528,15 @@ const float *OgreDepthCamera::DepthData() const
 }
 
 //////////////////////////////////////////////////
-ignition::common::ConnectionPtr OgreDepthCamera::ConnectNewDepthFrame(
+common::ConnectionPtr OgreDepthCamera::ConnectNewDepthFrame(
     std::function<void(const float *, unsigned int, unsigned int,
       unsigned int, const std::string &)>  _subscriber)
 {
   return this->dataPtr->newDepthFrame.Connect(_subscriber);
 }
 
 //////////////////////////////////////////////////
-ignition::common::ConnectionPtr OgreDepthCamera::ConnectNewRgbPointCloud(
+common::ConnectionPtr OgreDepthCamera::ConnectNewRgbPointCloud(
     std::function<void(const float *, unsigned int, unsigned int,
       unsigned int, const std::string &)>  _subscriber)
 {

ogre/src/OgreDynamicLines.cc

@@ -33,10 +33,10 @@ enum {POSITION_BINDING, TEXCOORD_BINDING};
 class ignition::rendering::OgreDynamicLinesPrivate
 {
   /// \brief list of colors at each point
-  public: std::vector<ignition::math::Color> colors;
+  public: std::vector<math::Color> colors;
 
   /// \brief List of points for the line
-  public: std::vector<ignition::math::Vector3d> points;
+  public: std::vector<math::Vector3d> points;
 
   /// \brief Used to indicate if the lines require an update
   public: bool dirty = false;
@@ -57,8 +57,8 @@ OgreDynamicLines::~OgreDynamicLines()
 }
 
 /////////////////////////////////////////////////
-void OgreDynamicLines::AddPoint(const ignition::math::Vector3d &_pt,
-                            const ignition::math::Color &_color)
+void OgreDynamicLines::AddPoint(const math::Vector3d &_pt,
+                            const math::Color &_color)
 {
   this->dataPtr->points.push_back(_pt);
   this->dataPtr->colors.push_back(_color);
@@ -67,14 +67,14 @@ void OgreDynamicLines::AddPoint(const ignition::math::Vector3d &_pt,
 
 /////////////////////////////////////////////////
 void OgreDynamicLines::AddPoint(double _x, double _y,
-                double _z, const ignition::math::Color &_color)
+                double _z, const math::Color &_color)
 {
-  this->AddPoint(ignition::math::Vector3d(_x, _y, _z), _color);
+  this->AddPoint(math::Vector3d(_x, _y, _z), _color);
 }
 
 /////////////////////////////////////////////////
 void OgreDynamicLines::SetPoint(unsigned int _index,
-                            const ignition::math::Vector3d &_value)
+                            const math::Vector3d &_value)
 {
   if (_index >= this->dataPtr->points.size())
   {
@@ -90,24 +90,24 @@ void OgreDynamicLines::SetPoint(unsigned int _index,
 
 /////////////////////////////////////////////////
 void OgreDynamicLines::SetColor(unsigned int _index,
-                            const ignition::math::Color &_color)
+                            const math::Color &_color)
 {
   this->dataPtr->colors[_index] = _color;
   this->dataPtr->dirty = true;
 }
 
 /////////////////////////////////////////////////
-ignition::math::Vector3d OgreDynamicLines::Point(
+math::Vector3d OgreDynamicLines::Point(
     const unsigned int _index) const
 {
   if (_index >= this->dataPtr->points.size())
   {
     ignerr << "Point index[" << _index << "] is out of bounds[0-"
            << this->dataPtr->points.size()-1 << "]\n";
 
-    return ignition::math::Vector3d(ignition::math::INF_D,
-                                    ignition::math::INF_D,
-                                    ignition::math::INF_D);
+    return math::Vector3d(math::INF_D,
+                                    math::INF_D,
+                                    math::INF_D);
   }
 
   return this->dataPtr->points[_index];

ogre/src/OgreGpuRays.cc

@@ -710,7 +710,7 @@ void OgreGpuRays::CreateOrthoCam()
   }
 
   Ogre::SceneNode *rootSceneNode = std::dynamic_pointer_cast<
-      ignition::rendering::OgreNode>(this->scene->RootVisual())->Node();
+      OgreNode>(this->scene->RootVisual())->Node();
   this->dataPtr->pitchNodeOrtho = rootSceneNode->createChildSceneNode();
   this->dataPtr->pitchNodeOrtho->attachObject(this->dataPtr->orthoCam);
 
@@ -893,7 +893,7 @@ void OgreGpuRays::CreateCanvas()
       this->Name() + "second_pass_canvas");
 
   Ogre::SceneNode *visualSceneNode =  std::dynamic_pointer_cast<
-    ignition::rendering::OgreNode>(this->dataPtr->visual)->Node();
+    OgreNode>(this->dataPtr->visual)->Node();
 
   Ogre::Node *visualParent = visualSceneNode->getParent();
   if (visualParent != nullptr)
@@ -902,7 +902,7 @@ void OgreGpuRays::CreateCanvas()
   }
   this->dataPtr->pitchNodeOrtho->addChild(visualSceneNode);
 
-  // Convert mesh from common::Mesh to rendering::mesh and add it to
+  // Convert mesh from common::Mesh to mesh and add it to
   // the canvas visual
   MeshPtr renderingMesh = this->scene->CreateMesh(
       this->dataPtr->undistMesh);
@@ -913,7 +913,7 @@ void OgreGpuRays::CreateCanvas()
 
   MaterialPtr canvasMaterial =
     this->scene->CreateMaterial(this->Name() + "_green");
-  canvasMaterial->SetAmbient(ignition::math::Color(0, 1, 0, 1));
+  canvasMaterial->SetAmbient(math::Color(0, 1, 0, 1));
   this->dataPtr->visual->SetMaterial(canvasMaterial);
 
   this->dataPtr->visual->SetVisible(true);
@@ -975,7 +975,7 @@ void OgreGpuRays::notifyRenderSingleObject(Ogre::Renderable *_rend,
 }
 
 //////////////////////////////////////////////////
-ignition::common::ConnectionPtr OgreGpuRays::ConnectNewGpuRaysFrame(
+common::ConnectionPtr OgreGpuRays::ConnectNewGpuRaysFrame(
     std::function<void(const float *_frame, unsigned int _width,
     unsigned int _height, unsigned int _channels,
     const std::string &/*_format*/)> _subscriber)

ogre/src/OgreMarker.cc

@@ -175,14 +175,14 @@ MaterialPtr OgreMarker::Material() const
 
 //////////////////////////////////////////////////
 void OgreMarker::SetPoint(unsigned int _index,
-    const ignition::math::Vector3d &_value)
+    const math::Vector3d &_value)
 {
   this->dataPtr->dynamicRenderable->SetPoint(_index, _value);
 }
 
 //////////////////////////////////////////////////
-void OgreMarker::AddPoint(const ignition::math::Vector3d &_pt,
-    const ignition::math::Color &_color)
+void OgreMarker::AddPoint(const math::Vector3d &_pt,
+    const math::Color &_color)
 {
   this->dataPtr->dynamicRenderable->AddPoint(_pt, _color);
 }

ogre/src/OgreMaterialSwitcher.cc

@@ -28,7 +28,7 @@ using namespace rendering;
 OgreMaterialSwitcher::OgreMaterialSwitcher()
   : lastTechnique(nullptr)
 {
-  this->currentColor = ignition::math::Color(0.0f, 0.0f, 0.1f);
+  this->currentColor = math::Color(0.0f, 0.0f, 0.1f);
 }
 
 /////////////////////////////////////////////////
@@ -157,7 +157,7 @@ void OgreMaterialSwitcher::postRenderTargetUpdate(
 
 /////////////////////////////////////////////////
 std::string OgreMaterialSwitcher::EntityName(
-    const ignition::math::Color &_color) const
+    const math::Color &_color) const
 {
   auto iter = this->colorDict.find(_color.AsRGBA());
 
@@ -178,7 +178,7 @@ void OgreMaterialSwitcher::NextColor()
 /////////////////////////////////////////////////
 void OgreMaterialSwitcher::Reset()
 {
-  this->currentColor = ignition::math::Color(0.0, 0.0, 0.0);
+  this->currentColor = math::Color(0.0, 0.0, 0.0);
   this->lastTechnique = nullptr;
   this->lastEntity.clear();
   this->colorDict.clear();

ogre/src/OgreMesh.cc

@@ -64,7 +64,7 @@ bool OgreMesh::HasSkeleton() const
 std::map<std::string, math::Matrix4d>
         OgreMesh::SkeletonLocalTransforms() const
 {
-  std::map<std::string, ignition::math::Matrix4d> mapTfs;
+  std::map<std::string, math::Matrix4d> mapTfs;
   if (this->ogreEntity->hasSkeleton())
   {
     Ogre::SkeletonInstance *skel = this->ogreEntity->getSkeleton();
@@ -74,10 +74,10 @@ std::map<std::string, math::Matrix4d>
       Ogre::Quaternion quat(bone->getOrientation());
       Ogre::Vector3 p(bone->getPosition());
 
-      ignition::math::Quaterniond tfQuat(quat.w, quat.x, quat.y, quat.z);
-      ignition::math::Vector3d tfTrans(p.x, p.y, p.z);
+      math::Quaterniond tfQuat(quat.w, quat.x, quat.y, quat.z);
+      math::Vector3d tfTrans(p.x, p.y, p.z);
 
-      ignition::math::Matrix4d tf(tfQuat);
+      math::Matrix4d tf(tfQuat);
       tf.SetTranslation(tfTrans);
 
       mapTfs[bone->getName()] = tf;
@@ -102,9 +102,9 @@ void OgreMesh::SetSkeletonLocalTransforms(
     if (skel->hasBone(pair.first))
     {
       Ogre::Bone *bone = skel->getBone(pair.first);
-      ignition::math::Matrix4d tf = pair.second;
-      ignition::math::Vector3d tf_trans = tf.Translation();
-      ignition::math::Quaterniond tf_quat = tf.Rotation();
+      math::Matrix4d tf = pair.second;
+      math::Vector3d tf_trans = tf.Translation();
+      math::Quaterniond tf_quat = tf.Rotation();
 
       Ogre::Vector3 p(tf_trans.X(), tf_trans.Y(), tf_trans.Z());
 

ogre/src/OgreRTShaderSystem.cc

@@ -708,7 +708,7 @@ void OgreRTShaderSystem::Update()
 bool OgreRTShaderSystem::SetShadowTextureSize(const unsigned int _size)
 {
   // check if texture size is a power of 2
-  if (!ignition::math::isPowerOfTwo(_size))
+  if (!math::isPowerOfTwo(_size))
   {
     ignerr << "Shadow texture size must be a power of 2" << std::endl;
     return false;

ogre/src/OgreRayQuery.cc

@@ -231,7 +231,7 @@ void OgreRayQuery::MeshInformation(const Ogre::Mesh *_mesh,
            ++j, vertex += vbuf->getVertexSize())
      {
         posElem->baseVertexPointerToElement(vertex, &pReal);
-        ignition::math::Vector3d pt(pReal[0], pReal[1], pReal[2]);
+        math::Vector3d pt(pReal[0], pReal[1], pReal[2]);
         _vertices[current_offset + j] =
             OgreConversions::Convert((_orient * (pt * _scale)) + _position);
       }

ogre/src/OgreRenderEngine.cc

@@ -324,7 +324,7 @@ void OgreRenderEngine::CreateLogger()
 {
   // create log file path
   std::string logPath;
-  ignition::common::env(IGN_HOMEDIR, logPath);
+  common::env(IGN_HOMEDIR, logPath);
   logPath = common::joinPaths(logPath, ".ignition", "rendering");
   common::createDirectories(logPath);
   logPath = common::joinPaths(logPath, "ogre.log");
@@ -812,5 +812,5 @@ Ogre::OverlaySystem *OgreRenderEngine::OverlaySystem() const
 #endif
 
 // Register this plugin
-IGNITION_ADD_PLUGIN(ignition::rendering::OgreRenderEnginePlugin,
-                    ignition::rendering::RenderEnginePlugin)
+IGNITION_ADD_PLUGIN(OgreRenderEnginePlugin,
+                    rendering::RenderEnginePlugin)

ogre/src/OgreScene.cc

@@ -243,7 +243,7 @@ void OgreScene::SetGradientBackgroundColor(
     return;
   }
 
-  // Convert the ignition::math::Color to Ogre::ColourValue.
+  // Convert the math::Color to Ogre::ColourValue.
   std::array<Ogre::ColourValue, 4> ogreColors;
   for (auto i = 0u; i < 4; ++i)
     ogreColors[i].setAsRGBA(_colors[i].AsRGBA());

ogre/src/OgreSelectionBuffer.cc

@@ -231,14 +231,14 @@ Ogre::Entity *OgreSelectionBuffer::OnSelectionClick(const int _x, const int _y)
 
   size_t posInStream = 0;
 
-  ignition::math::Color::BGRA color(0);
+  math::Color::BGRA color(0);
   if (!this->dataPtr->buffer)
   {
     ignerr << "Selection buffer is null.\n";
     return nullptr;
   }
   memcpy(static_cast<void *>(&color), this->dataPtr->buffer + posInStream, 4);
-  ignition::math::Color cv;
+  math::Color cv;
   cv.SetFromARGB(color);
   cv.A(1.0);
   const std::string &entName =

ogre/src/OgreText.cc

@@ -257,7 +257,7 @@ void OgreMovableText::SetTextString(const std::string &_text)
 }
 
 //////////////////////////////////////////////////
-void OgreMovableText::SetColor(const ignition::math::Color &_color)
+void OgreMovableText::SetColor(const math::Color &_color)
 {
   if (this->color != _color)
   {
@@ -323,13 +323,13 @@ void OgreMovableText::SetShowOnTop(const bool _onTop)
 }
 
 //////////////////////////////////////////////////
-ignition::math::AxisAlignedBox OgreMovableText::AABB() const
+math::AxisAlignedBox OgreMovableText::AABB() const
 {
-  return ignition::math::AxisAlignedBox(
-      ignition::math::Vector3d(this->aabb->getMinimum().x,
+  return math::AxisAlignedBox(
+      math::Vector3d(this->aabb->getMinimum().x,
                     this->aabb->getMinimum().y,
                     this->aabb->getMinimum().z),
-      ignition::math::Vector3d(this->aabb->getMaximum().x,
+      math::Vector3d(this->aabb->getMaximum().x,
                     this->aabb->getMaximum().y,
                     this->aabb->getMaximum().z));
 }
@@ -489,7 +489,7 @@ void OgreMovableText::SetupGeometry()
   pVert = static_cast<float*>(ptbuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
 
   // Derive space width from a capital A
-  if (ignition::math::equal(this->spaceWidth, 0.0f))
+  if (math::equal(this->spaceWidth, 0.0f))
   {
     this->spaceWidth = this->font->getGlyphAspectRatio('A') *
         this->charHeight * 2.0;
@@ -983,7 +983,7 @@ void OgreText::SetTextString(const std::string &_text)
 }
 
 //////////////////////////////////////////////////
-void OgreText::SetColor(const ignition::math::Color &_color)
+void OgreText::SetColor(const math::Color &_color)
 {
   BaseText::SetColor(_color);
   this->dataPtr->ogreObj->SetColor(_color);
@@ -1026,7 +1026,7 @@ void OgreText::SetShowOnTop(const bool _onTop)
 }
 
 //////////////////////////////////////////////////
-ignition::math::AxisAlignedBox OgreText::AABB() const
+math::AxisAlignedBox OgreText::AABB() const
 {
   return this->dataPtr->ogreObj->AABB();
 }