From ed4984bf53b90e50acad606aeb4b35340db802a3 Mon Sep 17 00:00:00 2001 From: csmartdalton Date: Mon, 13 Feb 2017 14:57:28 -0700 Subject: [PATCH] Add animated text samples BUG=skia: Change-Id: I0b0a00a0d5c5790a1fc963458bc90c968830afd8 Reviewed-on: https://skia-review.googlesource.com/8361 Commit-Queue: Chris Dalton Reviewed-by: Mike Reed --- gn/samples.gni | 1 + samplecode/SamplePathText.cpp | 407 ++++++++++++++++++++++++++++++++++ 2 files changed, 408 insertions(+) create mode 100644 samplecode/SamplePathText.cpp diff --git a/gn/samples.gni b/gn/samples.gni index 0fd0df9031..7f8f3b990a 100644 --- a/gn/samples.gni +++ b/gn/samples.gni @@ -67,6 +67,7 @@ samples_sources = [ "$_samplecode/SampleMegaStroke.cpp", "$_samplecode/SamplePatch.cpp", "$_samplecode/SamplePath.cpp", + "$_samplecode/SamplePathText.cpp", "$_samplecode/SamplePathClip.cpp", "$_samplecode/SamplePathEffects.cpp", "$_samplecode/SamplePathFuzz.cpp", 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(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 fFrontMatrices; + SkAutoTMalloc 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(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 fFrontPaths; + SkAutoTArray 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(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(t); + const Sk4f fpart = t - SkNx_cast(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; )