Support loading glb with compressed jpeg textures

graphics/include/gz/common/Image.hh

@@ -85,7 +85,11 @@ namespace gz
                 BAYER_GBRG8,
                 BAYER_GRBG8,
                 COMPRESSED_PNG,
-                PIXEL_FORMAT_COUNT
+                PIXEL_FORMAT_COUNT,
+                // \todo(iche033) COMPRESSED_JPEG is added at the end to
+                // preserve ABI compatibility. Move this enum up when merging
+                // forward to main
+                COMPRESSED_JPEG
               };
 
 

graphics/src/AssimpLoader.cc

@@ -196,7 +196,7 @@
     const aiNode* _node, const math::Matrix4d& _transform, Mesh* _mesh) const
 {
   if (!_node)
     return;
   // Visit this node, add the submesh
   for (unsigned meshIdx = 0; meshIdx < _node->mNumMeshes; ++meshIdx)
   {
@@ -221,7 +221,7 @@
         SkeletonNode *skelNode =
             skeleton->NodeByName(boneNodeName);
         if (skelNode == nullptr)
           continue;
         skelNode->SetInverseBindTransform(
             this->ConvertTransform(bone->mOffsetMatrix));
         for (unsigned weightIdx = 0; weightIdx < bone->mNumWeights; ++weightIdx)
@@ -267,7 +267,7 @@
     std::unordered_set<std::string>& _boneNames) const
 {
   if (!_node)
     return;
 
   for (unsigned meshIdx = 0; meshIdx < _node->mNumMeshes; ++meshIdx)
   {
@@ -295,7 +295,7 @@
     const std::unordered_set<std::string> &_boneNames) const
 {
   if (_node == nullptr || _parent == nullptr)
     return;
   // First explore this node
   auto nodeName = ToString(_node->mName);
   auto boneExist = _boneNames.find(nodeName) != _boneNames.end();
@@ -510,57 +510,74 @@
 }
 
 std::pair<ImagePtr, ImagePtr>
     AssimpLoader::Implementation::SplitMetallicRoughnessMap(
     const common::Image& _img) const
 {
   std::pair<ImagePtr, ImagePtr> ret;
   // Metalness in B roughness in G
   const auto width = _img.Width();
   const auto height = _img.Height();
   const auto bytesPerPixel = 4;
 
   std::vector<unsigned char> metalnessData(width * height * bytesPerPixel);
   std::vector<unsigned char> roughnessData(width * height * bytesPerPixel);
 
   for (unsigned int y = 0; y < height; ++y)
   {
     for (unsigned int x = 0; x < width; ++x)
     {
       // RGBA so 4 bytes per pixel, alpha fully opaque
       auto baseIndex = bytesPerPixel * (y * width + x);
       auto color = _img.Pixel(x, (height - y - 1));
       metalnessData[baseIndex] = color.B() * 255.0;
       metalnessData[baseIndex + 1] = color.B() * 255.0;
       metalnessData[baseIndex + 2] = color.B() * 255.0;
       metalnessData[baseIndex + 3] = 255;
       roughnessData[baseIndex] = color.G() * 255.0;
       roughnessData[baseIndex + 1] = color.G() * 255.0;
       roughnessData[baseIndex + 2] = color.G() * 255.0;
       roughnessData[baseIndex + 3] = 255;
     }
   }
   // First is metal, second is rough
   ret.first = std::make_shared<Image>();
   ret.first->SetFromData(&metalnessData[0], width, height, Image::RGBA_INT8);
   ret.second = std::make_shared<Image>();
   ret.second->SetFromData(&roughnessData[0], width, height, Image::RGBA_INT8);
   return ret;
 }
 
 //////////////////////////////////////////////////
 ImagePtr AssimpLoader::Implementation::LoadEmbeddedTexture(
     const aiTexture* _texture) const
 {
-  auto img = std::make_shared<Image>();
   if (_texture->mHeight == 0)
   {
+    Image::PixelFormatType format = Image::PixelFormatType::UNKNOWN_PIXEL_FORMAT;
     if (_texture->CheckFormat("png"))
     {
-      img->SetFromCompressedData((unsigned char*)_texture->pcData,
-          _texture->mWidth, Image::PixelFormatType::COMPRESSED_PNG);
+      format = Image::PixelFormatType::COMPRESSED_PNG;
+    }
+    else if (_texture->CheckFormat("jpg"))
+    {
+      format = Image::PixelFormatType::COMPRESSED_JPEG;
+    }
+    if (format != Image::PixelFormatType::UNKNOWN_PIXEL_FORMAT)
+    {
+      auto img = std::make_shared<Image>();
+      img->SetFromCompressedData(
+          reinterpret_cast<unsigned char *>(_texture->pcData),
+          _texture->mWidth, format);
+      return img;
+    }
+    else
+    {
+      gzerr << "Unable to load embedded texture. "
+            << "Unsupported compressed image format"
+            << std::endl;
     }
   }
-  return img;
+  return ImagePtr();
 }
 
 //////////////////////////////////////////////////
@@ -747,7 +764,7 @@
     SkeletonNode *node = queue.front();
     queue.pop();
     if (nullptr == node)
       continue;
 
     if (node->HasInvBindTransform())
     {

graphics/src/AssimpLoader_TEST.cc

@@ -644,6 +644,39 @@ TEST_F(AssimpLoader, LoadGlTF2BoxExternalTexture)
   EXPECT_EQ(testTextureFile, mat->TextureImage());
 }
 
+/////////////////////////////////////////////////
+// This test loads a box glb mesh with embedded compressed jpeg texture
+TEST_F(AssimpLoader, LoadGlTF2BoxWithJPEGTexture)
+{
+  common::AssimpLoader loader;
+  common::Mesh *mesh = loader.Load(
+      common::testing::TestFile("data", "box_texture_jpg.glb"));
+
+  EXPECT_STREQ("unknown", mesh->Name().c_str());
+  EXPECT_EQ(math::Vector3d(1, 1, 1), mesh->Max());
+  EXPECT_EQ(math::Vector3d(-1, -1, -1), mesh->Min());
+
+  EXPECT_EQ(24u, mesh->VertexCount());
+  EXPECT_EQ(24u, mesh->NormalCount());
+  EXPECT_EQ(36u, mesh->IndexCount());
+  EXPECT_EQ(24u, mesh->TexCoordCount());
+  EXPECT_EQ(1u, mesh->SubMeshCount());
+  EXPECT_EQ(1u, mesh->MaterialCount());
+
+  // Make sure we can read the submesh name
+  EXPECT_STREQ("Cube", mesh->SubMeshByIndex(0).lock()->Name().c_str());
+
+  const common::MaterialPtr mat = mesh->MaterialByIndex(0u);
+  ASSERT_TRUE(mat.get());
+
+  // Make sure we read the material color values
+  EXPECT_EQ(math::Color(0.4f, 0.4f, 0.4f, 1.0f), mat->Ambient());
+  EXPECT_EQ(math::Color(1.0f, 1.0f, 1.0f, 1.0f), mat->Diffuse());
+  EXPECT_EQ(math::Color(0.0f, 0.0f, 0.0f, 1.0f), mat->Specular());
+  EXPECT_EQ("Cube_Material_Diffuse", mat->TextureImage());
+  EXPECT_NE(nullptr, mat->TextureData());
+}
+
 /////////////////////////////////////////////////
 // Use a fully featured glb test asset, including PBR textures, emissive maps
 // embedded textures, lightmaps, animations to test advanced glb features

graphics/src/Image.cc

@@ -239,17 +239,17 @@
     bluemask = 0xff0000;
     scanlineBytes = _width * 3;
   }
   else if ((_format == BAYER_RGGB8) ||
            (_format == BAYER_BGGR8) ||
            (_format == BAYER_GBRG8) ||
            (_format == BAYER_GRBG8))
   {
     bpp = 8;
     scanlineBytes = _width;
   }
   else
   {
     gzerr << "Unable to handle format[" << _format << "]\n";
     return;
   }
 
@@ -274,10 +274,22 @@
     FreeImage_Unload(this->dataPtr->bitmap);
   this->dataPtr->bitmap = nullptr;
 
-  if (_format == COMPRESSED_PNG)
+  FREE_IMAGE_FORMAT format = FIF_UNKNOWN;
+  switch (_format)
+  {
+    case COMPRESSED_PNG:
+      format = FIF_PNG;
+      break;
+    case COMPRESSED_JPEG:
+      format = FIF_JPEG;
+      break;
+    default:
+      break;
+  }
+  if (format != FIF_UNKNOWN)
   {
     FIMEMORY *fiMem = FreeImage_OpenMemory(_data, _size);
-    this->dataPtr->bitmap = FreeImage_LoadFromMemory(FIF_PNG, fiMem);
+    this->dataPtr->bitmap = FreeImage_LoadFromMemory(format, fiMem);
     FreeImage_CloseMemory(fiMem);
   }
   else
@@ -396,7 +408,7 @@
   }
   else
   {
     data = this->dataPtr->DataImpl(this->dataPtr->bitmap);
   }
   return data;
 }
@@ -525,10 +537,10 @@
   }
   else
   {
     if (this->dataPtr->PixelIndex(
            this->dataPtr->bitmap, _x, _y, clr) == FALSE)
     {
       gzerr << "Image: Coordinates out of range ["
         << _x << " " << _y << "] \n";
       return clr;
     }
@@ -590,7 +602,7 @@
         if (FALSE ==
               FreeImage_GetPixelColor(this->dataPtr->bitmap, x, y, &firgb))
         {
           gzerr << "Image: Coordinates out of range["
             << x << " " << y << "] \n";
           continue;
         }
@@ -614,7 +626,7 @@
         if (this->dataPtr->PixelIndex(
                this->dataPtr->bitmap, x, y, clr) == FALSE)
         {
           gzerr << "Image: Coordinates out of range ["
             << x << " " << y << "] \n";
           continue;
         }
@@ -635,7 +647,7 @@
     FIBITMAP *_dib, unsigned _x, unsigned _y, math::Color &_color) const
 {
   if (!_dib)
     return FALSE;
 
   FREE_IMAGE_TYPE imageType = FreeImage_GetImageType(_dib);
   // 8 bit images
@@ -646,7 +658,7 @@
     if (FreeImage_GetPixelIndex(
         _dib, _x, _y, &byteValue) == FALSE)
     {
       return FALSE;
     }
 
     unsigned int bpp = FreeImage_GetBPP(_dib);
@@ -667,7 +679,7 @@
     }
     else
     {
       return FALSE;
     }
   }
   return TRUE;