Rename localMatrix to uvMatrix for better clarity. (#234)

Co-authored-by: ffjiefan <[email protected]>
Tencent · Sep 20, 2024 · 9437205 · 9437205
1 parent da33896
commit 9437205
Show file tree

Hide file tree

Showing 67 changed files with 212 additions and 206 deletions.
diff --git a/include/tgfx/core/Image.h b/include/tgfx/core/Image.h
@@ -287,9 +287,11 @@ class Image {
   virtual std::shared_ptr<TextureProxy> lockTextureProxy(Context* context,
                                                          uint32_t renderFlags = 0) const;
 
-  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(
-      const FPArgs& args, TileMode tileModeX, TileMode tileModeY, const SamplingOptions& sampling,
-      const Matrix* localMatrix) const = 0;
+  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(const FPArgs& args,
+                                                                 TileMode tileModeX,
+                                                                 TileMode tileModeY,
+                                                                 const SamplingOptions& sampling,
+                                                                 const Matrix* uvMatrix) const = 0;
 
   friend class FragmentProcessor;
   friend class RuntimeImageFilter;

diff --git a/include/tgfx/core/ImageFilter.h b/include/tgfx/core/ImageFilter.h
@@ -114,9 +114,10 @@ class ImageFilter {
    * Returns a FragmentProcessor that applies this filter to the source image. The returned
    * processor is in the coordinate space of the source image.
    */
-  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(
-      std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
-      const Matrix* localMatrix) const = 0;
+  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
+                                                                 const FPArgs& args,
+                                                                 const SamplingOptions& sampling,
+                                                                 const Matrix* uvMatrix) const = 0;
 
   /**
    * Returns true if this filter is a ComposeImageFilter.
@@ -130,7 +131,7 @@ class ImageFilter {
   std::unique_ptr<FragmentProcessor> makeFPFromFilteredImage(std::shared_ptr<Image> source,
                                                              const FPArgs& args,
                                                              const SamplingOptions& sampling,
-                                                             const Matrix* localMatrix) const;
+                                                             const Matrix* uvMatrix) const;
 
   friend class DropShadowImageFilter;
   friend class ComposeImageFilter;

diff --git a/include/tgfx/core/MaskFilter.h b/include/tgfx/core/MaskFilter.h
@@ -38,8 +38,8 @@ class MaskFilter {
   virtual ~MaskFilter() = default;
 
  private:
-  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(
-      const FPArgs& args, const Matrix* localMatrix) const = 0;
+  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(const FPArgs& args,
+                                                                 const Matrix* uvMatrix) const = 0;
 
   friend class RenderContext;
 };

diff --git a/include/tgfx/core/Shader.h b/include/tgfx/core/Shader.h
@@ -135,8 +135,8 @@ class Shader {
  protected:
   std::weak_ptr<Shader> weakThis;
 
-  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(
-      const FPArgs& args, const Matrix* localMatrix) const = 0;
+  virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor(const FPArgs& args,
+                                                                 const Matrix* uvMatrix) const = 0;
 
   friend class FragmentProcessor;
   friend class Canvas;

diff --git a/src/core/ImageFilter.cpp b/src/core/ImageFilter.cpp
@@ -70,11 +70,11 @@ bool ImageFilter::applyCropRect(const Rect& srcRect, Rect* dstRect, const Rect*
 
 std::unique_ptr<FragmentProcessor> ImageFilter::makeFPFromFilteredImage(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
-    const Matrix* localMatrix) const {
+    const Matrix* uvMatrix) const {
   auto inputBounds = Rect::MakeWH(source->width(), source->height());
   auto clipBounds = args.drawRect;
-  if (localMatrix) {
-    clipBounds = localMatrix->mapRect(clipBounds);
+  if (uvMatrix) {
+    clipBounds = uvMatrix->mapRect(clipBounds);
   }
   Rect dstBounds = Rect::MakeEmpty();
   if (!applyCropRect(inputBounds, &dstBounds, &clipBounds)) {
@@ -86,8 +86,8 @@ std::unique_ptr<FragmentProcessor> ImageFilter::makeFPFromFilteredImage(
     return nullptr;
   }
   auto fpMatrix = Matrix::MakeTrans(-dstBounds.x(), -dstBounds.y());
-  if (localMatrix != nullptr) {
-    fpMatrix.preConcat(*localMatrix);
+  if (uvMatrix != nullptr) {
+    fpMatrix.preConcat(*uvMatrix);
   }
   return TextureEffect::Make(std::move(textureProxy), sampling, &fpMatrix);
 }

diff --git a/src/filters/BlurImageFilter.cpp b/src/filters/BlurImageFilter.cpp
@@ -88,15 +88,15 @@ void BlurImageFilter::draw(std::shared_ptr<RenderTargetProxy> renderTarget,
                            const Rect& imageBounds, bool isDown) const {
   auto dstWidth = static_cast<float>(renderTarget->width());
   auto dstHeight = static_cast<float>(renderTarget->height());
-  auto localMatrix =
+  auto uvMatrix =
       Matrix::MakeScale(imageBounds.width() / dstWidth, imageBounds.height() / dstHeight);
-  localMatrix.postTranslate(imageBounds.x(), imageBounds.y());
+  uvMatrix.postTranslate(imageBounds.x(), imageBounds.y());
   auto texelSize = Size::Make(0.5f / imageBounds.width(), 0.5f / imageBounds.height());
   auto blurProcessor =
       DualBlurFragmentProcessor::Make(isDown ? DualBlurPassMode::Down : DualBlurPassMode::Up,
                                       std::move(imageProcessor), blurOffset, texelSize);
   OpContext opContext(std::move(renderTarget), true);
-  opContext.fillWithFP(std::move(blurProcessor), localMatrix);
+  opContext.fillWithFP(std::move(blurProcessor), uvMatrix);
 }
 
 Rect BlurImageFilter::onFilterBounds(const Rect& srcRect) const {
@@ -149,7 +149,7 @@ std::shared_ptr<TextureProxy> BlurImageFilter::onFilterImage(Context* context,
 
 std::unique_ptr<FragmentProcessor> BlurImageFilter::asFragmentProcessor(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
-    const Matrix* localMatrix) const {
-  return makeFPFromFilteredImage(source, args, sampling, localMatrix);
+    const Matrix* uvMatrix) const {
+  return makeFPFromFilteredImage(source, args, sampling, uvMatrix);
 }
 }  // namespace tgfx
diff --git a/src/filters/BlurImageFilter.h b/src/filters/BlurImageFilter.h
@@ -36,7 +36,7 @@ class BlurImageFilter : public ImageFilter {
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,
                                                          const SamplingOptions& sampling,
-                                                         const Matrix* localMatrix) const override;
+                                                         const Matrix* uvMatrix) const override;
 
   void draw(std::shared_ptr<RenderTargetProxy> renderTarget,
             std::unique_ptr<FragmentProcessor> imageProcessor, const Rect& imageBounds,

diff --git a/src/filters/ComposeImageFilter.cpp b/src/filters/ComposeImageFilter.cpp
@@ -73,11 +73,11 @@ Rect ComposeImageFilter::onFilterBounds(const Rect& srcRect) const {
 
 std::unique_ptr<FragmentProcessor> ComposeImageFilter::asFragmentProcessor(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
-    const Matrix* localMatrix) const {
+    const Matrix* uvMatrix) const {
   auto bounds = Rect::MakeWH(source->width(), source->height());
   auto drawBounds = args.drawRect;
-  if (localMatrix) {
-    drawBounds = localMatrix->mapRect(drawBounds);
+  if (uvMatrix) {
+    drawBounds = uvMatrix->mapRect(drawBounds);
   }
   bool hasMipmaps = source->hasMipmaps() && sampling.mipmapMode != MipmapMode::None;
   auto count = filters.size() - 1;
@@ -98,8 +98,8 @@ std::unique_ptr<FragmentProcessor> ComposeImageFilter::asFragmentProcessor(
     lastOffset.offset(bounds.x(), bounds.y());
   }
   auto matrix = Matrix::MakeTrans(-lastOffset.x, -lastOffset.y);
-  if (localMatrix) {
-    matrix.preConcat(*localMatrix);
+  if (uvMatrix) {
+    matrix.preConcat(*uvMatrix);
   }
   return filters.back()->asFragmentProcessor(std::move(lastSource), args, sampling, &matrix);
 }

diff --git a/src/filters/ComposeImageFilter.h b/src/filters/ComposeImageFilter.h
@@ -33,7 +33,7 @@ class ComposeImageFilter : public ImageFilter {
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,
                                                          const SamplingOptions& sampling,
-                                                         const Matrix* localMatrix) const override;
+                                                         const Matrix* uvMatrix) const override;
 
   bool isComposeFilter() const override {
     return true;

diff --git a/src/filters/DropShadowImageFilter.cpp b/src/filters/DropShadowImageFilter.cpp
@@ -55,13 +55,13 @@ 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* localMatrix) const {
+    const Matrix* uvMatrix) const {
   // Request a rasterized image, does nothing if the source is not already rasterized.
   source = source->makeRasterized();
   std::unique_ptr<FragmentProcessor> shadowProcessor;
   auto shadowMatrix = Matrix::MakeTrans(-dx, -dy);
-  if (localMatrix != nullptr) {
-    shadowMatrix.preConcat(*localMatrix);
+  if (uvMatrix != nullptr) {
+    shadowMatrix.preConcat(*uvMatrix);
   }
   if (blurFilter != nullptr) {
     shadowProcessor = blurFilter->asFragmentProcessor(source, args, sampling, &shadowMatrix);
@@ -79,7 +79,7 @@ std::unique_ptr<FragmentProcessor> DropShadowImageFilter::asFragmentProcessor(
     return colorShadowProcessor;
   }
   auto imageProcessor = FragmentProcessor::Make(std::move(source), args, TileMode::Decal,
-                                                TileMode::Decal, sampling, localMatrix);
+                                                TileMode::Decal, sampling, uvMatrix);
   return XfermodeFragmentProcessor::MakeFromTwoProcessors(
       std::move(imageProcessor), std::move(colorShadowProcessor), BlendMode::SrcOver);
 }

diff --git a/src/filters/DropShadowImageFilter.h b/src/filters/DropShadowImageFilter.h
@@ -38,6 +38,6 @@ class DropShadowImageFilter : public ImageFilter {
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,
                                                          const SamplingOptions& sampling,
-                                                         const Matrix* localMatrix) const override;
+                                                         const Matrix* uvMatrix) const override;
 };
 }  // namespace tgfx
diff --git a/src/filters/RuntimeImageFilter.cpp b/src/filters/RuntimeImageFilter.cpp
@@ -58,7 +58,7 @@ std::shared_ptr<TextureProxy> RuntimeImageFilter::onFilterImage(Context* context
 
 std::unique_ptr<FragmentProcessor> RuntimeImageFilter::asFragmentProcessor(
     std::shared_ptr<Image> source, const FPArgs& args, const SamplingOptions& sampling,
-    const Matrix* localMatrix) const {
-  return makeFPFromFilteredImage(source, args, sampling, localMatrix);
+    const Matrix* uvMatrix) const {
+  return makeFPFromFilteredImage(source, args, sampling, uvMatrix);
 }
 }  // namespace tgfx
diff --git a/src/filters/RuntimeImageFilter.h b/src/filters/RuntimeImageFilter.h
@@ -36,7 +36,7 @@ class RuntimeImageFilter : public ImageFilter {
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(std::shared_ptr<Image> source,
                                                          const FPArgs& args,
                                                          const SamplingOptions& sampling,
-                                                         const Matrix* localMatrix) const override;
+                                                         const Matrix* uvMatrix) const override;
 
  private:
   std::shared_ptr<RuntimeEffect> effect = nullptr;

diff --git a/src/filters/ShaderMaskFilter.cpp b/src/filters/ShaderMaskFilter.cpp
@@ -28,8 +28,8 @@ std::shared_ptr<MaskFilter> MaskFilter::MakeShader(std::shared_ptr<Shader> shade
 }
 
 std::unique_ptr<FragmentProcessor> ShaderMaskFilter::asFragmentProcessor(
-    const FPArgs& args, const Matrix* localMatrix) const {
-  auto processor = FragmentProcessor::Make(shader, args, localMatrix);
+    const FPArgs& args, const Matrix* uvMatrix) const {
+  auto processor = FragmentProcessor::Make(shader, args, uvMatrix);
   return FragmentProcessor::MulInputByChildAlpha(std::move(processor), inverted);
 }
 }  // namespace tgfx
diff --git a/src/filters/ShaderMaskFilter.h b/src/filters/ShaderMaskFilter.h
@@ -30,7 +30,7 @@ class ShaderMaskFilter : public MaskFilter {
 
  protected:
   std::unique_ptr<FragmentProcessor> asFragmentProcessor(const FPArgs& args,
-                                                         const Matrix* localMatrix) const override;
+                                                         const Matrix* uvMatrix) const override;
 
  private:
   std::shared_ptr<Shader> shader;

diff --git a/src/gpu/OpContext.cpp b/src/gpu/OpContext.cpp
@@ -28,21 +28,21 @@ OpContext::~OpContext() {
   }
 }
 
-void OpContext::fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& localMatrix) {
+void OpContext::fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& uvMatrix) {
   fillRectWithFP(Rect::MakeWH(renderTargetProxy->width(), renderTargetProxy->height()),
-                 std::move(fp), localMatrix);
+                 std::move(fp), uvMatrix);
   if (autoResolve) {
     auto drawingManager = renderTargetProxy->getContext()->drawingManager();
     drawingManager->addTextureResolveTask(renderTargetProxy);
   }
 }
 
 void OpContext::fillRectWithFP(const Rect& dstRect, std::unique_ptr<FragmentProcessor> fp,
-                               const Matrix& localMatrix) {
+                               const Matrix& uvMatrix) {
   if (fp == nullptr) {
     return;
   }
-  auto op = FillRectOp::Make(std::nullopt, dstRect, Matrix::I(), &localMatrix);
+  auto op = FillRectOp::Make(std::nullopt, dstRect, Matrix::I(), &uvMatrix);
   op->addColorFP(std::move(fp));
   op->setBlendMode(BlendMode::Src);
   addOp(std::move(op));

diff --git a/src/gpu/OpContext.h b/src/gpu/OpContext.h
@@ -41,10 +41,10 @@ class OpContext {
     return renderTargetProxy.get();
   }
 
-  void fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& localMatrix);
+  void fillWithFP(std::unique_ptr<FragmentProcessor> fp, const Matrix& uvMatrix);
 
   void fillRectWithFP(const Rect& dstRect, std::unique_ptr<FragmentProcessor> fp,
-                      const Matrix& localMatrix);
+                      const Matrix& uvMatrix);
 
   void addOp(std::unique_ptr<Op> op);
 

diff --git a/src/gpu/RenderContext.cpp b/src/gpu/RenderContext.cpp
@@ -184,12 +184,12 @@ void RenderContext::drawPath(const Path& path, const MCState& state, const FillS
 }
 
 static std::unique_ptr<FragmentProcessor> CreateMaskFP(std::shared_ptr<TextureProxy> textureProxy,
-                                                       const Matrix* localMatrix = nullptr) {
+                                                       const Matrix* uvMatrix = nullptr) {
   if (textureProxy == nullptr) {
     return nullptr;
   }
   auto isAlphaOnly = textureProxy->isAlphaOnly();
-  auto processor = TextureEffect::Make(std::move(textureProxy), {}, localMatrix);
+  auto processor = TextureEffect::Make(std::move(textureProxy), {}, uvMatrix);
   if (processor == nullptr) {
     return nullptr;
   }
@@ -449,9 +449,9 @@ std::unique_ptr<FragmentProcessor> RenderContext::getClipMask(const Path& clip,
   if (texture == nullptr) {
     return nullptr;
   }
-  auto localMatrix = viewMatrix;
-  localMatrix.postTranslate(-clipBounds.left, -clipBounds.top);
-  auto maskEffect = TextureEffect::Make(texture, {}, &localMatrix);
+  auto uvMatrix = viewMatrix;
+  uvMatrix.postTranslate(-clipBounds.left, -clipBounds.top);
+  auto maskEffect = TextureEffect::Make(texture, {}, &uvMatrix);
   if (!texture->isAlphaOnly()) {
     maskEffect = FragmentProcessor::MulInputByChildAlpha(std::move(maskEffect));
   }

diff --git a/src/gpu/ops/FillRectOp.cpp b/src/gpu/ops/FillRectOp.cpp
@@ -28,15 +28,15 @@ namespace tgfx {
 class RectPaint {
  public:
   RectPaint(std::optional<Color> color, const Rect& rect, const Matrix& viewMatrix,
-            const Matrix* localMatrix)
+            const Matrix* uvMatrix)
       : color(color.value_or(Color::White())), rect(rect), viewMatrix(viewMatrix),
-        localMatrix(localMatrix ? *localMatrix : Matrix::I()) {
+        uvMatrix(uvMatrix ? *uvMatrix : Matrix::I()) {
   }
 
   Color color;
   Rect rect;
   Matrix viewMatrix;
-  Matrix localMatrix;
+  Matrix uvMatrix;
 };
 
 class RectCoverageVerticesProvider : public DataProvider {
@@ -53,7 +53,7 @@ class RectCoverageVerticesProvider : public DataProvider {
     for (auto& rectPaint : rectPaints) {
       auto& viewMatrix = rectPaint->viewMatrix;
       auto& rect = rectPaint->rect;
-      auto& localMatrix = rectPaint->localMatrix;
+      auto& uvMatrix = rectPaint->uvMatrix;
       auto scale = sqrtf(viewMatrix.getScaleX() * viewMatrix.getScaleX() +
                          viewMatrix.getSkewY() * viewMatrix.getSkewY());
       // we want the new edge to be .5px away from the old line.
@@ -63,8 +63,8 @@ class RectCoverageVerticesProvider : public DataProvider {
       auto outsetBounds = rect.makeOutset(padding, padding);
       auto outsetQuad = Quad::MakeFromRect(outsetBounds, viewMatrix);
 
-      auto normalInsetQuad = Quad::MakeFromRect(insetBounds, localMatrix);
-      auto normalOutsetQuad = Quad::MakeFromRect(outsetBounds, localMatrix);
+      auto normalInsetQuad = Quad::MakeFromRect(insetBounds, uvMatrix);
+      auto normalOutsetQuad = Quad::MakeFromRect(outsetBounds, uvMatrix);
 
       for (int j = 0; j < 2; ++j) {
         const auto& quad = j == 0 ? insetQuad : outsetQuad;
@@ -108,9 +108,9 @@ class RectNonCoverageVerticesProvider : public DataProvider {
     for (auto& rectPaint : rectPaints) {
       auto& viewMatrix = rectPaint->viewMatrix;
       auto& rect = rectPaint->rect;
-      auto& localMatrix = rectPaint->localMatrix;
+      auto& uvMatrix = rectPaint->uvMatrix;
       auto quad = Quad::MakeFromRect(rect, viewMatrix);
-      auto localQuad = Quad::MakeFromRect(rect, localMatrix);
+      auto localQuad = Quad::MakeFromRect(rect, uvMatrix);
       for (size_t j = 4; j >= 1; --j) {
         vertices[index++] = quad.point(j - 1).x;
         vertices[index++] = quad.point(j - 1).y;
@@ -134,14 +134,14 @@ class RectNonCoverageVerticesProvider : public DataProvider {
 };
 
 std::unique_ptr<FillRectOp> FillRectOp::Make(std::optional<Color> color, const Rect& rect,
-                                             const Matrix& viewMatrix, const Matrix* localMatrix) {
-  return std::unique_ptr<FillRectOp>(new FillRectOp(color, rect, viewMatrix, localMatrix));
+                                             const Matrix& viewMatrix, const Matrix* uvMatrix) {
+  return std::unique_ptr<FillRectOp>(new FillRectOp(color, rect, viewMatrix, uvMatrix));
 }
 
 FillRectOp::FillRectOp(std::optional<Color> color, const Rect& rect, const Matrix& viewMatrix,
-                       const Matrix* localMatrix)
+                       const Matrix* uvMatrix)
     : DrawOp(ClassID()), hasColor(color) {
-  auto rectPaint = std::make_shared<RectPaint>(color, rect, viewMatrix, localMatrix);
+  auto rectPaint = std::make_shared<RectPaint>(color, rect, viewMatrix, uvMatrix);
   rectPaints.push_back(std::move(rectPaint));
   auto bounds = viewMatrix.mapRect(rect);
   setBounds(bounds);

diff --git a/src/gpu/ops/FillRectOp.h b/src/gpu/ops/FillRectOp.h
@@ -30,15 +30,15 @@ class FillRectOp : public DrawOp {
 
   static std::unique_ptr<FillRectOp> Make(std::optional<Color> color, const Rect& rect,
                                           const Matrix& viewMatrix,
-                                          const Matrix* localMatrix = nullptr);
+                                          const Matrix* uvMatrix = nullptr);
 
   void prepare(Context* context) override;
 
   void execute(RenderPass* renderPass) override;
 
  private:
   FillRectOp(std::optional<Color> color, const Rect& rect, const Matrix& viewMatrix,
-             const Matrix* localMatrix = nullptr);
+             const Matrix* uvMatrix = nullptr);
 
   bool onCombineIfPossible(Op* op) override;