Allow ScaleImage to create its own texture cache and remove unnecessary sampling parameters.

include/tgfx/core/Image.h

@@ -209,8 +209,7 @@ class Image {
   /**
    * Returns true if the Image is guaranteed to produce a single-plane texture without extra
    * transforms and can be cached for repeat drawing. Extra transforms may include orientation,
-   * scale, subsets, filters, or RGBAAA layouts. A YUV Image is also not flat since it has multiple
-   * planes.
+   * subsets, filters, or RGBAAA layouts. A YUV Image is also not flat since it has multiple planes.
    */
   virtual bool isFlat() const = 0;
 
@@ -225,25 +224,19 @@ class Image {
    * its own GPU cache but uses the full resolution cache created by the original Image. If you want
    * the subset Image to create its own GPU cache, you should call makeFlattened() on the subset
    * Image.
-   * @param mipmapped Specifies whether the flattened Image should have mipmaps. Ignored if the
-   * Image is already flat.
-   * @param sampling The sampling options may be applied if the image has scaling transforms.
-   * Ignored if the Image is already flat.
    * @return If the Image is already flat, the original Image is returned.
    */
-  std::shared_ptr<Image> makeFlattened(bool mipmapped = false,
-                                       const SamplingOptions& sampling = {}) const;
+  std::shared_ptr<Image> makeFlattened() const;
 
   /**
    * Returns an Image backed by a GPU texture associated with the given context. If a corresponding
    * texture cache exists in the context, it returns an Image that wraps that texture. Otherwise, it
-   * creates one immediately, applying the sampling options if the image is scaled. If the Image is
-   * already texture-backed and the context is compatible with the GPU texture, it returns the
-   * original Image. Otherwise, it returns nullptr. It's safe to release the original Image to
-   * reduce CPU memory usage, as the returned Image holds a strong reference to the texture cache.
+   * creates one immediately. If the Image is already texture-backed and the context is compatible
+   * with the GPU texture, it returns the original Image. Otherwise, it returns nullptr. It's safe
+   * to release the original Image to reduce CPU memory usage, as the returned Image holds a strong
+   * reference to the texture cache.
    */
-  virtual std::shared_ptr<Image> makeTextureImage(Context* context,
-                                                  const SamplingOptions& sampling = {}) const;
+  virtual std::shared_ptr<Image> makeTextureImage(Context* context) const;
 
   /**
    * Retrieves the backend texture of the Image. Returns an invalid BackendTexture if the Image is
@@ -281,11 +274,18 @@ class Image {
   std::shared_ptr<Image> makeOriented(Orientation orientation) const;
 
   /**
-   * Returns an Image with the specified scale. The returned Image always shares pixels and caches
-   * with the original Image. If both scaleX and scaleY are 1.0, the original Image is returned.
-   * If scaleX or scaleY is less than zero, nullptr is returned.
+   * Returns an Image scaled by the given factor. The scaled Image will have its own GPU cache at
+   * the new resolution and will not have mipmaps, even if the original Image does. You can call
+   * makeMipmapped() on the scaled Image to enable mipmaps. If the scale is greater than 1.0, it
+   * may result in blurring. Note that calling makeScaled() on an already scaled Image may return
+   * its internal non-scaled Image if the multiplied scale is 1.0.
+   * @param scale The factor to scale the Image by.
+   * @param sampling The sampling options to use when scaling the Image.
+   * @return The scaled Image. If the scale is 1.0, the original Image is returned. If the scale is
+   * less than 0, nullptr is returned.
    */
-  std::shared_ptr<Image> makeScaled(float scaleX, float scaleY) const;
+  virtual std::shared_ptr<Image> makeScaled(float scale,
+                                            const SamplingOptions& sampling = {}) const;
 
   /**
    * Returns a filtered Image with the specified filter. The filter has the potential to alter the
@@ -321,19 +321,14 @@ class Image {
 
   virtual std::shared_ptr<Image> onMakeOriented(Orientation orientation) const;
 
-  virtual std::shared_ptr<Image> onMakeScaled(float scaleX, float scaleY) const;
-
   virtual std::shared_ptr<Image> onMakeWithFilter(std::shared_ptr<ImageFilter> filter,
                                                   Point* offset, const Rect* clipRect) const;
 
   /**
    * Returns a texture proxy for the entire Image.
    * @param args The TPArgs used to create the texture proxy.
-   * @param sampling The sampling options applied when rasterizing the Image. This option
-   * may be ignored if the Image has no scaling transforms.
    */
-  virtual std::shared_ptr<TextureProxy> lockTextureProxy(const TPArgs& args,
-                                                         const SamplingOptions& sampling) const;
+  virtual std::shared_ptr<TextureProxy> lockTextureProxy(const TPArgs& args) const;
 
   /**
    * Returns a fragment processor for the entire Image.
@@ -354,6 +349,7 @@ class Image {
   friend class TransformImage;
   friend class RGBAAAImage;
   friend class FlattenImage;
+  friend class ScaleImage;
   friend class ImageShader;
 };
 }  // namespace tgfx

include/tgfx/core/ImageFilter.h

@@ -137,11 +137,10 @@ class ImageFilter {
    * @param source The source image.
    * @param clipBounds The clip bounds of the filtered image, relative to the source image.
    * @param args The arguments for creating the texture proxy.
-   * @param sampling The sampling options used for sampling the source image.
    */
   virtual std::shared_ptr<TextureProxy> lockTextureProxy(std::shared_ptr<Image> source,
-                                                         const Rect& clipBounds, const TPArgs& args,
-                                                         const SamplingOptions& sampling) const;
+                                                         const Rect& clipBounds,
+                                                         const TPArgs& args) const;
 
   /**
    * Returns a FragmentProcessor that applies this filter to the source image. The returned

src/core/ImageFilter.cpp

@@ -38,8 +38,7 @@ Rect ImageFilter::onFilterBounds(const Rect& srcRect) const {
 
 std::shared_ptr<TextureProxy> ImageFilter::lockTextureProxy(std::shared_ptr<Image> source,
                                                             const Rect& clipBounds,
-                                                            const TPArgs& args,
-                                                            const SamplingOptions& sampling) const {
+                                                            const TPArgs& args) const {
   auto renderTarget = RenderTargetProxy::MakeFallback(
       args.context, static_cast<int>(clipBounds.width()), static_cast<int>(clipBounds.height()),
       source->isAlphaOnly(), 1, args.mipmapped);
@@ -49,7 +48,8 @@ std::shared_ptr<TextureProxy> ImageFilter::lockTextureProxy(std::shared_ptr<Imag
   auto drawRect = Rect::MakeWH(renderTarget->width(), renderTarget->height());
   FPArgs fpArgs(args.context, args.renderFlags, drawRect, Matrix::I());
   auto offsetMatrix = Matrix::MakeTrans(clipBounds.x(), clipBounds.y());
-  auto processor = asFragmentProcessor(std::move(source), fpArgs, sampling, &offsetMatrix);
+  // There is no scaling for the source image, so we can use the default sampling options.
+  auto processor = asFragmentProcessor(std::move(source), fpArgs, {}, &offsetMatrix);
   if (!processor) {
     return nullptr;
   }
@@ -84,7 +84,7 @@ std::unique_ptr<FragmentProcessor> ImageFilter::makeFPFromTextureProxy(
   auto isAlphaOnly = source->isAlphaOnly();
   auto mipmapped = source->hasMipmaps() && NeedMipmaps(sampling, args.viewMatrix, uvMatrix);
   TPArgs tpArgs(args.context, args.renderFlags, mipmapped);
-  auto textureProxy = lockTextureProxy(std::move(source), dstBounds, tpArgs, sampling);
+  auto textureProxy = lockTextureProxy(std::move(source), dstBounds, tpArgs);
   if (textureProxy == nullptr) {
     return nullptr;
   }

src/core/filters/BlurImageFilter.cpp

@@ -105,9 +105,9 @@ Rect BlurImageFilter::onFilterBounds(const Rect& srcRect) const {
   return srcRect.makeOutset(blurOffset.x * mul, blurOffset.y * mul);
 }
 
-std::shared_ptr<TextureProxy> BlurImageFilter::lockTextureProxy(
-    std::shared_ptr<Image> source, const Rect& clipBounds, const TPArgs& args,
-    const SamplingOptions& sampling) const {
+std::shared_ptr<TextureProxy> BlurImageFilter::lockTextureProxy(std::shared_ptr<Image> source,
+                                                                const Rect& clipBounds,
+                                                                const TPArgs& args) const {
   auto isAlphaOnly = source->isAlphaOnly();
   auto lastRenderTarget = RenderTargetProxy::MakeFallback(
       args.context, static_cast<int>(clipBounds.width()), static_cast<int>(clipBounds.height()),
@@ -117,7 +117,7 @@ std::shared_ptr<TextureProxy> BlurImageFilter::lockTextureProxy(
   }
   auto drawRect = Rect::MakeWH(lastRenderTarget->width(), lastRenderTarget->height());
   FPArgs fpArgs(args.context, args.renderFlags, drawRect, Matrix::I());
-  auto processor = FragmentProcessor::Make(source, fpArgs, tileMode, tileMode, sampling);
+  auto processor = FragmentProcessor::Make(source, fpArgs, tileMode, tileMode, {});
   auto imageBounds = clipBounds;
   std::vector<std::shared_ptr<RenderTargetProxy>> renderTargets = {};
   for (int i = 0; i < iteration; ++i) {

src/core/filters/BlurImageFilter.h

@@ -30,8 +30,8 @@ class BlurImageFilter : public ImageFilter {
   Rect onFilterBounds(const Rect& srcRect) const override;
 
   std::shared_ptr<TextureProxy> lockTextureProxy(std::shared_ptr<Image> source,
-                                                 const Rect& clipBounds, const TPArgs& args,
-                                                 const SamplingOptions& sampling) const override;
+                                                 const Rect& clipBounds,
+                                                 const TPArgs& args) const override;
 
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,

src/core/filters/DropShadowImageFilter.cpp

@@ -59,10 +59,7 @@ Rect DropShadowImageFilter::onFilterBounds(const Rect& srcRect) const {
 std::unique_ptr<FragmentProcessor> DropShadowImageFilter::asFragmentProcessor(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
     const Matrix* uvMatrix) const {
-  if (!source->isFlat()) {
-    auto needMipmaps = NeedMipmaps(sampling, args.viewMatrix, uvMatrix);
-    source = source->makeFlattened(needMipmaps, sampling);
-  }
+  source = source->makeFlattened();
   std::unique_ptr<FragmentProcessor> shadowProcessor;
   auto shadowMatrix = Matrix::MakeTrans(-dx, -dy);
   if (uvMatrix != nullptr) {

src/core/filters/InnerShadowImageFilter.cpp

@@ -45,11 +45,7 @@ InnerShadowImageFilter::InnerShadowImageFilter(float dx, float dy, float blurrin
 std::unique_ptr<FragmentProcessor> InnerShadowImageFilter::asFragmentProcessor(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
     const Matrix* uvMatrix) const {
-  if (!source->isFlat()) {
-    auto needMipmaps = NeedMipmaps(sampling, args.viewMatrix, uvMatrix);
-    source = source->makeFlattened(needMipmaps, sampling);
-  }
-
+  source = source->makeFlattened();
   // get inverted shadow mask
   auto shadowMatrix = Matrix::MakeTrans(-dx, -dy);
   if (uvMatrix != nullptr) {

src/core/filters/RuntimeImageFilter.cpp

@@ -35,9 +35,9 @@ Rect RuntimeImageFilter::onFilterBounds(const Rect& srcRect) const {
   return effect->filterBounds(srcRect);
 }
 
-std::shared_ptr<TextureProxy> RuntimeImageFilter::lockTextureProxy(
-    std::shared_ptr<Image> source, const Rect& clipBounds, const TPArgs& args,
-    const SamplingOptions& sampling) const {
+std::shared_ptr<TextureProxy> RuntimeImageFilter::lockTextureProxy(std::shared_ptr<Image> source,
+                                                                   const Rect& clipBounds,
+                                                                   const TPArgs& args) const {
   auto renderTarget = RenderTargetProxy::MakeFallback(
       args.context, static_cast<int>(clipBounds.width()), static_cast<int>(clipBounds.height()),
       source->isAlphaOnly(), effect->sampleCount(), args.mipmapped);
@@ -49,7 +49,7 @@ std::shared_ptr<TextureProxy> RuntimeImageFilter::lockTextureProxy(
   // Request a texture proxy from the source image without mipmaps to save memory.
   // It may be ignored if the source image has preset mipmaps.
   TPArgs tpArgs(args.context, args.renderFlags, false);
-  auto textureProxy = source->lockTextureProxy(tpArgs, sampling);
+  auto textureProxy = source->lockTextureProxy(tpArgs);
   if (textureProxy == nullptr) {
     return nullptr;
   }
@@ -60,7 +60,7 @@ std::shared_ptr<TextureProxy> RuntimeImageFilter::lockTextureProxy(
       LOGE("RuntimeImageFilter::lockTextureProxy() extraInput %d is nullptr", i);
       return nullptr;
     }
-    textureProxy = input->lockTextureProxy(tpArgs, sampling);
+    textureProxy = input->lockTextureProxy(tpArgs);
     if (textureProxy == nullptr) {
       return nullptr;
     }

src/core/filters/RuntimeImageFilter.h

@@ -30,8 +30,8 @@ class RuntimeImageFilter : public ImageFilter {
   Rect onFilterBounds(const Rect& srcRect) const override;
 
   std::shared_ptr<TextureProxy> lockTextureProxy(std::shared_ptr<Image> source,
-                                                 const Rect& clipBounds, const TPArgs& args,
-                                                 const SamplingOptions& sampling) const override;
+                                                 const Rect& clipBounds,
+                                                 const TPArgs& args) const override;
 
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,

src/core/images/BufferImage.cpp

@@ -21,6 +21,7 @@
 
 namespace tgfx {
 std::shared_ptr<Image> Image::MakeFrom(std::shared_ptr<ImageBuffer> buffer) {
+  TRACE_EVENT;
   if (buffer == nullptr) {
     return nullptr;
   }
@@ -34,6 +35,7 @@ BufferImage::BufferImage(UniqueKey uniqueKey, std::shared_ptr<ImageBuffer> buffe
 }
 
 std::shared_ptr<TextureProxy> BufferImage::onLockTextureProxy(const TPArgs& args) const {
+  TRACE_EVENT;
   return args.context->proxyProvider()->createTextureProxy(args.uniqueKey, imageBuffer,
                                                            args.mipmapped, args.renderFlags);
 }

src/core/images/DecoderImage.cpp

@@ -23,6 +23,7 @@
 namespace tgfx {
 std::shared_ptr<Image> DecoderImage::MakeFrom(UniqueKey uniqueKey,
                                               std::shared_ptr<ImageDecoder> decoder) {
+  TRACE_EVENT;
   if (decoder == nullptr) {
     return nullptr;
   }
@@ -37,6 +38,7 @@ DecoderImage::DecoderImage(UniqueKey uniqueKey, std::shared_ptr<ImageDecoder> de
 }
 
 std::shared_ptr<TextureProxy> DecoderImage::onLockTextureProxy(const TPArgs& args) const {
+  TRACE_EVENT;
   return args.context->proxyProvider()->createTextureProxy(args.uniqueKey, decoder, args.mipmapped,
                                                            args.renderFlags);
 }

src/core/images/FilterImage.cpp

@@ -27,6 +27,7 @@ namespace tgfx {
 std::shared_ptr<Image> FilterImage::MakeFrom(std::shared_ptr<Image> source,
                                              std::shared_ptr<ImageFilter> filter, Point* offset,
                                              const Rect* clipRect) {
+  TRACE_EVENT;
   if (source == nullptr) {
     return nullptr;
   }
@@ -72,13 +73,15 @@ std::shared_ptr<Image> FilterImage::onCloneWith(std::shared_ptr<Image> newSource
 }
 
 std::shared_ptr<Image> FilterImage::onMakeSubset(const Rect& subset) const {
+  TRACE_EVENT;
   auto newBounds = subset;
   newBounds.offset(bounds.x(), bounds.y());
   return FilterImage::Wrap(source, newBounds, filter);
 }
 
 std::shared_ptr<Image> FilterImage::onMakeWithFilter(std::shared_ptr<ImageFilter> imageFilter,
                                                      Point* offset, const Rect* clipRect) const {
+  TRACE_EVENT;
   if (imageFilter == nullptr) {
     return nullptr;
   }
@@ -111,18 +114,19 @@ std::shared_ptr<Image> FilterImage::onMakeWithFilter(std::shared_ptr<ImageFilter
   return FilterImage::Wrap(source, filterBounds, std::move(composeFilter));
 }
 
-std::shared_ptr<TextureProxy> FilterImage::lockTextureProxy(const TPArgs& args,
-                                                            const SamplingOptions& sampling) const {
+std::shared_ptr<TextureProxy> FilterImage::lockTextureProxy(const TPArgs& args) const {
+  TRACE_EVENT;
   auto inputBounds = Rect::MakeWH(source->width(), source->height());
   auto filterBounds = filter->filterBounds(inputBounds);
-  return filter->lockTextureProxy(source, filterBounds, args, sampling);
+  return filter->lockTextureProxy(source, filterBounds, args);
 }
 
 std::unique_ptr<FragmentProcessor> FilterImage::asFragmentProcessor(const FPArgs& args,
                                                                     TileMode tileModeX,
                                                                     TileMode tileModeY,
                                                                     const SamplingOptions& sampling,
                                                                     const Matrix* uvMatrix) const {
+  TRACE_EVENT;
   auto fpMatrix = concatUVMatrix(uvMatrix);
   auto inputBounds = Rect::MakeWH(source->width(), source->height());
   auto drawBounds = args.drawRect;
@@ -143,7 +147,7 @@ std::unique_ptr<FragmentProcessor> FilterImage::asFragmentProcessor(const FPArgs
   auto mipmapped =
       source->hasMipmaps() && NeedMipmaps(sampling, args.viewMatrix, AddressOf(fpMatrix));
   TPArgs tpArgs(args.context, args.renderFlags, mipmapped);
-  auto textureProxy = filter->lockTextureProxy(source, dstBounds, tpArgs, sampling);
+  auto textureProxy = filter->lockTextureProxy(source, dstBounds, tpArgs);
   if (textureProxy == nullptr) {
     return nullptr;
   }

src/core/images/FilterImage.h

@@ -47,10 +47,6 @@ class FilterImage : public SubsetImage {
     return false;
   }
 
-  bool isFlat() const override {
-    return false;
-  }
-
  protected:
   FilterImage(std::shared_ptr<Image> source, const Rect& bounds,
               std::shared_ptr<ImageFilter> filter);
@@ -62,8 +58,7 @@ class FilterImage : public SubsetImage {
   std::shared_ptr<Image> onMakeWithFilter(std::shared_ptr<ImageFilter> filter, Point* offset,
                                           const Rect* clipRect) const override;
 
-  std::shared_ptr<TextureProxy> lockTextureProxy(const TPArgs& args,
-                                                 const SamplingOptions& sampling) const override;
+  std::shared_ptr<TextureProxy> lockTextureProxy(const TPArgs& args) const override;
 
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(const FPArgs& args, TileMode tileModeX,
                                                          TileMode tileModeY,