simulate drawatlas

samplecode/SampleAtlas.cpp

 /*
  * 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"
 
+typedef void (*DrawAtlasProc)(SkCanvas*, SkImage*, const SkRSXform[], const SkRect[],
+                              const SkColor[], int, const SkRect*, const SkPaint*);
+
+static void draw_atlas(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],
+                       const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
+                       const SkPaint* paint) {
+    canvas->drawAtlas(atlas, xform, tex, colors, count, SkXfermode::kModulate_Mode, cull, paint);
+}
+
+static void draw_atlas_sim(SkCanvas* canvas, SkImage* atlas, const SkRSXform xform[],

[robertphillips, 2015/08/06 12:11:55]

\n ?

+                           const SkRect tex[], const SkColor colors[], int count, const SkRect* cull,
+                           const SkPaint* paint) {
+    for (int i = 0; i < count; ++i) {
+        SkMatrix matrix;
+        matrix.setRSXform(xform[i]);
+        
+        canvas->save();
+        canvas->concat(matrix);
+        canvas->drawImageRect(atlas, &tex[i], tex[i].makeOffset(-tex[i].x(), -tex[i].y()), paint);
+        canvas->restore();
+    }
+}
+
 static SkImage* make_atlas(int atlasSize, int cellSize) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(atlasSize, atlasSize);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
     SkCanvas* canvas = surface->getCanvas();
 
     SkPaint paint;
     paint.setAntiAlias(true);
     SkRandom rand;
 
     const SkScalar half = cellSize * SK_ScalarHalf;
@@ skipping 66 matching lines @@
                 fDAlpha = -fDAlpha;
             }
         }
         
         SkRSXform asRSXform() const {
             return SkRSXform::MakeFromRadians(fScale, fRadian, fCenter.x(), fCenter.y(),
                                               SkScalarHalf(kCellSize), SkScalarHalf(kCellSize));
         }
     };
 
+    DrawAtlasProc fProc;
+
     enum {
         N = 256,
     };
 
     SkAutoTUnref<SkImage> fAtlas;
     Rec         fRec[N];
     SkRect      fTex[N];
     SkRect      fBounds;
     bool        fUseColors;
 
 public:
-    DrawAtlasDrawable(const SkRect& r) : fBounds(r), fUseColors(false) {
+    DrawAtlasDrawable(DrawAtlasProc proc, const SkRect& r)
+        : fProc(proc), fBounds(r), fUseColors(false)
+    {
         SkRandom rand;
         fAtlas.reset(make_atlas(kAtlasSize, kCellSize));
         const SkScalar kMaxSpeed = 5;
         const SkScalar cell = SkIntToScalar(kCellSize);
         int i = 0;
         for (int y = 0; y < kAtlasSize; y += kCellSize) {
             for (int x = 0; x < kAtlasSize; x += kCellSize) {
                 const SkScalar sx = SkIntToScalar(x);
                 const SkScalar sy = SkIntToScalar(y);
                 fTex[i].setXYWH(sx, sy, cell, cell);
@@ skipping 26 matching lines @@
             xform[i] = fRec[i].asRSXform();
             if (fUseColors) {
                 colors[i] = SkColorSetARGB((int)(fRec[i].fAlpha * 0xFF), 0xFF, 0xFF, 0xFF);
             }
         }
         SkPaint paint;
         paint.setFilterQuality(kLow_SkFilterQuality);
 
         const SkRect cull = this->getBounds();
         const SkColor* colorsPtr = fUseColors ? colors : NULL;
-        canvas->drawAtlas(fAtlas, xform, fTex, colorsPtr, N, SkXfermode::kModulate_Mode,
-                          &cull, &paint);
+        fProc(canvas, fAtlas, xform, fTex, colorsPtr, N, &cull, &paint);
     }
     
     SkRect onGetBounds() override {
         const SkScalar border = kMaxScale * kCellSize;
         SkRect r = fBounds;
         r.outset(border, border);
         return r;
     }
 
 private:
     typedef SkDrawable INHERITED;
 };
 
 class DrawAtlasView : public SampleView {
-    DrawAtlasDrawable* fDrawable;
+    const char*         fName;
+    DrawAtlasDrawable*  fDrawable;
 
 public:
-    DrawAtlasView() {
-        fDrawable = new DrawAtlasDrawable(SkRect::MakeWH(640, 480));
+    DrawAtlasView(const char name[], DrawAtlasProc proc) : fName(name) {
+        fDrawable = new DrawAtlasDrawable(proc, SkRect::MakeWH(640, 480));
     }
 
     ~DrawAtlasView() override {
         fDrawable->unref();
     }
 
 protected:
     bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
-            SampleCode::TitleR(evt, "DrawAtlas");
+            SampleCode::TitleR(evt, fName);
             return true;
         }
         SkUnichar uni;
         if (SampleCode::CharQ(*evt, &uni)) {
             switch (uni) {
                 case 'C': fDrawable->toggleUseColors(); this->inval(NULL); return true;
                 default: break;
             }
         }
         return this->INHERITED::onQuery(evt);
@@ skipping 12 matching lines @@
         return true;
     }
 #endif
 
 private:
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
-static SkView* MyFactory() { return new DrawAtlasView; }
-static SkViewRegister reg(MyFactory);
+DEF_SAMPLE( return new DrawAtlasView("DrawAtlas", draw_atlas); )
+DEF_SAMPLE( return new DrawAtlasView("DrawAtlasSim", draw_atlas_sim); )