From cbcb0a12ad0068b820c28178e8aa141166febd1f Mon Sep 17 00:00:00 2001 From: Brian Salomon Date: Sun, 19 Nov 2017 13:20:13 -0500 Subject: Revert "Revert "Add Atlas Text interface for rendering SDF glyphs."" This reverts commit 9c2202ffc22b4293b48a4edeafa1b5d2bab8bb83. Bug: skia: Change-Id: I482ddf74f8e40d3d0908c840ba5c6ff981ccefbd Reviewed-on: https://skia-review.googlesource.com/73345 Reviewed-by: Brian Salomon Commit-Queue: Brian Salomon --- include/atlastext/SkAtlasTextContext.h | 42 +++++++++++++++++++ include/atlastext/SkAtlasTextFont.h | 35 ++++++++++++++++ include/atlastext/SkAtlasTextRenderer.h | 71 +++++++++++++++++++++++++++++++++ include/atlastext/SkAtlasTextTarget.h | 61 ++++++++++++++++++++++++++++ 4 files changed, 209 insertions(+) create mode 100644 include/atlastext/SkAtlasTextContext.h create mode 100644 include/atlastext/SkAtlasTextFont.h create mode 100644 include/atlastext/SkAtlasTextRenderer.h create mode 100644 include/atlastext/SkAtlasTextTarget.h (limited to 'include/atlastext') 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 Make(sk_sp); + + 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); + + std::unique_ptr 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 Make(sk_sp typeface, SkScalar size) { + return sk_sp(new SkAtlasTextFont(std::move(typeface), size)); + } + + SkTypeface* typeface() const { return fTypeface.get(); } + + sk_sp refTypeface() const { return fTypeface; } + + SkScalar size() const { return fSize; } + +private: + SkAtlasTextFont(sk_sp typeface, SkScalar size) + : fTypeface(std::move(typeface)), fSize(size) {} + + sk_sp 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 +#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 Make(sk_sp, 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, int width, int height, void* handle); + + void* const fHandle; + const sk_sp fContext; + const int fWidth; + const int fHeight; + +private: + SkAtlasTextTarget() = delete; + SkAtlasTextTarget(const SkAtlasTextContext&) = delete; + SkAtlasTextTarget& operator=(const SkAtlasTextContext&) = delete; +}; + +#endif -- cgit v1.2.3