Use Nearest as the texture filtering mode to avoid rendering blur when the image is not scaled. (#2930)

Author: kevingpqi123

src/rendering/graphics/Canvas.cpp

@@ -21,6 +21,22 @@
 #include "tgfx/core/Surface.h"
 
 namespace pag {
+tgfx::SamplingOptions GetSamplingOptions(const tgfx::Matrix& matrix, tgfx::Image* image) {
+  if (image == nullptr) {
+    return {};
+  }
+  auto mipmapMode = image->hasMipmaps() ? tgfx::MipmapMode::Linear : tgfx::MipmapMode::None;
+  tgfx::SamplingOptions samplingOptions(tgfx::FilterMode::Linear, mipmapMode);
+  if (matrix.isTranslate()) {
+    float tx = matrix.getTranslateX();
+    float ty = matrix.getTranslateY();
+    if (std::floor(tx) == tx && std::floor(ty) == ty) {
+      samplingOptions.filterMode = tgfx::FilterMode::Nearest;
+    }
+  }
+  return samplingOptions;
+}
+
 struct CanvasState {
   float alpha = 1.0f;
   tgfx::BlendMode blendMode = tgfx::BlendMode::SrcOver;

src/rendering/graphics/Canvas.h

@@ -20,11 +20,14 @@
 
 #include "tgfx/core/Canvas.h"
 #include "tgfx/core/RenderFlags.h"
+#include "tgfx/core/SamplingOptions.h"
 
 namespace pag {
 class RenderCache;
 struct CanvasState;
 
+tgfx::SamplingOptions GetSamplingOptions(const tgfx::Matrix& matrix, tgfx::Image* image);
+
 class Canvas {
  public:
   Canvas(tgfx::Surface* surface, RenderCache* cache);
@@ -145,21 +148,10 @@ class Canvas {
     canvas->drawPath(path, createPaint(paint));
   }
 
-  void drawImage(std::shared_ptr<tgfx::Image> image, float left, float top,
-                 const tgfx::Paint* paint = nullptr) {
-    auto realPaint = createPaint(paint);
-    canvas->drawImage(std::move(image), left, top, &realPaint);
-  }
-
-  void drawImage(std::shared_ptr<tgfx::Image> image, const tgfx::Matrix& matrix,
-                 const tgfx::Paint* paint = nullptr) {
-    auto realPaint = createPaint(paint);
-    canvas->drawImage(std::move(image), matrix, &realPaint);
-  }
-
   void drawImage(std::shared_ptr<tgfx::Image> image, const tgfx::Paint* paint = nullptr) {
     auto realPaint = createPaint(paint);
-    canvas->drawImage(std::move(image), &realPaint);
+    auto samplingOptions = GetSamplingOptions(canvas->getMatrix(), image.get());
+    canvas->drawImage(std::move(image), samplingOptions, &realPaint);
   }
 
   void drawImage(std::shared_ptr<tgfx::Image> image, tgfx::SamplingOptions sampling,

src/rendering/graphics/Picture.cpp

@@ -94,7 +94,10 @@ class ImageProxyPicture : public Picture {
     if (!(renderFlags & tgfx::RenderFlags::DisableCache)) {
       auto snapshot = cache->getSnapshot(this);
       if (snapshot) {
-        canvas->drawImage(snapshot->getImage(), snapshot->getMatrix());
+        auto canvasMatrix = canvas->getMatrix();
+        canvas->concat(snapshot->getMatrix());
+        canvas->drawImage(snapshot->getImage());
+        canvas->setMatrix(canvasMatrix);
         return;
       }
     }
@@ -178,7 +181,10 @@ class SnapshotPicture : public Picture {
       graphic->draw(canvas);
       return;
     }
-    canvas->drawImage(snapshot->getImage(), snapshot->getMatrix());
+    auto canvasMatrix = canvas->getMatrix();
+    canvas->concat(snapshot->getMatrix());
+    canvas->drawImage(snapshot->getImage());
+    canvas->setMatrix(canvasMatrix);
   }
 
  protected:

src/rendering/renderers/FilterRenderer.cpp

@@ -415,7 +415,10 @@ void FilterRenderer::DrawWithFilter(Canvas* parentCanvas, const FilterModifier*
   } else if (input == output) {
     parentCanvas->drawPicture(sourcePicture);
   } else {
-    parentCanvas->drawImage(output, totalOffset.x, totalOffset.y);
+    auto canvasMatrix = parentCanvas->getMatrix();
+    parentCanvas->translate(totalOffset.x, totalOffset.y);
+    parentCanvas->drawImage(output);
+    parentCanvas->setMatrix(canvasMatrix);
   }
   parentCanvas->restore();
 }