Add animated text samples

BUG=skia:

Change-Id: I0b0a00a0d5c5790a1fc963458bc90c968830afd8
Reviewed-on: https://skia-review.googlesource.com/8361
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Mike Reed <reed@google.com>

1 files changed, 407 insertions, 0 deletions

diff --git a/samplecode/SamplePathText.cpp b/samplecode/SamplePathText.cpp
new file mode 100644
index 0000000000..26ffb9a31c
--- /dev/null
+++ b/samplecode/SamplePathText.cpp
@@ -0,0 +1,407 @@
+/*
+ * 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 "SampleCode.h"
+#include "SkAnimTimer.h"
+#include "SkCanvas.h"
+#include "SkGlyphCache.h"
+#include "SkPaint.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkTaskGroup.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Static text from paths.
+class PathText : public SampleView {
+public:
+    constexpr static int kNumPaths = 1500;
+    virtual const char* getName() const { return "PathText"; }
+
+    PathText() : fRand(25) {
+        SkPaint defaultPaint;
+        SkAutoGlyphCache agc(defaultPaint, nullptr, &SkMatrix::I());
+        SkGlyphCache* cache = agc.getCache();
+        SkPath glyphPaths[52];
+        for (int i = 0; i < 52; ++i) {
+            // I and l are rects on OS X ...
+            char c = "aQCDEFGH7JKLMNOPBRZTUVWXYSAbcdefghijk1mnopqrstuvwxyz"[i];
+            SkGlyphID id = cache->unicharToGlyph(c);
+            cache->getScalerContext()->getPath(SkPackedGlyphID(id), &glyphPaths[i]);
+        }
+
+        for (int i = 0; i < kNumPaths; ++i) {
+            const SkPath& p = glyphPaths[i % 52];
+            fGlyphs[i].init(fRand, p);
+        }
+    }
+
+    virtual void reset() {
+        for (Glyph& glyph : fGlyphs) {
+            glyph.reset(fRand, this->width(), this->height());
+        }
+    }
+
+    void onOnceBeforeDraw() final { this->INHERITED::onOnceBeforeDraw(); this->reset(); }
+    void onSizeChange() final { this->INHERITED::onSizeChange(); this->reset(); }
+
+    bool onQuery(SkEvent* evt) final {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, this->getName());
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        for (Glyph& glyph : fGlyphs) {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->translate(glyph.fPosition.x(), glyph.fPosition.y());
+            canvas->scale(glyph.fZoom, glyph.fZoom);
+            canvas->rotate(glyph.fSpin);
+            canvas->translate(-glyph.fMidpt.x(), -glyph.fMidpt.y());
+            canvas->drawPath(glyph.fPath, glyph.fPaint);
+        }
+    }
+
+protected:
+    struct Glyph {
+        void init(SkRandom& rand, const SkPath& path);
+        void reset(SkRandom& rand, int w, int h);
+
+        SkPath     fPath;
+        SkPaint    fPaint;
+        SkPoint    fPosition;
+        SkScalar   fZoom;
+        SkScalar   fSpin;
+        SkPoint    fMidpt;
+    };
+
+    Glyph      fGlyphs[kNumPaths];
+    SkRandom   fRand;
+
+    typedef SampleView INHERITED;
+};
+
+void PathText::Glyph::init(SkRandom& rand, const SkPath& path) {
+    fPath = path;
+    fPaint.setAntiAlias(true);
+    fPaint.setColor(rand.nextU() | 0x80808080);
+}
+
+void PathText::Glyph::reset(SkRandom& rand, int w, int h) {
+    int screensize = SkTMax(w, h);
+    const SkRect& bounds = fPath.getBounds();
+    SkScalar t;
+
+    fPosition = {rand.nextF() * w, rand.nextF() * h};
+    t = pow(rand.nextF(), 100);
+    fZoom = ((1 - t) * screensize / 50 + t * screensize / 3) /
+            SkTMax(bounds.width(), bounds.height());
+    fSpin = rand.nextF() * 360;
+    fMidpt = {bounds.centerX(), bounds.centerY()};
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Text from paths with animated transformation matrices.
+class MovingPathText : public PathText {
+public:
+    const char* getName() const override { return "MovingPathText"; }
+
+    MovingPathText()
+        : fFrontMatrices(kNumPaths)
+        , fBackMatrices(kNumPaths) {
+    }
+
+    ~MovingPathText() {
+        fBackgroundAnimationTask.wait();
+    }
+
+    void reset() override {
+        const SkScalar screensize = static_cast<SkScalar>(SkTMax(this->width(), this->height()));
+        this->INHERITED::reset();
+
+        for (auto& v : fVelocities) {
+            for (SkScalar* d : {&v.fDx, &v.fDy}) {
+                SkScalar t = pow(fRand.nextF(), 3);
+                *d = ((1 - t) / 60 + t / 10) * (fRand.nextBool() ? screensize : -screensize);
+            }
+
+            SkScalar t = pow(fRand.nextF(), 25);
+            v.fDSpin = ((1 - t) * 360 / 7.5 + t * 360 / 1.5) * (fRand.nextBool() ? 1 : -1);
+        }
+
+        // Get valid front data.
+        fBackgroundAnimationTask.wait();
+        this->runAnimationTask(0, 0, this->width(), this->height());
+        memcpy(fFrontMatrices, fBackMatrices, kNumPaths * sizeof(SkMatrix));
+        fLastTick = 0;
+    }
+
+    bool onAnimate(const SkAnimTimer& timer) final {
+        fBackgroundAnimationTask.wait();
+        this->swapAnimationBuffers();
+
+        const double tsec = timer.secs();
+        const double dt = fLastTick ? (timer.secs() - fLastTick) : 0;
+        fBackgroundAnimationTask.add(std::bind(&MovingPathText::runAnimationTask, this, tsec,
+                                               dt, this->width(), this->height()));
+        fLastTick = timer.secs();
+        return true;
+    }
+
+    /**
+     * Called on a background thread. Here we can only modify fBackMatrices.
+     */
+    virtual void runAnimationTask(double t, double dt, int w, int h) {
+        for (int idx = 0; idx < kNumPaths; ++idx) {
+            Velocity* v = &fVelocities[idx];
+            Glyph* glyph = &fGlyphs[idx];
+            SkMatrix* backMatrix = &fBackMatrices[idx];
+
+            glyph->fPosition.fX += v->fDx * dt;
+            if (glyph->fPosition.x() < 0) {
+                glyph->fPosition.fX -= 2 * glyph->fPosition.x();
+                v->fDx = -v->fDx;
+            } else if (glyph->fPosition.x() > w) {
+                glyph->fPosition.fX -= 2 * (glyph->fPosition.x() - w);
+                v->fDx = -v->fDx;
+            }
+
+            glyph->fPosition.fY += v->fDy * dt;
+            if (glyph->fPosition.y() < 0) {
+                glyph->fPosition.fY -= 2 * glyph->fPosition.y();
+                v->fDy = -v->fDy;
+            } else if (glyph->fPosition.y() > h) {
+                glyph->fPosition.fY -= 2 * (glyph->fPosition.y() - h);
+                v->fDy = -v->fDy;
+            }
+
+            glyph->fSpin += v->fDSpin * dt;
+
+            backMatrix->setTranslate(glyph->fPosition.x(), glyph->fPosition.y());
+            backMatrix->preScale(glyph->fZoom, glyph->fZoom);
+            backMatrix->preRotate(glyph->fSpin);
+            backMatrix->preTranslate(-glyph->fMidpt.x(), -glyph->fMidpt.y());
+        }
+    }
+
+    virtual void swapAnimationBuffers() {
+        std::swap(fFrontMatrices, fBackMatrices);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        for (int i = 0; i < kNumPaths; ++i) {
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->concat(fFrontMatrices[i]);
+            canvas->drawPath(fGlyphs[i].fPath, fGlyphs[i].fPaint);
+        }
+    }
+
+protected:
+    struct Velocity {
+        SkScalar fDx, fDy;
+        SkScalar fDSpin;
+    };
+
+    Velocity                  fVelocities[kNumPaths];
+    SkAutoTMalloc<SkMatrix>   fFrontMatrices;
+    SkAutoTMalloc<SkMatrix>   fBackMatrices;
+    SkTaskGroup               fBackgroundAnimationTask;
+    double                    fLastTick;
+
+    typedef PathText INHERITED;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Text from paths with animated control points.
+class WavyPathText : public MovingPathText {
+public:
+    const char* getName() const override { return "WavyPathText"; }
+
+    WavyPathText()
+        : fFrontPaths(kNumPaths)
+        , fBackPaths(kNumPaths) {}
+
+    ~WavyPathText() {
+        fBackgroundAnimationTask.wait();
+    }
+
+    void reset() override {
+        fWaves.reset(fRand, this->width(), this->height());
+        this->INHERITED::reset();
+        std::copy(fBackPaths.get(), fBackPaths.get() + kNumPaths, fFrontPaths.get());
+    }
+
+    /**
+     * Called on a background thread. Here we can only modify fBackPaths.
+     */
+    void runAnimationTask(double t, double dt, int w, int h) override {
+        const float tsec = static_cast<float>(t);
+        this->INHERITED::runAnimationTask(t, 0.5 * dt, w, h);
+
+        for (int i = 0; i < kNumPaths; ++i) {
+            const Glyph& glyph = fGlyphs[i];
+            const SkMatrix& backMatrix = fBackMatrices[i];
+
+            const Sk2f matrix[3] = {
+                Sk2f(backMatrix.getScaleX(), backMatrix.getSkewY()),
+                Sk2f(backMatrix.getSkewX(), backMatrix.getScaleY()),
+                Sk2f(backMatrix.getTranslateX(), backMatrix.getTranslateY())
+            };
+
+            SkPath* backpath = &fBackPaths[i];
+            backpath->reset();
+            backpath->setFillType(SkPath::kEvenOdd_FillType);
+
+            SkPath::RawIter iter(glyph.fPath);
+            SkPath::Verb verb;
+            SkPoint pts[4];
+
+            while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+                switch (verb) {
+                    case SkPath::kMove_Verb: {
+                        SkPoint pt = fWaves.apply(tsec, matrix, pts[0]);
+                        backpath->moveTo(pt.x(), pt.y());
+                        break;
+                    }
+                    case SkPath::kLine_Verb: {
+                        SkPoint endpt = fWaves.apply(tsec, matrix, pts[1]);
+                        backpath->lineTo(endpt.x(), endpt.y());
+                        break;
+                    }
+                    case SkPath::kQuad_Verb: {
+                        SkPoint controlPt = fWaves.apply(tsec, matrix, pts[1]);
+                        SkPoint endpt = fWaves.apply(tsec, matrix, pts[2]);
+                        backpath->quadTo(controlPt.x(), controlPt.y(), endpt.x(), endpt.y());
+                        break;
+                    }
+                    case SkPath::kClose_Verb: {
+                        backpath->close();
+                        break;
+                    }
+                    case SkPath::kCubic_Verb:
+                    case SkPath::kConic_Verb:
+                    case SkPath::kDone_Verb:
+                        SkFAIL("Unexpected path verb");
+                        break;
+                }
+            }
+        }
+    }
+
+    void swapAnimationBuffers() override {
+        this->INHERITED::swapAnimationBuffers();
+        fFrontPaths.swap(fBackPaths);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        for (int i = 0; i < kNumPaths; ++i) {
+            canvas->drawPath(fFrontPaths[i], fGlyphs[i].fPaint);
+        }
+    }
+
+private:
+    /**
+     * Describes 4 stacked sine waves that can offset a point as a function of wall time.
+     */
+    class Waves {
+    public:
+        void reset(SkRandom& rand, int w, int h);
+        SkPoint apply(float tsec, const Sk2f matrix[3], const SkPoint& pt) const;
+
+    private:
+        constexpr static double kAverageAngle = SK_ScalarPI / 8.0;
+        constexpr static double kMaxOffsetAngle = SK_ScalarPI / 3.0;
+
+        float fAmplitudes[4];
+        float fFrequencies[4];
+        float fDirsX[4];
+        float fDirsY[4];
+        float fSpeeds[4];
+        float fOffsets[4];
+    };
+
+    SkAutoTArray<SkPath>   fFrontPaths;
+    SkAutoTArray<SkPath>   fBackPaths;
+    Waves                  fWaves;
+
+    typedef MovingPathText INHERITED;
+};
+
+void WavyPathText::Waves::reset(SkRandom& rand, int w, int h) {
+    const double pixelsPerMeter = 0.06 * SkTMax(w, h);
+    const double medianWavelength = 8 * pixelsPerMeter;
+    const double medianWaveAmplitude = 0.05 * 4 * pixelsPerMeter;
+    const double gravity = 9.8 * pixelsPerMeter;
+
+    for (int i = 0; i < 4; ++i) {
+        const double offsetAngle = (rand.nextF() * 2 - 1) * kMaxOffsetAngle;
+        const double intensity = pow(2, rand.nextF() * 2 - 1);
+        const double wavelength = intensity * medianWavelength;
+
+        fAmplitudes[i] = intensity * medianWaveAmplitude;
+        fFrequencies[i] = 2 * SK_ScalarPI / wavelength;
+        fDirsX[i] = cosf(kAverageAngle + offsetAngle);
+        fDirsY[i] = sinf(kAverageAngle + offsetAngle);
+        fSpeeds[i] = -sqrt(gravity * 2 * SK_ScalarPI / wavelength);
+        fOffsets[i] = rand.nextF() * 2 * SK_ScalarPI;
+    }
+}
+
+SkPoint WavyPathText::Waves::apply(float tsec, const Sk2f matrix[3], const SkPoint& pt) const {
+    constexpr static int kTableSize = 4096;
+    static float sin2table[kTableSize];
+    static SkOnce initTable;
+    initTable([]() {
+        for (int i = 0; i <= kTableSize; ++i) {
+            const double sintheta = sin(i * (SK_ScalarPI / kTableSize));
+            sin2table[i] = static_cast<float>(sintheta * sintheta - 0.5);
+        }
+    });
+
+     const Sk4f amplitudes = Sk4f::Load(fAmplitudes);
+     const Sk4f frequencies = Sk4f::Load(fFrequencies);
+     const Sk4f dirsX = Sk4f::Load(fDirsX);
+     const Sk4f dirsY = Sk4f::Load(fDirsY);
+     const Sk4f speeds = Sk4f::Load(fSpeeds);
+     const Sk4f offsets = Sk4f::Load(fOffsets);
+
+    float devicePt[2];
+    (matrix[0] * pt.x() + matrix[1] * pt.y() + matrix[2]).store(devicePt);
+
+    const Sk4f t = (frequencies * (dirsX * devicePt[0] + dirsY * devicePt[1]) +
+                    speeds * tsec +
+                    offsets).abs() * (float(kTableSize) / float(SK_ScalarPI));
+
+    const Sk4i ipart = SkNx_cast<int>(t);
+    const Sk4f fpart = t - SkNx_cast<float>(ipart);
+
+    int32_t indices[4];
+    (ipart & (kTableSize-1)).store(indices);
+
+    const Sk4f left(sin2table[indices[0]], sin2table[indices[1]],
+                    sin2table[indices[2]], sin2table[indices[3]]);
+    const Sk4f right(sin2table[indices[0] + 1], sin2table[indices[1] + 1],
+                     sin2table[indices[2] + 1], sin2table[indices[3] + 1]);
+    const Sk4f height = amplitudes * (left * (1.f - fpart) + right * fpart);
+
+    Sk4f dy = height * dirsY;
+    Sk4f dx = height * dirsX;
+
+    float offsetY[4], offsetX[4];
+    (dy + SkNx_shuffle<2,3,0,1>(dy)).store(offsetY); // accumulate.
+    (dx + SkNx_shuffle<2,3,0,1>(dx)).store(offsetX);;
+
+    return {devicePt[0] + offsetY[0] + offsetY[1], devicePt[1] - offsetX[0] - offsetX[1]};
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+DEF_SAMPLE( return new WavyPathText; )
+DEF_SAMPLE( return new MovingPathText; )
+DEF_SAMPLE( return new PathText; )