SVG export module, converting drawing commands to SVG text

CMakeLists.txt

@@ -204,6 +204,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/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;
 
@@ -61,6 +62,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,20 @@ 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.
+   * The length of the array is not required, it will be resized within the method.
+   */
+  virtual std::vector<Unichar> getGlyphToUnicodeMap() const = 0;
+
   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,91 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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 <sstream>
+#include "tgfx/core/Canvas.h"
+#include "tgfx/core/Rect.h"
+#include "tgfx/gpu/Context.h"
+
+namespace tgfx {
+class SVGExportingContext;
+
+struct ExportingOptions {
+  ExportingOptions() = default;
+  ExportingOptions(bool convertTextToPaths, bool prettyXML)
+      : convertTextToPaths(convertTextToPaths), prettyXML(prettyXML) {
+  }
+  /**
+   * Convert text to paths in the exported SVG text, only applicable to outline fonts. Emoji and
+   * web fonts will only be exported as text.
+   */
+  bool convertTextToPaths = false;
+  /**
+   * Format SVG text with spaces('/t') and newlines('/n').
+   */
+  bool prettyXML = true;
+};
+
+/**
+ * SVGExporter is a class used to export SVG text, converting drawing commands in the Canvas to
+ * SVG text.
+ */
+class SVGExporter {
+ public:
+  /**
+   * Creates an SVGExporter object pointer, which can be used to export SVG text.
+   *
+   * @param svgStream The string stream to store the SVG text.
+   * @param context used to convert some rendering commands into image data.
+   * @param viewBox viewBox of SVG, and content that exceeds the display area in the
+   * SVG will be clipped.
+   * @param options Options for exporting SVG text.
+   */
+  static std::shared_ptr<SVGExporter> Make(std::stringstream& svgStream, Context* context,
+                                           const Rect& viewBox, ExportingOptions options);
+
+  /**
+   * Destroys the SVGExporter object, equivalent to calling close().
+   */
+  ~SVGExporter();
+
+  /**
+   * Get the canvas if the SVGExporter is not closed.if closed, return nullptr.
+   */
+  Canvas* getCanvas() const;
+
+  /**
+   * Closes the SVGExporter.Finalizing any unfinished drawing commands and writing the SVG end tag.
+   */
+  void close();
+
+ private:
+  /**
+   * Construct a SVGExporter object
+   */
+  SVGExporter(std::stringstream& svgStream, Context* context, const Rect& viewBox,
+              ExportingOptions options);
+
+  bool closed = false;
+  SVGExportingContext* drawContext = nullptr;
+  Canvas* canvas = nullptr;
+};
+
+}  // namespace tgfx

src/core/Canvas.cpp

@@ -110,6 +110,7 @@ void Canvas::restore() {
   *mcState = canvasState->mcState;
   auto layer = std::move(canvasState->savedLayer);
   stateStack.pop();
+  drawContext->onRestore();
   if (layer != nullptr) {
     drawContext = layer->drawContext;
     auto layerContext = reinterpret_cast<RecordingContext*>(layer->layerContext.get());
@@ -188,6 +189,7 @@ void Canvas::clipPath(const Path& path) {
   auto clipPath = path;
   clipPath.transform(mcState->matrix);
   mcState->clip.addPath(clipPath, PathOp::Intersect);
+  drawContext->onClipPath(*mcState);
 }
 
 void Canvas::resetStateStack() {

src/core/DrawContext.h

@@ -95,5 +95,9 @@ class DrawContext {
    */
   virtual void drawLayer(std::shared_ptr<Picture> picture, const MCState& state,
                          const FillStyle& style, std::shared_ptr<ImageFilter> filter) = 0;
+
+  virtual void onClipPath(const MCState&){};
+
+  virtual void onRestore(){};
 };
 }  // namespace tgfx

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();
 };

src/core/utils/Caster.cpp

@@ -0,0 +1,69 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "Caster.h"
+
+namespace tgfx {
+std::shared_ptr<const ColorShader> ShaderCaster::AsColorShader(
+    const std::shared_ptr<Shader>& shader) {
+  if (shader->type() == Shader::Type::Color) {
+    return std::static_pointer_cast<const ColorShader>(shader);
+  }
+  return nullptr;
+}
+
+std::shared_ptr<const ImageShader> ShaderCaster::AsImageShader(
+    const std::shared_ptr<Shader>& shader) {
+  if (shader->type() == Shader::Type::Image) {
+    return std::static_pointer_cast<const ImageShader>(shader);
+  }
+  return nullptr;
+}
+
+std::shared_ptr<const GradientShader> ShaderCaster::AsGradientShader(
+    const std::shared_ptr<Shader>& shader) {
+  if (shader->type() == Shader::Type::Gradient) {
+    return std::static_pointer_cast<const GradientShader>(shader);
+  }
+  return nullptr;
+}
+
+std::shared_ptr<const BlurImageFilter> ImageFilterCaster::AsBlurImageFilter(
+    const std::shared_ptr<ImageFilter>& imageFilter) {
+  if (imageFilter->type() == ImageFilter::Type::Blur) {
+    return std::static_pointer_cast<const BlurImageFilter>(imageFilter);
+  }
+  return nullptr;
+}
+std::shared_ptr<const DropShadowImageFilter> ImageFilterCaster::AsDropShadowImageFilter(
+    const std::shared_ptr<ImageFilter>& imageFilter) {
+  if (imageFilter->type() == ImageFilter::Type::DropShadow) {
+    return std::static_pointer_cast<const DropShadowImageFilter>(imageFilter);
+  }
+  return nullptr;
+}
+
+std::shared_ptr<const InnerShadowImageFilter> ImageFilterCaster::AsInnerShadowImageFilter(
+    const std::shared_ptr<ImageFilter>& imageFilter) {
+  if (imageFilter->type() == ImageFilter::Type::InnerShadow) {
+    return std::static_pointer_cast<const InnerShadowImageFilter>(imageFilter);
+  }
+  return nullptr;
+}
+
+}  // namespace tgfx

src/core/utils/Caster.h

@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <memory>
+#include "core/filters/BlurImageFilter.h"
+#include "core/filters/DropShadowImageFilter.h"
+#include "core/filters/InnerShadowImageFilter.h"
+#include "core/shaders/ColorShader.h"
+#include "core/shaders/GradientShader.h"
+#include "core/shaders/ImageShader.h"
+
+#pragma once
+
+namespace tgfx {
+
+class ShaderCaster {
+ public:
+  static std::shared_ptr<const ColorShader> AsColorShader(const std::shared_ptr<Shader>& shader);
+
+  static std::shared_ptr<const ImageShader> AsImageShader(const std::shared_ptr<Shader>& shader);
+
+  static std::shared_ptr<const GradientShader> AsGradientShader(
+      const std::shared_ptr<Shader>& shader);
+};
+
+class ImageFilterCaster {
+ public:
+  static std::shared_ptr<const BlurImageFilter> AsBlurImageFilter(
+      const std::shared_ptr<ImageFilter>& imageFilter);
+
+  static std::shared_ptr<const DropShadowImageFilter> AsDropShadowImageFilter(
+      const std::shared_ptr<ImageFilter>& imageFilter);
+
+  static std::shared_ptr<const InnerShadowImageFilter> AsInnerShadowImageFilter(
+      const std::shared_ptr<ImageFilter>& imageFilter);
+};
+
+}  // namespace tgfx