Add Atlas Text interface for rendering SDF glyphs.

This new API is built upon SDF text atlas code from the GPU backend. Unlike using the GPU
backend to draw text, this set of interfaces allows the client to render the SDF glyphs. The
client issues text draws to potentially multiple targets and then the client flushes. The
client then gets commands from Skia with data to put into a texture atlas and vertices to
draw that reference the texture. The client is responsible for creating the texture, uploading
the SDF data to the texture, and drawing the vertices provided by Skia.

Change-Id: Ie9447e19b85f0ce1c2b942e5216c787a74f335d3
Reviewed-on: https://skia-review.googlesource.com/59360
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

4 files changed, 209 insertions, 0 deletions

diff --git a/include/atlastext/SkAtlasTextContext.h b/include/atlastext/SkAtlasTextContext.h
new file mode 100644
index 0000000000..bb5de52992
--- /dev/null
+++ b/include/atlastext/SkAtlasTextContext.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAtlasTextContext_DEFINED
+#define SkAtlasTextContext_DEFINED
+
+#include "SkRefCnt.h"
+
+class SkAtlasTextRenderer;
+class SkInternalAtlasTextContext;
+
+SkAtlasTextRenderer* SkGetAtlasTextRendererFromInternalContext(class SkInternalAtlasTextContext&);
+
+/**
+ * Class that Atlas Text client uses to register their SkAtlasTextRenderer implementation and
+ * to create one or more SkAtlasTextTargets (destination surfaces for text rendering).
+ */
+class SK_API SkAtlasTextContext : public SkRefCnt {
+public:
+    static sk_sp<SkAtlasTextContext> Make(sk_sp<SkAtlasTextRenderer>);
+
+    SkAtlasTextRenderer* renderer() const {
+        return SkGetAtlasTextRendererFromInternalContext(*fInternalContext);
+    }
+
+    SkInternalAtlasTextContext& internal() { return *fInternalContext; }
+
+private:
+    SkAtlasTextContext() = delete;
+    SkAtlasTextContext(const SkAtlasTextContext&) = delete;
+    SkAtlasTextContext& operator=(const SkAtlasTextContext&) = delete;
+
+    SkAtlasTextContext(sk_sp<SkAtlasTextRenderer>);
+
+    std::unique_ptr<SkInternalAtlasTextContext> fInternalContext;
+};
+
+#endif
diff --git a/include/atlastext/SkAtlasTextFont.h b/include/atlastext/SkAtlasTextFont.h
new file mode 100644
index 0000000000..a9e641f7ad
--- /dev/null
+++ b/include/atlastext/SkAtlasTextFont.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAtlasTextFont_DEFINED
+#define SkAtlasTextFont_DEFINED
+
+#include "SkRefCnt.h"
+#include "SkTypeface.h"
+
+/** Represents a font at a size. TODO: What else do we need here (skewX, scaleX, vertical, ...)? */
+class SK_API SkAtlasTextFont : public SkRefCnt {
+public:
+    static sk_sp<SkAtlasTextFont> Make(sk_sp<SkTypeface> typeface, SkScalar size) {
+        return sk_sp<SkAtlasTextFont>(new SkAtlasTextFont(std::move(typeface), size));
+    }
+
+    SkTypeface* typeface() const { return fTypeface.get(); }
+
+    sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
+
+    SkScalar size() const { return fSize; }
+
+private:
+    SkAtlasTextFont(sk_sp<SkTypeface> typeface, SkScalar size)
+            : fTypeface(std::move(typeface)), fSize(size) {}
+
+    sk_sp<SkTypeface> fTypeface;
+    SkScalar fSize;
+};
+
+#endif
diff --git a/include/atlastext/SkAtlasTextRenderer.h b/include/atlastext/SkAtlasTextRenderer.h
new file mode 100644
index 0000000000..a78e270edb
--- /dev/null
+++ b/include/atlastext/SkAtlasTextRenderer.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkPoint.h"
+#include "SkRefCnt.h"
+
+#ifndef SkAtlasTextRenderer_DEFINED
+#define SkAtlasTextRenderer_DEFINED
+
+/**
+ * This is the base class for a renderer implemented by the SkAtlasText client. The
+ * SkAtlasTextContext issues texture creations, deletions, uploads, and vertex draws to the
+ * renderer. The renderer must perform those actions in the order called to correctly render
+ * the text drawn to SkAtlasTextTargets.
+ */
+class SK_API SkAtlasTextRenderer : public SkRefCnt {
+public:
+    enum class AtlasFormat {
+        /** Unsigned normalized 8 bit single channel format. */
+        kA8
+    };
+
+    struct SDFVertex {
+        /** Position in device space (not normalized). */
+        SkPoint fPosition;
+        /** Color, same value for all four corners of a glyph quad. */
+        uint32_t fColor;
+        /** Texture coordinate (in texel units, not normalized). */
+        SkIPoint16 fTextureCoord;
+    };
+
+    virtual ~SkAtlasTextRenderer() = default;
+
+    /**
+     * Create a texture of the provided format with dimensions 'width' x 'height'
+     * and return a unique handle.
+     */
+    virtual void* createTexture(AtlasFormat, int width, int height) = 0;
+
+    /**
+     * Delete the texture with the passed handle.
+     */
+    virtual void deleteTexture(void* textureHandle) = 0;
+
+    /**
+     * Place the pixel data specified by 'data' in the texture with handle
+     * 'textureHandle' in the rectangle ['x', 'x' + 'width') x ['y', 'y' + 'height').
+     * 'rowBytes' specifies the byte offset between successive rows in 'data' and will always be
+     * a multiple of the number of bytes per pixel.
+     * The pixel format of data is the same as that of 'textureHandle'.
+     */
+    virtual void setTextureData(void* textureHandle, const void* data, int x, int y, int width,
+                                int height, size_t rowBytes) = 0;
+
+    /**
+     * Draws glyphs using SDFs. The SDF data resides in 'textureHandle'. The array
+     * 'vertices' provides interleaved device-space positions, colors, and
+     * texture coordinates. There are are 4 * 'quadCnt' entries in 'vertices'.
+     */
+    virtual void drawSDFGlyphs(void* targetHandle, void* textureHandle, const SDFVertex vertices[],
+                               int quadCnt) = 0;
+
+    /** Called when a SkAtlasTextureTarget is destroyed. */
+    virtual void targetDeleted(void* targetHandle) = 0;
+};
+
+#endif
diff --git a/include/atlastext/SkAtlasTextTarget.h b/include/atlastext/SkAtlasTextTarget.h
new file mode 100644
index 0000000000..0859afde39
--- /dev/null
+++ b/include/atlastext/SkAtlasTextTarget.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAtlasTextTarget_DEFINED
+#define SkAtlasTextTarget_DEFINED
+
+#include <memory>
+#include "SkRefCnt.h"
+#include "SkScalar.h"
+
+class SkAtlasTextContext;
+class SkAtlasTextFont;
+
+/** Represents a client-created renderable surface and is used to draw text into the surface. */
+class SK_API SkAtlasTextTarget {
+public:
+    virtual ~SkAtlasTextTarget();
+
+    /**
+     * Creates a text drawing target. ‘handle’ is used to identify this rendering surface when
+     * draws are flushed to the SkAtlasTextContext's SkAtlasTextRenderer.
+     */
+    static std::unique_ptr<SkAtlasTextTarget> Make(sk_sp<SkAtlasTextContext>, int width, int height,
+                                                   void* handle);
+
+    /**
+     * Enqueues a text draw in the target. The meaning of 'color' here is interpreted by the
+     * client's SkAtlasTextRenderer when it actually renders the text.
+     */
+    virtual void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
+                          uint32_t color, const SkAtlasTextFont& font) = 0;
+
+    /** Issues all queued text draws to SkAtlasTextRenderer. */
+    virtual void flush() = 0;
+
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+
+    void* handle() const { return fHandle; }
+
+    SkAtlasTextContext* context() const { return fContext.get(); }
+
+protected:
+    SkAtlasTextTarget(sk_sp<SkAtlasTextContext>, int width, int height, void* handle);
+
+    void* const fHandle;
+    const sk_sp<SkAtlasTextContext> fContext;
+    const int fWidth;
+    const int fHeight;
+
+private:
+    SkAtlasTextTarget() = delete;
+    SkAtlasTextTarget(const SkAtlasTextContext&) = delete;
+    SkAtlasTextTarget& operator=(const SkAtlasTextContext&) = delete;
+};
+
+#endif