Improved coverage: MeshDescriptor, Mesh, MoveToHelper, OrbitViewController, PixelFormat and ShadersParams

examples/text_geom/CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.10.2 FATAL_ERROR)
 project(ignition-rendering-text-geom)
 
 find_package(ignition-rendering3)
+find_package(ignition-common3)
 
 find_package(GLUT REQUIRED)
 include_directories(SYSTEM ${GLUT_INCLUDE_DIRS})
@@ -26,5 +27,5 @@ target_link_libraries(text_geom
   ${OPENGL_LIBRARIES}
   ${GLEW_LIBRARIES}
   ${IGNITION-RENDERING_LIBRARIES}
+  ${IGNITION-COMMON_LIBRARIES}
   )
-

ogre2/src/Ogre2Camera.cc

@@ -233,8 +233,17 @@ VisualPtr Ogre2Camera::VisualAt(const math::Vector2i &_mousePos)
 //////////////////////////////////////////////////
 RenderWindowPtr Ogre2Camera::CreateRenderWindow()
 {
-  // TODO(anyone)
-  return RenderWindowPtr();
+  RenderWindowPtr base = this->scene->CreateRenderWindow();
+  Ogre2RenderWindowPtr renderWindow =
+      std::dynamic_pointer_cast<Ogre2RenderWindow>(base);
+  renderWindow->SetWidth(this->ImageWidth());
+  renderWindow->SetHeight(this->ImageHeight());
+  renderWindow->SetDevicePixelRatio(1);
+  renderWindow->SetCamera(this->ogreCamera);
+  renderWindow->SetBackgroundColor(this->scene->BackgroundColor());
+
+  this->renderTexture = renderWindow;
+  return base;
 }
 
 //////////////////////////////////////////////////

ogre2/src/Ogre2Grid.cc

@@ -43,11 +43,14 @@ Ogre2Grid::Ogre2Grid()
 //////////////////////////////////////////////////
 Ogre2Grid::~Ogre2Grid()
 {
+  BaseGrid::Destroy();
 }
 
 //////////////////////////////////////////////////
 void Ogre2Grid::PreRender()
 {
+  BaseGrid::PreRender();
+
   if (this->gridDirty)
   {
     this->Create();

ogre2/src/Ogre2Marker.cc

@@ -58,12 +58,15 @@ Ogre2Marker::~Ogre2Marker()
 //////////////////////////////////////////////////
 void Ogre2Marker::PreRender()
 {
+  BaseMarker::PreRender();
   this->dataPtr->dynamicRenderable->Update();
 }
 
 //////////////////////////////////////////////////
 void Ogre2Marker::Destroy()
 {
+  BaseMarker::Destroy();
+
   if (!this->Scene())
     return;
 
@@ -192,19 +195,22 @@ MaterialPtr Ogre2Marker::Material() const
 void Ogre2Marker::SetPoint(unsigned int _index,
     const math::Vector3d &_value)
 {
+  BaseMarker::SetPoint(_index, _value);
   this->dataPtr->dynamicRenderable->SetPoint(_index, _value);
 }
 
 //////////////////////////////////////////////////
 void Ogre2Marker::AddPoint(const math::Vector3d &_pt,
     const math::Color &_color)
 {
+  BaseMarker::AddPoint(_pt, _color);
   this->dataPtr->dynamicRenderable->AddPoint(_pt, _color);
 }
 
 //////////////////////////////////////////////////
 void Ogre2Marker::ClearPoints()
 {
+  BaseMarker::ClearPoints();
   this->dataPtr->dynamicRenderable->Clear();
 }
 

ogre2/src/Ogre2RenderEngine.cc

@@ -92,6 +92,7 @@ Ogre2RenderEngine::Ogre2RenderEngine() :
 //////////////////////////////////////////////////
 Ogre2RenderEngine::~Ogre2RenderEngine()
 {
+  this->Fini();
 }
 
 //////////////////////////////////////////////////
@@ -141,7 +142,7 @@ void Ogre2RenderEngine::Destroy()
 //////////////////////////////////////////////////
 bool Ogre2RenderEngine::IsEnabled() const
 {
-  return this->initialized;
+  return BaseRenderEngine::IsEnabled();
 }
 
 //////////////////////////////////////////////////

ogre2/src/Ogre2Scene.cc

@@ -406,11 +406,12 @@ RenderTexturePtr Ogre2Scene::CreateRenderTextureImpl(unsigned int _id,
 }
 
 //////////////////////////////////////////////////
-RenderWindowPtr Ogre2Scene::CreateRenderWindowImpl(unsigned int /*_id*/,
-    const std::string &/*_name*/)
+RenderWindowPtr Ogre2Scene::CreateRenderWindowImpl(unsigned int _id,
+    const std::string &_name)
 {
-  // TODO(anyone)
-  return RenderWindowPtr();
+  Ogre2RenderWindowPtr renderWindow(new Ogre2RenderWindow);
+  bool result = this->InitObject(renderWindow, _id, _name);
+  return (result) ? renderWindow : nullptr;
 }
 
 //////////////////////////////////////////////////

src/Marker_TEST.cc

@@ -115,6 +115,8 @@ void MarkerTest::Marker(const std::string &_renderEngine)
   // exercise point api
   EXPECT_NO_THROW(marker->AddPoint(math::Vector3d(0, 1, 2),
       math::Color::White));
+  EXPECT_NO_THROW(marker->AddPoint(-2, -1, 0, math::Color::White));
+
   EXPECT_NO_THROW(marker->SetPoint(0, math::Vector3d(3, 1, 2)));
   EXPECT_NO_THROW(marker->ClearPoints());
 

src/MeshDescriptor_TEST.cc

@@ -53,6 +53,12 @@ void MeshDescriptorTest::Descriptor(const std::string &_renderEngine)
   ScenePtr scene = engine->CreateScene("scene");
   ASSERT_TRUE(scene != nullptr);
 
+  MeshDescriptor failDescriptor;
+  failDescriptor.Load();
+
+  MeshDescriptor failDescriptor2("non_existing_mesh");
+  failDescriptor2.Load();
+
   // empty constructor
   MeshDescriptor emptyDescriptor;
   EXPECT_TRUE(emptyDescriptor.meshName.empty());

src/Mesh_TEST.cc

@@ -79,6 +79,11 @@ void MeshTest::MeshSubMesh(const std::string &_renderEngine)
 
   EXPECT_FALSE(mesh->HasSkeleton());
 
+  std::map<std::string, ignition::math::Matrix4d> skinFrames;
+  mesh->SetSkeletonLocalTransforms(skinFrames);
+  auto skeletonLocalTransforms = mesh->SkeletonLocalTransforms();
+  EXPECT_EQ(0u, skeletonLocalTransforms.size());
+
   // test submesh API
   MaterialPtr mat = submesh->Material();
   ASSERT_TRUE(mat != nullptr);
@@ -90,6 +95,8 @@ void MeshTest::MeshSubMesh(const std::string &_renderEngine)
   EXPECT_EQ(matClone, submesh->Material());
   EXPECT_NE(mat, submesh->Material());
 
+  submesh->SetMaterial(MaterialPtr(), false);
+
   submesh->SetMaterial("Default/White", false);
   EXPECT_EQ("Default/White", submesh->Material()->Name());
 
@@ -181,6 +188,9 @@ void MeshTest::MeshSkeleton(const std::string &_renderEngine)
     mesh->SetSkeletonLocalTransforms(skinFrames);
   }
 
+  auto skeletonLocalTransforms = mesh->SkeletonLocalTransforms();
+  EXPECT_EQ(31u, skeletonLocalTransforms.size());
+
   // Clean up
   engine->DestroyScene(scene);
   unloadEngine(engine->Name());

src/MoveToHelper_TEST.cc

@@ -17,6 +17,7 @@
 #include <gtest/gtest.h>
 
 #include <chrono>
+#include <cmath>
 
 #include <ignition/rendering/MoveToHelper.hh>
 #include <ignition/common/Console.hh>
@@ -111,6 +112,11 @@ void MoveToHelperTest::MoveTo(const std::string &_renderEngine)
 
   NodePtr target = scene->NodeByName("center");
 
+  moveToHelper.SetInitCameraPose(math::Pose3d());
+
+  // This call should return, there is no camera
+  moveToHelper.AddTime(0.1);
+
   moveToHelper.MoveTo(camera, target, 0.5,
     std::bind(&MoveToHelperTest::OnMoveToComplete, this));
   EXPECT_FALSE(moveToHelper.Idle());
@@ -136,6 +142,22 @@ void MoveToHelperTest::MoveTo(const std::string &_renderEngine)
   EXPECT_EQ(math::Vector3d(0.0, -1, 0.0), camera->LocalPosition());
   EXPECT_EQ(math::Quaterniond(0.0, -0.785398, 1.5708), camera->LocalRotation());
 
+  moveToHelper.LookDirection(camera,
+      math::Vector3d::Zero, lookAt,
+      0.5, std::bind(&MoveToHelperTest::OnMoveToComplete, this));
+  EXPECT_FALSE(moveToHelper.Idle());
+  checkIsCompleted(0.5);
+  EXPECT_TRUE(moveToHelper.Idle());
+  EXPECT_EQ(math::Vector3d(0.0, 0, 0.0), camera->LocalPosition());
+  EXPECT_EQ(math::Quaterniond(0.0, 0, 0), camera->LocalRotation());
+
+  moveToHelper.MoveTo(camera, math::Pose3d(INFINITY, 0.0, 0.0, 0, 0, 0), 0.5,
+    std::bind(&MoveToHelperTest::OnMoveToComplete, this));
+  EXPECT_FALSE(moveToHelper.Idle());
+  checkIsCompleted(0.5);
+  EXPECT_EQ(math::Vector3d(0.0, 0, 0.0), camera->LocalPosition());
+  EXPECT_TRUE(moveToHelper.Idle());
+
   engine->DestroyScene(scene);
   unloadEngine(engine->Name());
 }

src/OrbitViewController.cc

@@ -28,14 +28,6 @@ class ignition::rendering::OrbitViewControllerPrivate
 
   /// \brief Target point for camera movements
   public: math::Vector3d target;
-
-  /// \brief Keep yaw within limits
-  /// \return Normalized yaw
-  public: double NormalizeYaw(double _yaw);
-
-  /// \brief Keep pitch within limits
-  /// \return Normalized pitch
-  public: double NormalizePitch(double _pitch);
 };
 
 using namespace ignition;
@@ -178,26 +170,3 @@ void OrbitViewController::Orbit(const math::Vector2d &_value)
   this->dataPtr->camera->SetWorldPosition(
       this->dataPtr->camera->WorldPosition() + this->dataPtr->target);
 }
-
-//////////////////////////////////////////////////
-double OrbitViewControllerPrivate::NormalizeYaw(double _yaw)
-{
-  _yaw = fmod(_yaw, IGN_PI*2);
-  if (_yaw < 0.0f)
-  {
-    _yaw = IGN_PI * 2 + _yaw;
-  }
-
-  return _yaw;
-}
-
-//////////////////////////////////////////////////
-double OrbitViewControllerPrivate::NormalizePitch(double _pitch)
-{
-  if (_pitch < PITCH_LIMIT_LOW)
-    _pitch = PITCH_LIMIT_LOW;
-  else if (_pitch > PITCH_LIMIT_HIGH)
-    _pitch = PITCH_LIMIT_HIGH;
-
-  return _pitch;
-}

src/OrbitViewController_TEST.cc

@@ -35,6 +35,10 @@ class OrbitViewControllerTest : public testing::Test,
   /// \brief Test basic api
   public: void OrbitViewControl(const std::string &_renderEngine);
 
+  /// \brief Test basic api
+  public: void OrbitViewControlCameraConstructor(
+    const std::string &_renderEngine);
+
   /// \brief test zoom, pan, orbit
   public: void Control(const std::string &_renderEngine);
 };
@@ -83,6 +87,43 @@ void OrbitViewControllerTest::OrbitViewControl(const std::string &_renderEngine)
   unloadEngine(engine->Name());
 }
 
+/////////////////////////////////////////////////
+void OrbitViewControllerTest::OrbitViewControlCameraConstructor(
+  const std::string &_renderEngine)
+{
+  RenderEngine *engine = rendering::engine(_renderEngine);
+  if (!engine)
+  {
+    igndbg << "Engine '" << _renderEngine
+              << "' is not supported" << std::endl;
+    return;
+  }
+  ScenePtr scene = engine->CreateScene("scene");
+  EXPECT_NE(scene, nullptr);
+
+  CameraPtr camera =  scene->CreateCamera("camera");
+  EXPECT_NE(camera, nullptr);
+
+  OrbitViewController viewControl(camera);
+
+  // verify intial values
+  EXPECT_EQ(camera, viewControl.Camera());
+  EXPECT_EQ(math::Vector3d::Zero, viewControl.Target());
+
+  // test setting target
+  math::Vector3d target(1, 0, 0);
+  viewControl.SetTarget(target);
+  EXPECT_EQ(target, viewControl.Target());
+
+  target.Set(-0.3, -5, 1);
+  viewControl.SetTarget(target);
+  EXPECT_EQ(target, viewControl.Target());
+
+  // Clean up
+  engine->DestroyScene(scene);
+  unloadEngine(engine->Name());
+}
+
 /////////////////////////////////////////////////
 void OrbitViewControllerTest::Control(const std::string &_renderEngine)
 {
@@ -107,6 +148,10 @@ void OrbitViewControllerTest::Control(const std::string &_renderEngine)
 
   OrbitViewController viewControl;
 
+  viewControl.Zoom(0);
+  viewControl.Pan(math::Vector2d(0, 0));
+  viewControl.Orbit(math::Vector2d(0, 0));
+
   // test setting camera
   viewControl.SetCamera(camera);
   EXPECT_EQ(camera, viewControl.Camera());
@@ -229,6 +274,12 @@ TEST_P(OrbitViewControllerTest, OrbitViewController)
   OrbitViewControl(GetParam());
 }
 
+/////////////////////////////////////////////////
+TEST_P(OrbitViewControllerTest, OrbitViewControllerCameraConstructor)
+{
+  OrbitViewControlCameraConstructor(GetParam());
+}
+
 /////////////////////////////////////////////////
 TEST_P(OrbitViewControllerTest, Control)
 {

src/PixelFormat_TEST.cc

@@ -31,26 +31,47 @@ TEST(PixelFormatTest, PixelUtil)
   EXPECT_EQ(3u, PixelUtil::BytesPerPixel(format));
   EXPECT_EQ(1u, PixelUtil::BytesPerChannel(format));
   EXPECT_EQ(3072u, PixelUtil::MemorySize(format, 32, 32));
+  EXPECT_EQ("R8G8B8", PixelUtil::Name(format));
+  EXPECT_EQ(format, PixelUtil::Enum("R8G8B8"));
 
   format = PF_FLOAT32_R;
   EXPECT_EQ(4u, PixelUtil::BytesPerPixel(format));
   EXPECT_EQ(4u, PixelUtil::BytesPerChannel(format));
   EXPECT_EQ(4096u, PixelUtil::MemorySize(format, 32, 32));
+  EXPECT_EQ("FLOAT32_R", PixelUtil::Name(format));
+  EXPECT_EQ(format, PixelUtil::Enum("FLOAT32_R"));
 
   format = PF_FLOAT32_RGB;
   EXPECT_EQ(12u, PixelUtil::BytesPerPixel(format));
   EXPECT_EQ(4u, PixelUtil::BytesPerChannel(format));
   EXPECT_EQ(12288u, PixelUtil::MemorySize(format, 32, 32));
+  EXPECT_EQ("FLOAT32_RGB", PixelUtil::Name(format));
+  EXPECT_EQ(format, PixelUtil::Enum("FLOAT32_RGB"));
 
   format = PF_FLOAT32_RGBA;
   EXPECT_EQ(16u, PixelUtil::BytesPerPixel(format));
   EXPECT_EQ(4u, PixelUtil::BytesPerChannel(format));
   EXPECT_EQ(16384u, PixelUtil::MemorySize(format, 32, 32));
+  EXPECT_EQ("FLOAT32_RGBA", PixelUtil::Name(format));
+  EXPECT_EQ(format, PixelUtil::Enum("FLOAT32_RGBA"));
 
   format = PF_L16;
   EXPECT_EQ(2u, PixelUtil::BytesPerPixel(format));
   EXPECT_EQ(2u, PixelUtil::BytesPerChannel(format));
   EXPECT_EQ(2048u, PixelUtil::MemorySize(format, 32, 32));
+  EXPECT_EQ("L16", PixelUtil::Name(format));
+  EXPECT_EQ(format, PixelUtil::Enum("L16"));
+}
+
+/////////////////////////////////////////////////
+TEST(PixelFormatTest, PixelUtilInvalid)
+{
+  PixelFormat format = static_cast<PixelFormat>(16);
+
+  EXPECT_EQ(PF_UNKNOWN, PixelUtil::Sanitize(format));
+  EXPECT_EQ("UNKNOWN", PixelUtil::Name(format));
+
+  EXPECT_EQ(PF_UNKNOWN, PixelUtil::Enum("invalid"));
 }
 
 int main(int argc, char **argv)