Force tiles in SampleApp to integer boundaries.

samplecode/SampleApp.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 858 matching lines @@
     fPerspAnim = false;
     fRequestGrabImage = false;
     fTilingMode = kNo_Tiling;
     fMeasureFPS = false;
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
     fSubpixelState = SkOSMenu::kMixedState;
     fHintingState = 0;
     fFilterQualityIndex = 0;
     fFlipAxis = 0;
-    fScrollTestX = fScrollTestY = 0;
 
     fMouseX = fMouseY = 0;
     fFatBitsScale = 8;
     fTypeface = SkTypeface::CreateFromTypeface(nullptr, SkTypeface::kBold);
     fShowZoomer = false;
 
     fZoomLevel = 0;
     fZoomScale = SK_Scalar1;
+    fOffset = { 0, 0 };
 
     fMagnify = false;
 
     fSaveToPdf = false;
     fSaveToSKP = false;
 
     int sinkID = this->getSinkID();
     fAppMenu = new SkOSMenu;
     fAppMenu->setTitle("Global Settings");
     int itemID;
@@ skipping 157 matching lines @@
 
     if (fMeasureFPS) {
         fMeasureFPS_Time = 0;
     }
 
     SkSize tile = this->tileSize();
 
     if (kNo_Tiling == fTilingMode) {
         this->INHERITED::draw(canvas); // no looping or surfaces needed
     } else {
-        const int w = SkScalarRoundToInt(tile.width());
-        const int h = SkScalarRoundToInt(tile.height());
-        SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
+        const SkScalar w = SkScalarCeilToScalar(tile.width());
+        const SkScalar h = SkScalarCeilToScalar(tile.height());
+        SkImageInfo info = SkImageInfo::MakeN32Premul(SkScalarTruncToInt(w), SkScalarTruncToInt(h));
         SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
         SkCanvas* tileCanvas = surface->getCanvas();
 
-        for (SkScalar y = 0; y < height(); y += tile.height()) {
-            for (SkScalar x = 0; x < width(); x += tile.width()) {
+        for (SkScalar y = 0; y < height(); y += h) {
+            for (SkScalar x = 0; x < width(); x += w) {
                 SkAutoCanvasRestore acr(tileCanvas, true);
                 tileCanvas->translate(-x, -y);

[bungeman-skia, 2016/03/03 22:42:37]

Just to make things more clear, when x and y are not integers this means that
the pixel at the origin of the canvas is no longer at an integer position. Every
calculation will be shifted by the fractional part, resulting in rounding being
out of phase from the rounding if the same were drawn with a slightly different
fractional part.

                 tileCanvas->clear(0);
                 this->INHERITED::draw(tileCanvas);
                 surface->draw(canvas, x, y, nullptr);
             }
         }
 
         // for drawing the borders between tiles
         SkPaint paint;
         paint.setColor(0x60FF00FF);
         paint.setStyle(SkPaint::kStroke_Style);
@@ skipping 370 matching lines @@
         (void)SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT);
         fTimer.start();
     } else {
         (void)SampleView::SetRepeatDraw(child, 1);
     }
     if (fPerspAnim || fRotate) {
         this->inval(nullptr);
     }
 }
 
+void SampleWindow::changeOffset(SkVector delta) {
+    fOffset += delta;
+    this->updateMatrix();
+}
+
 void SampleWindow::changeZoomLevel(float delta) {
     fZoomLevel += delta;
     if (fZoomLevel > 0) {
         fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL);
         fZoomScale = fZoomLevel + SK_Scalar1;
     } else if (fZoomLevel < 0) {
         fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL);
         fZoomScale = SK_Scalar1 / (SK_Scalar1 - fZoomLevel);
     } else {
         fZoomScale = SK_Scalar1;
     }
     this->updateMatrix();
 }
 
 void SampleWindow::updateMatrix(){
     SkMatrix m;
     m.reset();
+
     if (fZoomLevel) {
         SkPoint center;
         //m = this->getLocalMatrix();//.invert(&m);
         m.mapXY(fZoomCenterX, fZoomCenterY, &center);
         SkScalar cx = center.fX;
         SkScalar cy = center.fY;
 
         m.setTranslate(-cx, -cy);
         m.postScale(fZoomScale, fZoomScale);
         m.postTranslate(cx, cy);
     }
 
+    m.postTranslate(fOffset.fX, fOffset.fY);
+
     if (fFlipAxis) {
         m.preTranslate(fZoomCenterX, fZoomCenterY);
         if (fFlipAxis & kFlipAxis_X) {
             m.preScale(-SK_Scalar1, SK_Scalar1);
         }
         if (fFlipAxis & kFlipAxis_Y) {
             m.preScale(SK_Scalar1, -SK_Scalar1);
         }
         m.preTranslate(-fZoomCenterX, -fZoomCenterY);
         //canvas->concat(m);
@@ skipping 174 matching lines @@
         case '7': dx = -1; dy = -1; break;
         case '9': dx =  1; dy = -1; break;
         case '3': dx =  1; dy =  1; break;
         case '1': dx = -1; dy =  1; break;
 
         default:
             break;
     }
 
     if (0xFF != dx && 0xFF != dy) {
-        if ((dx | dy) == 0) {
-            fScrollTestX = fScrollTestY = 0;
-        } else {
-            fScrollTestX += dx;
-            fScrollTestY += dy;
-        }
-        this->inval(nullptr);
+        this->changeOffset({SkIntToScalar(dx / 32.0f), SkIntToScalar(dy / 32.0f)});
         return true;
     }
 
     switch (uni) {
         case 27:    // ESC
             gAnimTimer.stop();
             if (this->sendAnimatePulse()) {
                 this->inval(nullptr);
             }
             break;
@@ skipping 143 matching lines @@
     {
         SkView* view = curr_view(this);
         if (view) {
             SkEvent evt(gKeyEvtName);
             evt.setFast32(key);
             if (view->doQuery(&evt)) {
                 return true;
             }
         }
     }
+
+    int dx = 0xFF;
+    int dy = 0xFF;
+
     switch (key) {
         case kRight_SkKey:
             if (this->nextSample()) {
                 return true;
             }
             break;
         case kLeft_SkKey:
             if (this->previousSample()) {
                 return true;
             }
             return true;
         case kUp_SkKey:
             this->changeZoomLevel(1.f / 32.f);
             return true;
         case kDown_SkKey:
             this->changeZoomLevel(-1.f / 32.f);
             return true;
         case kOK_SkKey: {
             SkString title;
             if (curr_title(this, &title)) {
                 writeTitleToPrefs(title.c_str());
             }
             return true;
         }
         case kBack_SkKey:
             this->showOverview();
             return true;
+
+        case k5_SkKey: dx =  0; dy =  0; break;
+        case k8_SkKey: dx =  0; dy = -1; break;
+        case k6_SkKey: dx =  1; dy =  0; break;
+        case k2_SkKey: dx =  0; dy =  1; break;
+        case k4_SkKey: dx = -1; dy =  0; break;
+        case k7_SkKey: dx = -1; dy = -1; break;
+        case k9_SkKey: dx =  1; dy = -1; break;
+        case k3_SkKey: dx =  1; dy =  1; break;
+        case k1_SkKey: dx = -1; dy =  1; break;
+
         default:
             break;
     }
+
+    if (0xFF != dx && 0xFF != dy) {
+        this->changeOffset({SkIntToScalar(dx / 32.0f), SkIntToScalar(dy / 32.0f)});
+        return true;
+    }
+
     return this->INHERITED::onHandleKey(key);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char gGestureClickType[] = "GestureClickType";
 
 bool SampleWindow::onDispatchClick(int x, int y, Click::State state,
         void* owner, unsigned modi) {
     if (Click::kMoved_State == state) {
@@ skipping 143 matching lines @@
     }
 
     title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
     title.prepend(trystate_str(fAAState, "AA ", "aa "));
     title.prepend(gFilterQualityStates[fFilterQualityIndex].fLabel);
     title.prepend(trystate_str(fSubpixelState, "S ", "s "));
     title.prepend(fFlipAxis & kFlipAxis_X ? "X " : nullptr);
     title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : nullptr);
     title.prepend(gHintingStates[fHintingState].label);
 
+    if (fOffset.fX || fOffset.fY) {
+        title.prependf("(%.2f, %.2f) ", SkScalarToFloat(fOffset.fX), SkScalarToFloat(fOffset.fY));
+    }
     if (fZoomLevel) {
         title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
     }
 
     if (fMeasureFPS) {
         title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
     }
 
 #if SK_SUPPORT_GPU
     if (IsGpuDeviceType(fDeviceType) &&
@@ skipping 242 matching lines @@
 #ifdef SK_BUILD_FOR_MAC
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
 }