Restore SkLightingShader and associated classes

This reverts https://skia-review.googlesource.com/c/skia/+/31140 (Remove SkLightingShader and associated classes) and updates the classes to ToT

Change-Id: I3b1df1704cca8907aa00f081a7e93339b65ad4fa
Reviewed-on: https://skia-review.googlesource.com/141545
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

2 files changed, 612 insertions, 0 deletions

diff --git a/samplecode/SampleLighting.cpp b/samplecode/SampleLighting.cpp
new file mode 100644
index 0000000000..0e68135b9d
--- /dev/null
+++ b/samplecode/SampleLighting.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "DecodeFile.h"
+#include "SampleCode.h"
+#include "Resources.h"
+#include "SkCanvas.h"
+#include "SkLightingShader.h"
+#include "SkNormalSource.h"
+#include "SkPoint3.h"
+
+static sk_sp<SkLights> create_lights(SkScalar angle, SkScalar blue) {
+
+    const SkVector3 dir = SkVector3::Make(SkScalarSin(angle)*SkScalarSin(SK_ScalarPI*0.25f),
+                                          SkScalarCos(angle)*SkScalarSin(SK_ScalarPI*0.25f),
+                                          SkScalarCos(SK_ScalarPI*0.25f));
+
+    SkLights::Builder builder;
+
+    builder.add(SkLights::Light::MakeDirectional(SkColor3f::Make(1.0f, 1.0f, blue), dir));
+    builder.setAmbientLightColor(SkColor3f::Make(0.1f, 0.1f, 0.1f));
+
+    return builder.finish();
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+class LightingView : public SampleView {
+public:
+    LightingView() : fLightAngle(0.0f) , fColorFactor(0.0f) {
+        {
+            SkBitmap diffuseBitmap;
+            SkAssertResult(GetResourceAsBitmap("images/brickwork-texture.jpg", &diffuseBitmap));
+
+            fRect = SkRect::MakeIWH(diffuseBitmap.width(), diffuseBitmap.height());
+
+            fDiffuseShader = SkShader::MakeBitmapShader(diffuseBitmap,
+                                                        SkShader::kClamp_TileMode,
+                                                        SkShader::kClamp_TileMode,
+                                                        nullptr);
+        }
+
+        {
+            SkBitmap normalBitmap;
+            SkAssertResult(GetResourceAsBitmap("images/brickwork_normal-map.jpg", &normalBitmap));
+
+            sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(normalBitmap,
+                                                                   SkShader::kClamp_TileMode,
+                                                                   SkShader::kClamp_TileMode,
+                                                                   nullptr);
+            fNormalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap), SkMatrix::I());
+        }
+    }
+
+protected:
+    // overrides from SkEventSink
+    bool onQuery(SkEvent* evt) override {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "Lighting");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        sk_sp<SkLights> lights(create_lights(fLightAngle, fColorFactor));
+
+        SkPaint paint;
+        paint.setShader(SkLightingShader::Make(fDiffuseShader,
+                                               fNormalSource,
+                                               std::move(lights)));
+        paint.setColor(SK_ColorBLACK);
+
+        canvas->drawRect(fRect, paint);
+    }
+
+    SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi) override {
+        return this->INHERITED::onFindClickHandler(x, y, modi);
+    }
+
+    bool onAnimate(const SkAnimTimer& timer) override {
+        fLightAngle += 0.015f;
+        fColorFactor += 0.01f;
+        if (fColorFactor > 1.0f) {
+            fColorFactor = 0.0f;
+        }
+
+        return true;
+    }
+
+private:
+    SkRect                fRect;
+    sk_sp<SkShader>       fDiffuseShader;
+    sk_sp<SkNormalSource> fNormalSource;
+
+    SkScalar              fLightAngle;
+    SkScalar              fColorFactor;
+
+    typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new LightingView; }
+static SkViewRegister reg(MyFactory);
diff --git a/samplecode/SampleLitAtlas.cpp b/samplecode/SampleLitAtlas.cpp
new file mode 100644
index 0000000000..9ca6df2aa0
--- /dev/null
+++ b/samplecode/SampleLitAtlas.cpp
@@ -0,0 +1,503 @@
+/*
+ * Copyright 2016 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 "SkBitmapProcShader.h"
+#include "SkCanvas.h"
+#include "SkDrawable.h"
+#include "SkLightingShader.h"
+#include "SkLights.h"
+#include "SkNormalSource.h"
+#include "SkRandom.h"
+#include "SkRSXform.h"
+#include "SkView.h"
+
+#include "sk_tool_utils.h"
+
+// A crude normal mapped asteroids-like sample
+class DrawLitAtlasDrawable : public SkDrawable {
+public:
+    DrawLitAtlasDrawable(const SkRect& r)
+            : fBounds(r)
+            , fUseColors(false)
+            , fLightDir(SkVector3::Make(1.0f, 0.0f, 0.0f)) {
+        fAtlas = MakeAtlas();
+
+        SkRandom rand;
+        for (int i = 0; i < kNumAsteroids; ++i) {
+            fAsteroids[i].initAsteroid(&rand, fBounds, &fDiffTex[i], &fNormTex[i]);
+        }
+
+        fShip.initShip(fBounds, &fDiffTex[kNumAsteroids], &fNormTex[kNumAsteroids]);
+
+        this->updateLights();
+    }
+
+    void toggleUseColors() {
+        fUseColors = !fUseColors;
+    }
+
+    void rotateLight() {
+        SkScalar c;
+        SkScalar s = SkScalarSinCos(SK_ScalarPI/6.0f, &c);
+
+        SkScalar newX = c * fLightDir.fX - s * fLightDir.fY;
+        SkScalar newY = s * fLightDir.fX + c * fLightDir.fY;
+
+        fLightDir.set(newX, newY, 0.0f);
+
+        this->updateLights();
+    }
+
+    void left() {
+        SkScalar newRot = SkScalarMod(fShip.rot() + (2*SK_ScalarPI - SK_ScalarPI/32.0f),
+                                      2 * SK_ScalarPI);
+        fShip.setRot(newRot);
+    }
+
+    void right() {
+        SkScalar newRot = SkScalarMod(fShip.rot() + SK_ScalarPI/32.0f, 2 * SK_ScalarPI);
+        fShip.setRot(newRot);
+    }
+
+    void thrust() {
+        SkScalar c;
+        SkScalar s = SkScalarSinCos(fShip.rot(), &c);
+
+        SkVector newVel = fShip.velocity();
+        newVel.fX += s;
+        newVel.fY += -c;
+
+        SkScalar len = newVel.length();
+        if (len > kMaxShipSpeed) {
+            newVel.setLength(SkIntToScalar(kMaxShipSpeed));
+        }
+
+        fShip.setVelocity(newVel);
+    }
+
+protected:
+    void onDraw(SkCanvas* canvas) override {
+        SkRSXform xforms[kNumAsteroids+kNumShips];
+        SkColor colors[kNumAsteroids+kNumShips];
+
+        for (int i = 0; i < kNumAsteroids; ++i) {
+            fAsteroids[i].advance(fBounds);
+            xforms[i] = fAsteroids[i].asRSXform();
+            if (fUseColors) {
+                colors[i] = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
+            }
+        }
+
+        fShip.advance(fBounds);
+        xforms[kNumAsteroids] = fShip.asRSXform();
+        if (fUseColors) {
+            colors[kNumAsteroids] = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
+        }
+
+#ifdef SK_DEBUG
+        canvas->drawBitmap(fAtlas, 0, 0); // just to see the atlas
+
+        this->drawLightDir(canvas, fBounds.centerX(), fBounds.centerY());
+#endif
+
+#if 0
+        // TODO: revitalize when drawLitAtlas API lands
+        SkPaint paint;
+        paint.setFilterQuality(kLow_SkFilterQuality);
+
+        const SkRect cull = this->getBounds();
+        const SkColor* colorsPtr = fUseColors ? colors : NULL;
+
+        canvas->drawLitAtlas(fAtlas, xforms, fDiffTex, fNormTex, colorsPtr, kNumAsteroids+1,
+                             SkXfermode::kModulate_Mode, &cull, &paint, fLights);
+#else
+        SkMatrix diffMat, normalMat;
+
+        for (int i = 0; i < kNumAsteroids+1; ++i) {
+            colors[i] = colors[i] & 0xFF000000; // to silence compilers
+            SkPaint paint;
+
+            SkRect r = fDiffTex[i];
+            r.offsetTo(0, 0);
+
+            diffMat.setRectToRect(fDiffTex[i], r, SkMatrix::kFill_ScaleToFit);
+            normalMat.setRectToRect(fNormTex[i], r, SkMatrix::kFill_ScaleToFit);
+
+            SkMatrix m;
+            m.setRSXform(xforms[i]);
+
+            sk_sp<SkShader> normalMap = SkShader::MakeBitmapShader(fAtlas, SkShader::kClamp_TileMode,
+                    SkShader::kClamp_TileMode, &normalMat);
+            sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(
+                    std::move(normalMap), m);
+            sk_sp<SkShader> diffuseShader = SkShader::MakeBitmapShader(fAtlas,
+                    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &diffMat);
+            paint.setShader(SkLightingShader::Make(std::move(diffuseShader),
+                    std::move(normalSource), fLights));
+
+            canvas->save();
+                canvas->setMatrix(m);
+                canvas->drawRect(r, paint);
+            canvas->restore();
+        }
+#endif
+
+#ifdef SK_DEBUG
+        {
+            SkPaint paint;
+            paint.setColor(SK_ColorRED);
+
+            for (int i = 0; i < kNumAsteroids; ++i) {
+                canvas->drawCircle(fAsteroids[i].pos().x(), fAsteroids[i].pos().y(), 2, paint);
+            }
+            canvas->drawCircle(fShip.pos().x(), fShip.pos().y(), 2, paint);
+
+            paint.setStyle(SkPaint::kStroke_Style);
+            canvas->drawRect(this->getBounds(), paint);
+        }
+#endif
+    }
+
+    SkRect onGetBounds() override {
+        return fBounds;
+    }
+
+private:
+
+    enum ObjType {
+        kBigAsteroid_ObjType = 0,
+        kMedAsteroid_ObjType,
+        kSmAsteroid_ObjType,
+        kShip_ObjType,
+
+        kLast_ObjType = kShip_ObjType
+    };
+
+    static const int kObjTypeCount = kLast_ObjType + 1;
+
+    void updateLights() {
+        SkLights::Builder builder;
+
+        builder.add(SkLights::Light::MakeDirectional(
+                SkColor3f::Make(1.0f, 1.0f, 1.0f), fLightDir));
+        builder.setAmbientLightColor(SkColor3f::Make(0.2f, 0.2f, 0.2f));
+
+        fLights = builder.finish();
+    }
+
+#ifdef SK_DEBUG
+    // Draw a vector to the light
+    void drawLightDir(SkCanvas* canvas, SkScalar centerX, SkScalar centerY) {
+        static const int kBgLen = 30;
+        static const int kSmLen = 5;
+
+        // TODO: change the lighting coordinate system to be right handed
+        SkPoint p1 = SkPoint::Make(centerX + kBgLen * fLightDir.fX,
+                                   centerY - kBgLen * fLightDir.fY);
+        SkPoint p2 = SkPoint::Make(centerX + (kBgLen-kSmLen) * fLightDir.fX,
+                                   centerY - (kBgLen-kSmLen) * fLightDir.fY);
+
+        SkPaint p;
+        canvas->drawLine(centerX, centerY, p1.fX, p1.fY, p);
+        canvas->drawLine(p1.fX, p1.fY,
+                         p2.fX - kSmLen * fLightDir.fY, p2.fY - kSmLen * fLightDir.fX, p);
+        canvas->drawLine(p1.fX, p1.fY,
+                         p2.fX + kSmLen * fLightDir.fY, p2.fY + kSmLen * fLightDir.fX, p);
+    }
+#endif
+
+    // Create the mixed diffuse & normal atlas
+    //
+    //    big color circle  |  big normal hemi
+    //    ------------------------------------
+    //    med color circle  |  med normal pyra
+    //    ------------------------------------
+    //    sm color circle   |   sm normal hemi
+    //    ------------------------------------
+    //    big ship          | big tetra normal
+    static SkBitmap MakeAtlas() {
+
+        SkBitmap atlas;
+        atlas.allocN32Pixels(kAtlasWidth, kAtlasHeight);
+
+        for (int y = 0; y < kAtlasHeight; ++y) {
+            int x = 0;
+            for ( ; x < kBigSize+kPad; ++x) {
+                *atlas.getAddr32(x, y) = SK_ColorTRANSPARENT;
+            }
+            for ( ; x < kAtlasWidth; ++x) {
+                *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0x88, 0x88, 0xFF);
+            }
+        }
+
+        // big asteroid
+        {
+            SkPoint bigCenter = SkPoint::Make(kDiffXOff + kBigSize/2.0f, kBigYOff + kBigSize/2.0f);
+
+            for (int y = kBigYOff; y < kBigYOff+kBigSize; ++y) {
+                for (int x = kDiffXOff; x < kDiffXOff+kBigSize; ++x) {
+                    SkScalar distSq = (x - bigCenter.fX) * (x - bigCenter.fX) +
+                                      (y - bigCenter.fY) * (y - bigCenter.fY);
+                    if (distSq > kBigSize*kBigSize/4.0f) {
+                        *atlas.getAddr32(x, y) = SkPreMultiplyARGB(0, 0, 0, 0);
+                    } else {
+                        *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0xFF, 0, 0);
+                    }
+                }
+            }
+
+            sk_tool_utils::create_hemi_normal_map(&atlas,
+                                                  SkIRect::MakeXYWH(kNormXOff, kBigYOff,
+                                                                    kBigSize, kBigSize));
+        }
+
+        // medium asteroid
+        {
+            for (int y = kMedYOff; y < kMedYOff+kMedSize; ++y) {
+                for (int x = kDiffXOff; x < kDiffXOff+kMedSize; ++x) {
+                    *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0xFF, 0);
+                }
+            }
+
+            sk_tool_utils::create_frustum_normal_map(&atlas,
+                                                     SkIRect::MakeXYWH(kNormXOff, kMedYOff,
+                                                                       kMedSize, kMedSize));
+        }
+
+        // small asteroid
+        {
+            SkPoint smCenter = SkPoint::Make(kDiffXOff + kSmSize/2.0f, kSmYOff + kSmSize/2.0f);
+
+            for (int y = kSmYOff; y < kSmYOff+kSmSize; ++y) {
+                for (int x = kDiffXOff; x < kDiffXOff+kSmSize; ++x) {
+                    SkScalar distSq = (x - smCenter.fX) * (x - smCenter.fX) +
+                                      (y - smCenter.fY) * (y - smCenter.fY);
+                    if (distSq > kSmSize*kSmSize/4.0f) {
+                        *atlas.getAddr32(x, y) = SkPreMultiplyARGB(0, 0, 0, 0);
+                    } else {
+                        *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0, 0xFF);
+                    }
+                }
+            }
+
+            sk_tool_utils::create_hemi_normal_map(&atlas,
+                                                  SkIRect::MakeXYWH(kNormXOff, kSmYOff,
+                                                                    kSmSize, kSmSize));
+        }
+
+        // ship
+        {
+            SkScalar shipMidLine = kDiffXOff + kMedSize/2.0f;
+
+            for (int y = kShipYOff; y < kShipYOff+kMedSize; ++y) {
+                SkScalar scaledY = (y - kShipYOff)/(float)kMedSize; // 0..1
+
+                for (int x = kDiffXOff; x < kDiffXOff+kMedSize; ++x) {
+                    SkScalar scaledX;
+
+                    if (x < shipMidLine) {
+                        scaledX = 1.0f - (x - kDiffXOff)/(kMedSize/2.0f); // 0..1
+                    } else {
+                        scaledX = (x - shipMidLine)/(kMedSize/2.0f);      // 0..1
+                    }
+
+                    if (scaledX < scaledY) {
+                        *atlas.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0xFF, 0xFF);
+                    } else {
+                        *atlas.getAddr32(x, y) = SkPackARGB32(0, 0, 0, 0);
+                    }
+                }
+            }
+
+            sk_tool_utils::create_tetra_normal_map(&atlas,
+                                                   SkIRect::MakeXYWH(kNormXOff, kShipYOff,
+                                                                     kMedSize, kMedSize));
+        }
+
+        return atlas;
+    }
+
+    class ObjectRecord {
+    public:
+        void initAsteroid(SkRandom *rand, const SkRect& bounds,
+                          SkRect* diffTex, SkRect* normTex) {
+            static const SkScalar gMaxSpeeds[3] = { 1, 2, 5 }; // smaller asteroids can go faster
+            static const SkScalar gYOffs[3] = { kBigYOff, kMedYOff, kSmYOff };
+            static const SkScalar gSizes[3] = { kBigSize, kMedSize, kSmSize };
+
+            static unsigned int asteroidType = 0;
+            fObjType = static_cast<ObjType>(asteroidType++ % 3);
+
+            fPosition.set(bounds.fLeft + rand->nextUScalar1() * bounds.width(),
+                          bounds.fTop + rand->nextUScalar1() * bounds.height());
+            fVelocity.fX = rand->nextSScalar1();
+            fVelocity.fY = sqrt(1.0f - fVelocity.fX * fVelocity.fX);
+            SkASSERT(SkScalarNearlyEqual(fVelocity.length(), 1.0f));
+            fVelocity *= gMaxSpeeds[fObjType];
+            fRot = 0;
+            fDeltaRot = rand->nextSScalar1() / 32;
+
+            diffTex->setXYWH(SkIntToScalar(kDiffXOff), gYOffs[fObjType],
+                             gSizes[fObjType], gSizes[fObjType]);
+            normTex->setXYWH(SkIntToScalar(kNormXOff), gYOffs[fObjType],
+                             gSizes[fObjType], gSizes[fObjType]);
+        }
+
+        void initShip(const SkRect& bounds, SkRect* diffTex, SkRect* normTex) {
+            fObjType = kShip_ObjType;
+            fPosition.set(bounds.centerX(), bounds.centerY());
+            fVelocity = SkVector::Make(0.0f, 0.0f);
+            fRot = 0.0f;
+            fDeltaRot = 0.0f;
+
+            diffTex->setXYWH(SkIntToScalar(kDiffXOff), SkIntToScalar(kShipYOff),
+                             SkIntToScalar(kMedSize), SkIntToScalar(kMedSize));
+            normTex->setXYWH(SkIntToScalar(kNormXOff), SkIntToScalar(kShipYOff),
+                             SkIntToScalar(kMedSize), SkIntToScalar(kMedSize));
+        }
+
+        void advance(const SkRect& bounds) {
+            fPosition += fVelocity;
+            if (fPosition.fX > bounds.right()) {
+                SkASSERT(fVelocity.fX > 0);
+                fVelocity.fX = -fVelocity.fX;
+            } else if (fPosition.fX < bounds.left()) {
+                SkASSERT(fVelocity.fX < 0);
+                fVelocity.fX = -fVelocity.fX;
+            }
+            if (fPosition.fY > bounds.bottom()) {
+                if (fVelocity.fY > 0) {
+                    fVelocity.fY = -fVelocity.fY;
+                }
+            } else if (fPosition.fY < bounds.top()) {
+                if (fVelocity.fY < 0) {
+                    fVelocity.fY = -fVelocity.fY;
+                }
+            }
+
+            fRot += fDeltaRot;
+            fRot = SkScalarMod(fRot, 2 * SK_ScalarPI);
+        }
+
+        const SkPoint& pos() const { return fPosition; }
+
+        SkScalar rot() const { return fRot; }
+        void setRot(SkScalar rot) { fRot = rot; }
+
+        const SkPoint& velocity() const { return fVelocity; }
+        void setVelocity(const SkPoint& velocity) { fVelocity = velocity; }
+
+        SkRSXform asRSXform() const {
+            static const SkScalar gHalfSizes[kObjTypeCount] = {
+                SkScalarHalf(kBigSize),
+                SkScalarHalf(kMedSize),
+                SkScalarHalf(kSmSize),
+                SkScalarHalf(kMedSize),
+            };
+
+            return SkRSXform::MakeFromRadians(1.0f, fRot, fPosition.x(), fPosition.y(),
+                                              gHalfSizes[fObjType],
+                                              gHalfSizes[fObjType]);
+        }
+
+    private:
+        ObjType     fObjType;
+        SkPoint     fPosition;
+        SkVector    fVelocity;
+        SkScalar    fRot;        // In radians.
+        SkScalar    fDeltaRot;   // In radiands. Not used by ship.
+    };
+
+private:
+    static const int kNumLights = 2;
+    static const int kNumAsteroids = 6;
+    static const int kNumShips = 1;
+
+    static const int kBigSize = 128;
+    static const int kMedSize = 64;
+    static const int kSmSize = 32;
+    static const int kPad = 1;
+    static const int kAtlasWidth = kBigSize + kBigSize + 2 * kPad; // 2 pads in the middle
+    static const int kAtlasHeight = kBigSize + kMedSize + kSmSize + kMedSize + 3 * kPad;
+
+    static const int kDiffXOff = 0;
+    static const int kNormXOff = kBigSize + 2 * kPad;
+
+    static const int kBigYOff = 0;
+    static const int kMedYOff = kBigSize + kPad;
+    static const int kSmYOff = kMedYOff + kMedSize + kPad;
+    static const int kShipYOff = kSmYOff + kSmSize + kPad;
+    static const int kMaxShipSpeed = 5;
+
+    SkBitmap        fAtlas;
+    ObjectRecord    fAsteroids[kNumAsteroids];
+    ObjectRecord    fShip;
+    SkRect          fDiffTex[kNumAsteroids+kNumShips];
+    SkRect          fNormTex[kNumAsteroids+kNumShips];
+    SkRect          fBounds;
+    bool            fUseColors;
+    SkVector3       fLightDir;
+    sk_sp<SkLights> fLights;
+
+    typedef SkDrawable INHERITED;
+};
+
+class DrawLitAtlasView : public SampleView {
+public:
+    DrawLitAtlasView() : fDrawable(new DrawLitAtlasDrawable(SkRect::MakeWH(640, 480))) {}
+
+protected:
+    bool onQuery(SkEvent* evt) override {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "DrawLitAtlas");
+            return true;
+        }
+        SkUnichar uni;
+        if (SampleCode::CharQ(*evt, &uni)) {
+            switch (uni) {
+                case 'C':
+                    fDrawable->toggleUseColors();
+                    return true;
+                case 'j':
+                    fDrawable->left();
+                    return true;
+                case 'k':
+                    fDrawable->thrust();
+                    return true;
+                case 'l':
+                    fDrawable->right();
+                    return true;
+                case 'o':
+                    fDrawable->rotateLight();
+                    return true;
+                default:
+                    break;
+            }
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        canvas->drawDrawable(fDrawable.get());
+    }
+
+    bool onAnimate(const SkAnimTimer& timer) override {
+        return true;
+    }
+
+private:
+    sk_sp<DrawLitAtlasDrawable> fDrawable;
+
+    typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkView* MyFactory() { return new DrawLitAtlasView; }
+static SkViewRegister reg(MyFactory);