SVG export module, converting drawing commands to SVG text

CMakeLists.txt

@@ -56,6 +56,10 @@ if (MACOS AND CLION_IDE AND NOT HasParent)
     option(TGFX_BUILD_TESTS "Build tgfx tests" ON)
 endif ()
 
+if (TGFX_BUILD_SVG)
+    set(TGFX_USE_PNG_ENCODE ON)
+endif ()
+
 if (TGFX_BUILD_TESTS)
     set(TGFX_USE_FREETYPE ON)
     set(TGFX_BUILD_DRAWERS ON)
@@ -204,6 +208,11 @@ if (TGFX_USE_ZLIB)
     list(APPEND TGFX_STATIC_VENDORS zlib)
 endif ()
 
+if (TGFX_BUILD_SVG)
+    # SVG and PDF exports require glyphs to be convertible back to Unicode.
+    list(APPEND TGFX_DEFINES TGFX_USE_GLYPH_TO_UNICODE)
+endif ()
+
 if (TGFX_USE_FREETYPE)
     list(APPEND TGFX_DEFINES TGFX_USE_FREETYPE)
     list(APPEND TGFX_STATIC_VENDORS freetype)

include/tgfx/core/Canvas.h

@@ -27,6 +27,7 @@
 #include "tgfx/core/SamplingOptions.h"
 #include "tgfx/core/Shape.h"
 #include "tgfx/core/TextBlob.h"
+#include "tgfx/svg/SVGExporter.h"
 
 namespace tgfx {
 class Surface;
@@ -430,5 +431,6 @@ class Canvas {
   friend class Surface;
   friend class Picture;
   friend class Recorder;
+  friend class SVGExporter;
 };
 }  // namespace tgfx

include/tgfx/core/ColorFilter.h

@@ -91,12 +91,21 @@ class ColorFilter {
     return false;
   }
 
+ protected:
+  enum class Type { Blend, Matrix, AlphaThreshold, Compose };
+
+  /**
+   * Returns the type of this color filter.
+   */
+  virtual Type type() const = 0;
+
  private:
   virtual std::unique_ptr<FragmentProcessor> asFragmentProcessor() const = 0;
 
   friend class RenderContext;
   friend class ColorFilterShader;
   friend class ComposeColorFilter;
   friend class ColorImageFilter;
+  friend class ColorFilterCaster;
 };
 }  // namespace tgfx

include/tgfx/core/ImageFilter.h

@@ -169,5 +169,6 @@ class ImageFilter {
   friend class InnerShadowImageFilter;
   friend class ComposeImageFilter;
   friend class FilterImage;
+  friend class ImageFilterCaster;
 };
 }  // namespace tgfx

include/tgfx/core/Picture.h

@@ -25,6 +25,7 @@ namespace tgfx {
 class Record;
 class Canvas;
 class DrawContext;
+class SVGExportingContext;
 class MCState;
 class Image;
 
@@ -64,6 +65,7 @@ class Picture {
   friend class MeasureContext;
   friend class RenderContext;
   friend class RecordingContext;
+  friend class SVGExportingContext;
   friend class Image;
   friend class PictureImage;
   friend class Canvas;

include/tgfx/core/Shader.h

@@ -151,5 +151,6 @@ class Shader {
 
   friend class FragmentProcessor;
   friend class Canvas;
+  friend class ShaderCaster;
 };
 }  // namespace tgfx

include/tgfx/core/Typeface.h

@@ -20,6 +20,7 @@
 
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 #include "tgfx/core/Data.h"
 
 namespace tgfx {
@@ -131,11 +132,19 @@ class Typeface {
   virtual std::shared_ptr<Data> copyTableData(FontTableTag tag) const = 0;
 
  protected:
+  /**
+   * Gets the mapping from GlyphID to unicode. The array index is GlyphID, and the array value is
+   * unicode. The array length is glyphsCount(). 
+   * This method is only implemented when compiling the SVG or PDF export module.
+   */
+  virtual std::vector<Unichar> getGlyphToUnicodeMap() const;
+
   mutable std::mutex locker = {};
 
  private:
   std::unordered_map<float, std::weak_ptr<ScalerContext>> scalerContexts = {};
 
   friend class ScalerContext;
+  friend class GlyphConverter;
 };
 }  // namespace tgfx

include/tgfx/svg/SVGExporter.h

@@ -0,0 +1,125 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2024 THL A29 Limited, a Tencent company. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  unless required by applicable law or agreed to in writing, software distributed under the
+//  license is distributed on an "as is" basis, without warranties or conditions of any kind,
+//  either express or implied. see the license for the specific language governing permissions
+//  and limitations under the license.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <memory>
+#include "tgfx/core/Canvas.h"
+#include "tgfx/core/Rect.h"
+#include "tgfx/core/WriteStream.h"
+#include "tgfx/gpu/Context.h"
+
+namespace tgfx {
+class SVGExportingContext;
+
+/**
+ * Defines flags for SVG exporting that influence the readability and functionality of the exported
+ * SVG.
+ */
+class SVGExportFlags {
+ public:
+  /**
+   * Converts text to paths in the exported SVG. 
+   * By default, text is exported as text elements.
+   * 
+   * Note:
+   * This only applies to fonts with outlines. Fonts without outlines, such as emoji and web fonts,
+   * will still be exported as text.
+   */
+  static constexpr uint32_t ConvertTextToPaths = 1 << 0;
+
+  /**
+   * Disable pretty XML formatting in the exported SVG.
+   * By default, spaces ('\t') and newlines ('\n') are included in the exported SVG text for
+   * improved
+   */
+  static constexpr uint32_t DisablePrettyXML = 1 << 1;
+
+  /**
+   * Disable unsupported attribute warnings.
+   * By default, warnings are logged to the console when exporting attributes that are not supported
+   * by the SVG standard.
+   */
+  static constexpr uint32_t DisableWarnings = 1 << 2;
+};
+
+/**
+ * SVGExporter is a class used to export SVG text, converting drawing commands in the Canvas to
+ * SVG text.
+ * 
+ * Unsupported SVG standard attributes:
+ * - Blend modes: 
+ * Clear, Src, Dst, DstOver, SrcIn, DstIn, SrcOut, DstOut, SrcATop, DstATop, Xor, and Modulate are
+ * not supported.
+ *
+ * - Image filters:
+ * Compose and Runtime are not supported.
+ *
+ * - Color filters:
+ * Blend is partially supported, similar to blend modes.
+ *
+ * - Shaders:
+ * ColorFilter,Blend,Matrix are not supported.Gradient shaders are partially supported.
+ * 
+ * - Gradient shaders:
+ * Conic gradients are not supported.
+ */
+class SVGExporter {
+ public:
+  /**
+   * Creates a shared pointer to an SVG exporter object, which can be used to export SVG text.
+   *
+   * @param svgStream The stream to store the SVG text.
+   * @param context The context used to convert some rendering commands into image data.
+   * @param viewBox The viewBox of the SVG. Content that exceeds this area will be clipped.
+   * @param exportFlags Flags for exporting SVG text.
+   * @return A shared pointer to the SVG exporter object. If svgStream is nullptr, context is
+   * nullptr, or viewBox is empty, nullptr is returned.
+   */
+  static std::shared_ptr<SVGExporter> Make(const std::shared_ptr<WriteStream>& svgStream,
+                                           Context* context, const Rect& viewBox,
+                                           uint32_t exportFlags = 0);
+
+  /**
+   * Destroys the SVG exporter object. If close() hasn't been called, it will be invoked 
+   * automatically.It will finalize any unfinished drawing commands and write the SVG end tag.
+   */
+  ~SVGExporter();
+
+  /**
+   * Returns the canvas for exporting if the SVGExporter is not closed; otherwise, returns nullptr.
+   */
+  Canvas* getCanvas() const;
+
+  /**
+   * Closes the SVG exporter,finalizing any unfinished drawing commands and writing the SVG end tag.
+   */
+  void close();
+
+ private:
+  /**
+   * Construct a SVG exporter object
+   */
+  SVGExporter(const std::shared_ptr<WriteStream>& svgStream, Context* context, const Rect& viewBox,
+              uint32_t exportFlags);
+
+  SVGExportingContext* drawContext = nullptr;
+  Canvas* canvas = nullptr;
+};
+
+}  // namespace tgfx

qt/src/main.cpp

@@ -27,7 +27,6 @@
 #include "qobject.h"
 
 int main(int argc, char* argv[]) {
-
   QApplication::setApplicationName("Hello2D");
   QApplication::setOrganizationName("org.tgfx");
   QSurfaceFormat defaultFormat = QSurfaceFormat();

src/core/Typeface.cpp

@@ -17,6 +17,7 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "tgfx/core/Typeface.h"
+#include <vector>
 #include "core/utils/UniqueID.h"
 #include "tgfx/core/UTF.h"
 
@@ -63,6 +64,11 @@ class EmptyTypeface : public Typeface {
     return nullptr;
   }
 
+ protected:
+  std::vector<Unichar> getGlyphToUnicodeMap() const override {
+    return {};
+  }
+
  private:
   uint32_t _uniqueID = UniqueID::Next();
 };
@@ -84,4 +90,9 @@ GlyphID Typeface::getGlyphID(const std::string& name) const {
   auto unichar = UTF::NextUTF8(&start, start + name.size());
   return getGlyphID(unichar);
 }
+
+std::vector<Unichar> Typeface::getGlyphToUnicodeMap() const {
+  return {};
+};
+
 }  // namespace tgfx

src/core/filters/AlphaThresholdColorFilter.h

@@ -25,6 +25,11 @@ class AlphaThresholdColorFilter : public ColorFilter {
  public:
   explicit AlphaThresholdColorFilter(float threshold) : threshold(threshold){};
 
+ protected:
+  Type type() const override {
+    return Type::AlphaThreshold;
+  };
+
  private:
   std::unique_ptr<FragmentProcessor> asFragmentProcessor() const override;
 

src/core/filters/ComposeColorFilter.h

@@ -28,6 +28,11 @@ class ComposeColorFilter : public ColorFilter {
 
   bool isAlphaUnchanged() const override;
 
+ protected:
+  Type type() const override {
+    return Type::Compose;
+  };
+
  private:
   std::shared_ptr<ColorFilter> inner = nullptr;
   std::shared_ptr<ColorFilter> outer = nullptr;

src/core/filters/MatrixColorFilter.h

@@ -29,8 +29,14 @@ class MatrixColorFilter : public ColorFilter {
     return alphaIsUnchanged;
   }
 
- private:
   std::array<float, 20> matrix;
+
+ protected:
+  Type type() const override {
+    return Type::Matrix;
+  };
+
+ private:
   bool alphaIsUnchanged;
 
   std::unique_ptr<FragmentProcessor> asFragmentProcessor() const override;

src/core/filters/ModeColorFilter.h

@@ -31,10 +31,15 @@ class ModeColorFilter : public ColorFilter {
 
   bool asColorMode(Color* color, BlendMode* mode) const override;
 
- private:
   Color color;
   BlendMode mode;
 
+ protected:
+  Type type() const override {
+    return Type::Blend;
+  };
+
+ private:
   std::unique_ptr<FragmentProcessor> asFragmentProcessor() const override;
 };
 }  // namespace tgfx