Revert "Add Atlas Text interface for rendering SDF glyphs."

This reverts commit 39631f3df172feb385527a5d125bc53b0bded7e6.

Reason for revert: break google3 rool

Original change's description:
> 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>

TBR=jvanverth@google.com,bsalomon@google.com,robertphillips@google.com

Change-Id: I4aad0c99e645b476fd8ba25731f2a10e8802bb25
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/73420
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>

3 files changed, 0 insertions, 498 deletions

diff --git a/tools/gpu/atlastext/GLTestAtlasTextRenderer.cpp b/tools/gpu/atlastext/GLTestAtlasTextRenderer.cpp
deleted file mode 100644
index 543f46012b..0000000000
--- a/tools/gpu/atlastext/GLTestAtlasTextRenderer.cpp
+++ /dev/null
@@ -1,439 +0,0 @@
-/*
- * 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 "GLTestAtlasTextRenderer.h"
-#include "../gl/GLTestContext.h"
-#include "SkBitmap.h"
-#include "TestAtlasTextRenderer.h"
-#include "gl/GrGLDefines.h"
-
-using sk_gpu_test::GLTestContext;
-
-namespace {
-
-class GLTestAtlasTextRenderer : public sk_gpu_test::TestAtlasTextRenderer {
-public:
-    GLTestAtlasTextRenderer(std::unique_ptr<GLTestContext>);
-
-    void* createTexture(AtlasFormat, int width, int height) override;
-
-    void deleteTexture(void* textureHandle) override;
-
-    void setTextureData(void* textureHandle, const void* data, int x, int y, int width, int height,
-                        size_t rowBytes) override;
-
-    void drawSDFGlyphs(void* targetHandle, void* textureHandle, const SDFVertex vertices[],
-                       int quadCnt) override;
-
-    void* makeTargetHandle(int width, int height) override;
-
-    void targetDeleted(void* target) override;
-
-    SkBitmap readTargetHandle(void* target) override;
-
-    bool initialized() const { return 0 != fProgram; }
-
-private:
-    struct AtlasTexture {
-        GrGLuint fID;
-        AtlasFormat fFormat;
-        int fWidth;
-        int fHeight;
-    };
-
-    struct Target {
-        GrGLuint fFBOID;
-        GrGLuint fRBID;
-        int fWidth;
-        int fHeight;
-    };
-
-    std::unique_ptr<GLTestContext> fContext;
-    GrGLuint fProgram = 0;
-    GrGLint fDstScaleAndTranslateLocation = 0;
-    GrGLint fAtlasInvSizeLocation = 0;
-    GrGLint fSamplerLocation = 0;
-};
-
-#define callgl(NAME, ...) fContext->gl()->fFunctions.f##NAME(__VA_ARGS__)
-#define checkgl()                                               \
-    do {                                                        \
-        static constexpr auto line = __LINE__;                  \
-        auto error = fContext->gl()->fFunctions.fGetError();    \
-        if (error != GR_GL_NO_ERROR) {                          \
-            SkDebugf("GL ERROR: 0x%x, line %d\n", error, line); \
-        }                                                       \
-    } while (false)
-
-GLTestAtlasTextRenderer::GLTestAtlasTextRenderer(std::unique_ptr<GLTestContext> context)
-        : fContext(std::move(context)) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-    auto vs = callgl(CreateShader, GR_GL_VERTEX_SHADER);
-    static constexpr char kGLVersionString[] = "#version 430 compatibility";
-    static constexpr char kGLESVersionString[] = "#version 300 es";
-    GrGLint lengths[2];
-    const GrGLchar* strings[2];
-    switch (fContext->gl()->fStandard) {
-        case kGL_GrGLStandard:
-            strings[0] = kGLVersionString;
-            lengths[0] = static_cast<GrGLint>(SK_ARRAY_COUNT(kGLVersionString)) - 1;
-            break;
-        case kGLES_GrGLStandard:
-            strings[0] = kGLESVersionString;
-            lengths[0] = static_cast<GrGLint>(SK_ARRAY_COUNT(kGLESVersionString)) - 1;
-            break;
-        default:
-            strings[0] = nullptr;
-            lengths[0] = 0;
-            break;
-    }
-
-    static constexpr const char kVS[] = R"(
-        uniform vec4 uDstScaleAndTranslate;
-        uniform vec2 uAtlasInvSize;
-
-        layout (location = 0) in vec2 inPosition;
-        layout (location = 1) in vec4 inColor;
-        layout (location = 2) in uvec2 inTextureCoords;
-
-        out vec2 vTexCoord;
-        out vec4 vColor;
-        out vec2 vIntTexCoord;
-
-        void main() {
-            vec2 intCoords;
-            // floor(vec2) doesn't seem to work on some ES devices.
-            intCoords.x = floor(float(inTextureCoords.x));
-            intCoords.y = floor(float(inTextureCoords.y));
-            vTexCoord = intCoords * uAtlasInvSize;
-            vIntTexCoord = intCoords;
-            vColor = inColor;
-            gl_Position = vec4(inPosition.x * uDstScaleAndTranslate.x + uDstScaleAndTranslate.y,
-                               inPosition.y * uDstScaleAndTranslate.z + uDstScaleAndTranslate.w,
-                               0.0, 1.0);
-        }
-    )";
-    strings[1] = kVS;
-    lengths[1] = SK_ARRAY_COUNT(kVS) - 1;
-    callgl(ShaderSource, vs, 2, strings, lengths);
-    callgl(CompileShader, vs);
-    GrGLint compileStatus;
-    callgl(GetShaderiv, vs, GR_GL_COMPILE_STATUS, &compileStatus);
-    if (compileStatus == GR_GL_FALSE) {
-        GrGLint logLength;
-        callgl(GetShaderiv, vs, GR_GL_INFO_LOG_LENGTH, &logLength);
-        std::unique_ptr<GrGLchar[]> log(new GrGLchar[logLength + 1]);
-        log[logLength] = '\0';
-        callgl(GetShaderInfoLog, vs, logLength, &logLength, log.get());
-        SkDebugf("Vertex Shader failed to compile\n%s", log.get());
-        callgl(DeleteShader, vs);
-        return;
-    }
-
-    auto fs = callgl(CreateShader, GR_GL_FRAGMENT_SHADER);
-    static constexpr const char kFS[] = R"(
-        uniform sampler2D uSampler;
-
-        in vec2 vTexCoord;
-        in vec4 vColor;
-        in vec2 vIntTexCoord;
-
-        layout (location = 0) out vec4 outColor;
-
-        void main() {
-            float sdfValue = texture(uSampler, vTexCoord).r;
-            float distance = 7.96875 * (sdfValue - 0.50196078431000002);
-            vec2 dist_grad = vec2(dFdx(distance), dFdy(distance));
-            vec2 Jdx = dFdx(vIntTexCoord);
-            vec2 Jdy = dFdy(vIntTexCoord);
-            float dg_len2 = dot(dist_grad, dist_grad);
-            if (dg_len2 < 0.0001) {
-                dist_grad = vec2(0.7071, 0.7071);
-            } else {
-                dist_grad = dist_grad * inversesqrt(dg_len2);
-            }
-            vec2 grad = vec2(dist_grad.x * Jdx.x + dist_grad.y * Jdy.x,
-                             dist_grad.x * Jdx.y + dist_grad.y * Jdy.y);
-            float afwidth = abs(0.65000000000000002 * length(grad));
-            float value = smoothstep(-afwidth, afwidth, distance);
-            outColor = value * vec4(vColor.rgb * vColor.a, vColor.a);
-        }
-    )";
-    strings[1] = kFS;
-    lengths[1] = SK_ARRAY_COUNT(kFS) - 1;
-    callgl(ShaderSource, fs, 2, strings, lengths);
-    callgl(CompileShader, fs);
-    callgl(GetShaderiv, fs, GR_GL_COMPILE_STATUS, &compileStatus);
-    if (compileStatus == GR_GL_FALSE) {
-        GrGLint logLength;
-        callgl(GetShaderiv, fs, GR_GL_INFO_LOG_LENGTH, &logLength);
-        std::unique_ptr<GrGLchar[]> log(new GrGLchar[logLength + 1]);
-        log[logLength] = '\0';
-        callgl(GetShaderInfoLog, fs, logLength, &logLength, log.get());
-        SkDebugf("Fragment Shader failed to compile\n%s", log.get());
-        callgl(DeleteShader, vs);
-        callgl(DeleteShader, fs);
-        return;
-    }
-
-    fProgram = callgl(CreateProgram);
-    if (!fProgram) {
-        callgl(DeleteShader, vs);
-        callgl(DeleteShader, fs);
-        return;
-    }
-
-    callgl(AttachShader, fProgram, vs);
-    callgl(AttachShader, fProgram, fs);
-    callgl(LinkProgram, fProgram);
-    GrGLint linkStatus;
-    callgl(GetProgramiv, fProgram, GR_GL_LINK_STATUS, &linkStatus);
-    if (linkStatus == GR_GL_FALSE) {
-        GrGLint logLength = 0;
-        callgl(GetProgramiv, vs, GR_GL_INFO_LOG_LENGTH, &logLength);
-        std::unique_ptr<GrGLchar[]> log(new GrGLchar[logLength + 1]);
-        log[logLength] = '\0';
-        callgl(GetProgramInfoLog, vs, logLength, &logLength, log.get());
-        SkDebugf("Program failed to link\n%s", log.get());
-        callgl(DeleteShader, vs);
-        callgl(DeleteShader, fs);
-        callgl(DeleteProgram, fProgram);
-        fProgram = 0;
-        return;
-    }
-    fDstScaleAndTranslateLocation = callgl(GetUniformLocation, fProgram, "uDstScaleAndTranslate");
-    fAtlasInvSizeLocation = callgl(GetUniformLocation, fProgram, "uAtlasInvSize");
-    fSamplerLocation = callgl(GetUniformLocation, fProgram, "uSampler");
-    if (fDstScaleAndTranslateLocation < 0 || fAtlasInvSizeLocation < 0 || fSamplerLocation < 0) {
-        callgl(DeleteShader, vs);
-        callgl(DeleteShader, fs);
-        callgl(DeleteProgram, fProgram);
-        fProgram = 0;
-    }
-
-    checkgl();
-}
-
-inline bool atlas_format_to_gl_types(SkAtlasTextRenderer::AtlasFormat format,
-                                     GrGLenum* internalFormat, GrGLenum* externalFormat,
-                                     GrGLenum* type) {
-    switch (format) {
-        case SkAtlasTextRenderer::AtlasFormat::kA8:
-            *internalFormat = GR_GL_R8;
-            *externalFormat = GR_GL_RED;
-            *type = GR_GL_UNSIGNED_BYTE;
-            return true;
-    }
-    return false;
-}
-
-inline int atlas_format_bytes_per_pixel(SkAtlasTextRenderer::AtlasFormat format) {
-    switch (format) {
-        case SkAtlasTextRenderer::AtlasFormat::kA8:
-            return 1;
-    }
-    return 0;
-}
-
-void* GLTestAtlasTextRenderer::createTexture(AtlasFormat format, int width, int height) {
-    GrGLenum internalFormat;
-    GrGLenum externalFormat;
-    GrGLenum type;
-    if (!atlas_format_to_gl_types(format, &internalFormat, &externalFormat, &type)) {
-        return nullptr;
-    }
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    GrGLuint id;
-    callgl(GenTextures, 1, &id);
-    if (!id) {
-        return nullptr;
-    }
-
-    callgl(BindTexture, GR_GL_TEXTURE_2D, id);
-    callgl(TexImage2D, GR_GL_TEXTURE_2D, 0, internalFormat, width, height, 0, externalFormat, type,
-           nullptr);
-    checkgl();
-
-    AtlasTexture* atlas = new AtlasTexture;
-    atlas->fID = id;
-    atlas->fFormat = format;
-    atlas->fWidth = width;
-    atlas->fHeight = height;
-    return atlas;
-}
-
-void GLTestAtlasTextRenderer::deleteTexture(void* textureHandle) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    auto* atlasTexture = reinterpret_cast<const AtlasTexture*>(textureHandle);
-
-    callgl(DeleteTextures, 1, &atlasTexture->fID);
-    checkgl();
-
-    delete atlasTexture;
-}
-
-void GLTestAtlasTextRenderer::setTextureData(void* textureHandle, const void* data, int x, int y,
-                                             int width, int height, size_t rowBytes) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    auto atlasTexture = reinterpret_cast<const AtlasTexture*>(textureHandle);
-
-    GrGLenum internalFormat;
-    GrGLenum externalFormat;
-    GrGLenum type;
-    if (!atlas_format_to_gl_types(atlasTexture->fFormat, &internalFormat, &externalFormat, &type)) {
-        return;
-    }
-    int bpp = atlas_format_bytes_per_pixel(atlasTexture->fFormat);
-    GrGLint rowLength = static_cast<GrGLint>(rowBytes / bpp);
-    if (static_cast<size_t>(rowLength * bpp) != rowBytes) {
-        return;
-    }
-    callgl(PixelStorei, GR_GL_UNPACK_ALIGNMENT, 1);
-    callgl(PixelStorei, GR_GL_UNPACK_ROW_LENGTH, rowLength);
-    callgl(BindTexture, GR_GL_TEXTURE_2D, atlasTexture->fID);
-    callgl(TexSubImage2D, GR_GL_TEXTURE_2D, 0, x, y, width, height, externalFormat, type, data);
-    checkgl();
-}
-
-void GLTestAtlasTextRenderer::drawSDFGlyphs(void* targetHandle, void* textureHandle,
-                                            const SDFVertex vertices[], int quadCnt) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    auto target = reinterpret_cast<const Target*>(targetHandle);
-    auto atlas = reinterpret_cast<const AtlasTexture*>(textureHandle);
-
-    callgl(UseProgram, fProgram);
-
-    callgl(ActiveTexture, GR_GL_TEXTURE0);
-    callgl(BindTexture, GR_GL_TEXTURE_2D, atlas->fID);
-    callgl(TexParameteri, GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MAG_FILTER, GR_GL_LINEAR);
-    callgl(TexParameteri, GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MIN_FILTER, GR_GL_LINEAR);
-
-    float uniformScaleAndTranslate[4] = {2.f / target->fWidth, -1.f, 2.f / target->fHeight, -1.f};
-    callgl(Uniform4fv, fDstScaleAndTranslateLocation, 1, uniformScaleAndTranslate);
-    callgl(Uniform2f, fAtlasInvSizeLocation, 1.f / atlas->fWidth, 1.f / atlas->fHeight);
-    callgl(Uniform1i, fSamplerLocation, 0);
-
-    callgl(BindFramebuffer, GR_GL_FRAMEBUFFER, target->fFBOID);
-    callgl(Viewport, 0, 0, target->fWidth, target->fHeight);
-
-    callgl(Enable, GR_GL_BLEND);
-    callgl(BlendFunc, GR_GL_ONE, GR_GL_ONE_MINUS_SRC_ALPHA);
-    callgl(Disable, GR_GL_DEPTH_TEST);
-
-    callgl(BindVertexArray, 0);
-    callgl(BindBuffer, GR_GL_ARRAY_BUFFER, 0);
-    callgl(BindBuffer, GR_GL_ELEMENT_ARRAY_BUFFER, 0);
-    callgl(VertexAttribPointer, 0, 2, GR_GL_FLOAT, GR_GL_FALSE, sizeof(SDFVertex), vertices);
-    size_t colorOffset = 2 * sizeof(float);
-    callgl(VertexAttribPointer, 1, 4, GR_GL_UNSIGNED_BYTE, GR_GL_TRUE, sizeof(SDFVertex),
-           reinterpret_cast<const char*>(vertices) + colorOffset);
-    size_t texOffset = colorOffset + sizeof(uint32_t);
-    callgl(VertexAttribIPointer, 2, 2, GR_GL_UNSIGNED_SHORT, sizeof(SDFVertex),
-           reinterpret_cast<const char*>(vertices) + texOffset);
-    callgl(EnableVertexAttribArray, 0);
-    callgl(EnableVertexAttribArray, 1);
-    callgl(EnableVertexAttribArray, 2);
-
-    std::unique_ptr<uint16_t[]> indices(new uint16_t[quadCnt * 6]);
-    for (int q = 0; q < quadCnt; ++q) {
-        indices[q * 6 + 0] = 0 + 4 * q;
-        indices[q * 6 + 1] = 1 + 4 * q;
-        indices[q * 6 + 2] = 2 + 4 * q;
-        indices[q * 6 + 3] = 2 + 4 * q;
-        indices[q * 6 + 4] = 1 + 4 * q;
-        indices[q * 6 + 5] = 3 + 4 * q;
-    }
-    callgl(DrawElements, GR_GL_TRIANGLES, 6 * quadCnt, GR_GL_UNSIGNED_SHORT, indices.get());
-    checkgl();
-}
-
-void* GLTestAtlasTextRenderer::makeTargetHandle(int width, int height) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    GrGLuint fbo;
-    callgl(GenFramebuffers, 1, &fbo);
-    if (!fbo) {
-        return nullptr;
-    }
-    GrGLuint rb;
-    callgl(GenRenderbuffers, 1, &rb);
-    if (!rb) {
-        callgl(DeleteFramebuffers, 1, &fbo);
-        return nullptr;
-    }
-    callgl(BindFramebuffer, GR_GL_FRAMEBUFFER, fbo);
-    callgl(BindRenderbuffer, GR_GL_RENDERBUFFER, rb);
-    callgl(RenderbufferStorage, GR_GL_RENDERBUFFER, GR_GL_RGBA8, width, height);
-    callgl(FramebufferRenderbuffer, GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0, GR_GL_RENDERBUFFER,
-           rb);
-    GrGLenum status = callgl(CheckFramebufferStatus, GR_GL_FRAMEBUFFER);
-    if (GR_GL_FRAMEBUFFER_COMPLETE != status) {
-        callgl(DeleteFramebuffers, 1, &fbo);
-        callgl(DeleteRenderbuffers, 1, &rb);
-        return nullptr;
-    }
-    callgl(Disable, GR_GL_SCISSOR_TEST);
-    callgl(ClearColor, 0.5, 0.5, 0.5, 1.0);
-    callgl(Clear, GR_GL_COLOR_BUFFER_BIT);
-    checkgl();
-    Target* target = new Target;
-    target->fFBOID = fbo;
-    target->fRBID = rb;
-    target->fWidth = width;
-    target->fHeight = height;
-    return target;
-}
-
-void GLTestAtlasTextRenderer::targetDeleted(void* target) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    Target* t = reinterpret_cast<Target*>(target);
-    callgl(DeleteFramebuffers, 1, &t->fFBOID);
-    callgl(DeleteRenderbuffers, 1, &t->fRBID);
-    delete t;
-}
-
-SkBitmap GLTestAtlasTextRenderer::readTargetHandle(void* target) {
-    auto restore = fContext->makeCurrentAndAutoRestore();
-
-    Target* t = reinterpret_cast<Target*>(target);
-
-    auto info =
-            SkImageInfo::Make(t->fWidth, t->fHeight, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
-    SkBitmap bmp;
-    bmp.setInfo(info, sizeof(uint32_t) * t->fWidth);
-    bmp.allocPixels();
-
-    callgl(BindFramebuffer, GR_GL_FRAMEBUFFER, t->fFBOID);
-    callgl(ReadPixels, 0, 0, t->fWidth, t->fHeight, GR_GL_RGBA, GR_GL_UNSIGNED_BYTE,
-           bmp.getPixels());
-    checkgl();
-    return bmp;
-}
-
-}  // anonymous namespace
-
-namespace sk_gpu_test {
-
-sk_sp<TestAtlasTextRenderer> MakeGLTestAtlasTextRenderer() {
-    std::unique_ptr<GLTestContext> context(CreatePlatformGLTestContext(kGL_GrGLStandard));
-    if (!context) {
-        context.reset(CreatePlatformGLTestContext(kGLES_GrGLStandard));
-    }
-    if (!context) {
-        return nullptr;
-    }
-    auto restorer = context->makeCurrentAndAutoRestore();
-    auto renderer = sk_make_sp<GLTestAtlasTextRenderer>(std::move(context));
-    return renderer->initialized() ? std::move(renderer) : nullptr;
-}
-
-}  // namespace sk_gpu_test
diff --git a/tools/gpu/atlastext/GLTestAtlasTextRenderer.h b/tools/gpu/atlastext/GLTestAtlasTextRenderer.h
deleted file mode 100644
index df01b345de..0000000000
--- a/tools/gpu/atlastext/GLTestAtlasTextRenderer.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * 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 GLTestAtlasTextRenderer_DEFINED
-#define GLTestAtlasTextRenderer_DEFINED
-
-#include "SkRefCnt.h"
-
-namespace sk_gpu_test {
-
-class TestAtlasTextRenderer;
-
-/**
- * Creates a TestAtlasTextRenderer that uses its own OpenGL context to implement
- * SkAtlasTextRenderer.
- */
-sk_sp<TestAtlasTextRenderer> MakeGLTestAtlasTextRenderer();
-
-}  // namespace sk_gpu_test
-
-#endif
diff --git a/tools/gpu/atlastext/TestAtlasTextRenderer.h b/tools/gpu/atlastext/TestAtlasTextRenderer.h
deleted file mode 100644
index 068a60d2bb..0000000000
--- a/tools/gpu/atlastext/TestAtlasTextRenderer.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * 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 TestAtlasTextRenderer_DEFINED
-#define TestAtlasTextRenderer_DEFINED
-
-#include "SkAtlasTextRenderer.h"
-#include "SkBitmap.h"
-
-namespace sk_gpu_test {
-
-class TestContext;
-
-/**
- * Base class for implementations of SkAtlasTextRenderer in order to test the SkAtlasText APIs.
- * Adds a helper for creating SkAtlasTextTargets and to read back the contents of a target as a
- * bitmap.
- */
-class TestAtlasTextRenderer : public SkAtlasTextRenderer {
-public:
-    /** Returns a handle that can be used to construct a SkAtlasTextTarget instance. */
-    virtual void* makeTargetHandle(int width, int height) = 0;
-
-    /** Makes a SkBitmap of the target handle's contents. */
-    virtual SkBitmap readTargetHandle(void* targetHandle) = 0;
-};
-
-}  // namespace sk_gpu_test
-
-#endif