Fix the incorrect mipmap state of the Image returned by Image::makeRasterized().

src/images/Image.cpp

@@ -119,7 +119,11 @@ BackendTexture Image::getBackendTexture(Context*, ImageOrigin*) const {
 
 std::shared_ptr<Image> Image::makeRasterized(float rasterizationScale,
                                              SamplingOptions sampling) const {
-  return RasterImage::MakeFrom(weakThis.lock(), rasterizationScale, sampling);
+  auto rasterImage = RasterImage::MakeFrom(weakThis.lock(), rasterizationScale, sampling);
+  if (rasterImage != nullptr && hasMipmaps()) {
+    return rasterImage->makeMipmapped(true);
+  }
+  return rasterImage;
 }
 
 std::shared_ptr<Image> Image::makeTextureImage(Context* context) const {

src/images/MipmapImage.cpp

@@ -17,19 +17,22 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "MipmapImage.h"
+#include "utils/Log.h"
 #include "utils/UniqueID.h"
 
 namespace tgfx {
 static BytesKey MakeMipmapBytesKey() {
+  auto mipmapFlag = UniqueID::Next();
   BytesKey bytesKey(1);
-  bytesKey.write(1);
+  bytesKey.write(mipmapFlag);
   return bytesKey;
 }
 
 std::shared_ptr<Image> MipmapImage::MakeFrom(std::shared_ptr<ResourceImage> source) {
   if (source == nullptr) {
     return nullptr;
   }
+  DEBUG_ASSERT(!source->hasMipmaps());
   static const auto MipmapBytesKey = MakeMipmapBytesKey();
   auto uniqueKey = UniqueKey::Combine(source->uniqueKey, MipmapBytesKey);
   auto image =
@@ -44,12 +47,15 @@ MipmapImage::MipmapImage(UniqueKey uniqueKey, std::shared_ptr<ResourceImage> sou
 
 std::shared_ptr<Image> MipmapImage::makeRasterized(float rasterizationScale,
                                                    SamplingOptions sampling) const {
+  if (rasterizationScale == 1.0f) {
+    return weakThis.lock();
+  }
   auto newSource =
       std::static_pointer_cast<ResourceImage>(source->makeRasterized(rasterizationScale, sampling));
-  if (newSource == source) {
-    return weakThis.lock();
+  if (newSource != nullptr) {
+    return newSource->makeMipmapped(true);
   }
-  return MipmapImage::MakeFrom(std::move(newSource));
+  return newSource;
 }
 
 std::shared_ptr<Image> MipmapImage::onMakeDecoded(Context* context, bool) const {

src/images/RasterImage.cpp

@@ -24,13 +24,16 @@
 #include "tgfx/core/RenderFlags.h"
 
 namespace tgfx {
-std::shared_ptr<Image> RasterImage::MakeFrom(std::shared_ptr<Image> source,
-                                             float rasterizationScale, SamplingOptions sampling) {
+std::shared_ptr<RasterImage> RasterImage::MakeFrom(std::shared_ptr<Image> source,
+                                                   float rasterizationScale,
+                                                   SamplingOptions sampling) {
   if (source == nullptr || rasterizationScale <= 0) {
     return nullptr;
   }
   auto hasMipmap = source->hasMipmaps();
   auto needMipmap = sampling.mipmapMode != MipmapMode::None;
+  // The source image's mipmap state is controlled by sampling options, while the caller defines the
+  // mipmap state of the returned raster image.
   if (hasMipmap != needMipmap) {
     auto newSource = source->makeMipmapped(needMipmap);
     if (newSource != nullptr) {
@@ -40,7 +43,7 @@ std::shared_ptr<Image> RasterImage::MakeFrom(std::shared_ptr<Image> source,
   auto rasterImage = std::shared_ptr<RasterImage>(
       new RasterImage(UniqueKey::Make(), std::move(source), rasterizationScale, sampling));
   rasterImage->weakThis = rasterImage;
-  return hasMipmap ? rasterImage->makeMipmapped(true) : rasterImage;
+  return rasterImage;
 }
 
 RasterImage::RasterImage(UniqueKey uniqueKey, std::shared_ptr<Image> source,

src/images/RasterImage.h

@@ -24,9 +24,12 @@
 namespace tgfx {
 class RasterImage : public ResourceImage {
  public:
-  static std::shared_ptr<Image> MakeFrom(std::shared_ptr<Image> source,
-                                         float rasterizationScale = 1.0f,
-                                         SamplingOptions sampling = {});
+  /**
+   * Note that the returned Image is always non-mipmapped.
+   */
+  static std::shared_ptr<RasterImage> MakeFrom(std::shared_ptr<Image> source,
+                                               float rasterizationScale = 1.0f,
+                                               SamplingOptions sampling = {});
 
   int width() const override;
 

test/src/CanvasTest.cpp

@@ -405,7 +405,11 @@ TGFX_TEST(CanvasTest, rasterized) {
   texture = Resource::Find<Texture>(context, rasterImageUniqueKey);
   EXPECT_TRUE(texture != nullptr);
   canvas->clear();
+  rasterImage = rasterImage->makeMipmapped(false);
+  EXPECT_FALSE(rasterImage->hasMipmaps());
   rasterImage = rasterImage->makeRasterized(2.0f, sampling);
+  EXPECT_FALSE(rasterImage->hasMipmaps());
+  rasterImage = rasterImage->makeMipmapped(true);
   EXPECT_EQ(rasterImage->width(), 908);
   EXPECT_EQ(rasterImage->height(), 1210);
   canvas->drawImage(rasterImage, 100, 100);