add SkCanvas::drawAtlas

samplecode/SampleAtlas.cpp

Index: samplecode/SampleAtlas.cpp
diff --git a/samplecode/SampleAtlas.cpp b/samplecode/SampleAtlas.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40a1dffff2e19a7a88dd231167f3c93238a6c65c
--- /dev/null
+++ b/samplecode/SampleAtlas.cpp
@@ -0,0 +1,203 @@
+/*
+ * 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 "SampleCode.h"
+#include "SkAnimTimer.h"
+#include "SkView.h"
+#include "SkCanvas.h"
+#include "SkDrawable.h"
+#include "SkPath.h"
+#include "SkRandom.h"
+#include "SkRSXform.h"
+#include "SkSurface.h"
+
+static SkImage* make_atlas() {

[robertphillips, 2015/06/15 16:12:55]

defined kAtlasSize as 512 somewhere and pass it in ?

[reed1, 2015/06/15 18:52:33]

Acknowledged.

+    static int N = 512;
+    SkImageInfo info = SkImageInfo::MakeN32Premul(N, N);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
+    SkCanvas* canvas = surface->getCanvas();
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    SkRandom rand;
+

[robertphillips, 2015/06/15 16:12:55]

const int kCellSize = 32;
const SkScalar kHalf = kCellSize/2.0f;

?

[reed1, 2015/06/15 18:52:33]

Acknowledged.

+    const SkScalar half = 16;
+    const char* s = "01234567890!@#$%^&*=+<>?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    paint.setTextSize(28);
+    paint.setTextAlign(SkPaint::kCenter_Align);
+    int i = 0;
+    for (int y = 0; y < N; y += 32) {
+        for (int x = 0; x < N; x += 32) {
+            paint.setColor(rand.nextU());
+            paint.setAlpha(0xFF);
+            int index = i % strlen(s);
+            canvas->drawText(&s[index], 1, x + half, y + half + half/2, paint);
+            i += 1;
+        }
+    }
+    return surface->newImageSnapshot();
+}
+
+class DrawAtlasDrawable : public SkDrawable {
+    struct Rec {
+        SkPoint     fCenter;
+        SkVector    fVelocity;
+        SkScalar    fScale;
+        SkScalar    fDScale;
+        SkScalar    fRadian;
+        SkScalar    fDRadian;
+        SkScalar    fAlpha;
+        SkScalar    fDAlpha;
+
+        void advance(const SkRect& bounds) {
+            fCenter += fVelocity;
+            if (fCenter.fX > bounds.right()) {
+                SkASSERT(fVelocity.fX > 0);
+                fVelocity.fX = -fVelocity.fX;
+            } else if (fCenter.fX < bounds.left()) {
+                SkASSERT(fVelocity.fX < 0);
+                fVelocity.fX = -fVelocity.fX;
+            }
+            if (fCenter.fY > bounds.bottom()) {
+                SkASSERT(fVelocity.fY > 0);
+                fVelocity.fY = -fVelocity.fY;
+            } else if (fCenter.fY < bounds.top()) {
+                SkASSERT(fVelocity.fY < 0);
+                fVelocity.fY = -fVelocity.fY;
+            }
+
+            fScale += fDScale;

[robertphillips, 2015/06/15 16:12:54]

SK_ScalarHalf ?

[reed1, 2015/06/15 18:52:33]

Not sure. I was playing around with the 2 & 1/2

+            if (fScale > 2 || fScale < SK_Scalar1/2) {
+                fDScale = -fDScale;
+            }
+
+            fRadian += fDRadian;
+            fRadian = SkScalarMod(fRadian, 2 * SK_ScalarPI);
+
+            fAlpha += fDAlpha;
+            if (fAlpha > 1) {
+                fAlpha = 1;
+                fDAlpha = -fDAlpha;
+            } else if (fAlpha < 0) {
+                fAlpha = 0;
+                fDAlpha = -fDAlpha;
+            }
+        }
+        
+        SkRSXform asRSXform() const {
+            SkMatrix m;
+            m.setTranslate(-8, -8);
+            m.postScale(fScale, fScale);
+            m.postRotate(SkRadiansToDegrees(fRadian));
+            m.postTranslate(fCenter.fX, fCenter.fY);
+
+            SkRSXform x;
+            x.fSCos = m.getScaleX();
+            x.fSSin = m.getSkewY();
+            x.fTx = m.getTranslateX();
+            x.fTy = m.getTranslateY();
+            return x;
+        }
+    };
+
+    enum {
+        N = 256,
+    };
+
+    SkAutoTUnref<SkImage> fAtlas;
+    Rec         fRec[N];
+    SkRect      fTex[N];
+    SkRect      fBounds;
+    
+public:
+    DrawAtlasDrawable(const SkRect& r) : fBounds(r) {
+        SkRandom rand;
+        fAtlas.reset(make_atlas());
+        const SkScalar half = 8;
+        const SkScalar speed = 5;
+        int i = 0;

[robertphillips, 2015/06/15 16:12:54]

512 -> kAtlasSize ?
32 -> kCellSize ?

[reed1, 2015/06/15 18:52:33]

Acknowledged.

+        for (int y = 0; y < 512; y += 32) {
+            for (int x = 0; x < 512; x += 32) {

[robertphillips, 2015/06/15 16:12:55]

SkASSERT(i < N); ?

[reed1, 2015/06/15 18:52:33]

Acknowledged.

+                fTex[i].setXYWH(x, y, 32, 32);
+                
+                fRec[i].fCenter.set(x/2 + half, y/2 + half);
+                fRec[i].fVelocity.fX = rand.nextSScalar1() * speed;
+                fRec[i].fVelocity.fY = rand.nextSScalar1() * speed;
+                fRec[i].fScale = 1;
+                fRec[i].fDScale = rand.nextSScalar1() / 4;
+                fRec[i].fRadian = 0;
+                fRec[i].fDRadian = rand.nextSScalar1() / 8;
+                fRec[i].fAlpha = rand.nextUScalar1();
+                fRec[i].fDAlpha = rand.nextSScalar1() / 10;
+                i += 1;
+            }
+        }

[robertphillips, 2015/06/15 16:12:54]

Rm this debugf ?

+        SkDebugf("total %d\n", i);
+    }
+    
+    void onDraw(SkCanvas* canvas) override {
+        SkRSXform xform[N];
+        SkColor colors[N];
+
+        for (int i = 0; i < N; ++i) {
+            fRec[i].advance(fBounds);
+            xform[i] = fRec[i].asRSXform();
+            colors[i] = SkColorSetARGB(fRec[i].fAlpha * 0xFF, 0xFF, 0xFF, 0xFF);
+        }
+        SkPaint paint;
+        paint.setFilterQuality(kLow_SkFilterQuality);
+        paint.setAntiAlias(true);
+        canvas->drawAtlas(fAtlas, xform, fTex, colors, N, NULL, &paint);
+    }
+    
+    SkRect onGetBounds() override {

[robertphillips, 2015/06/15 16:12:54]

Why not just fBounds ?

[reed1, 2015/06/15 18:52:33]

bounds outset by max scale * max cell radius

+        return SkRect::MakeLTRB(-1000, -1000, 1000, 1000);
+    }

[robertphillips, 2015/06/15 16:12:55]

private:
    typedef  SkDrawable INHERITED;

?

[reed1, 2015/06/15 18:52:33]

Done.

+};
+
+class DrawAtlasView : public SampleView {
+    SkDrawable* fDrawable;
+
+public:
+    DrawAtlasView() {
+        fDrawable = new DrawAtlasDrawable(SkRect::MakeWH(640, 480));
+    }
+
+    virtual ~DrawAtlasView() override {
+        fDrawable->unref();
+    }
+
+protected:
+    bool onQuery(SkEvent* evt) override {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "DrawAtlas");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void onDrawContent(SkCanvas* canvas) override {
+        canvas->drawDrawable(fDrawable);
+        this->inval(NULL);
+    }
+

[robertphillips, 2015/06/15 16:12:54]

Shouldn't we be using this ?

+#if 0
+    bool onAnimate(const SkAnimTimer& timer) override {
+        SkScalar angle = SkDoubleToScalar(fmod(timer.secs() * 360 / 24, 360));
+        fAnimatingDrawable->setSweep(angle);
+        return true;
+    }
+#endif
+
+private:
+    typedef SampleView INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+

[robertphillips, 2015/06/15 16:12:55]

We don't have a macro for this ?

+static SkView* MyFactory() { return new DrawAtlasView; }
+static SkViewRegister reg(MyFactory);