add SkAnimTimer, SPACE = pause/resume, ESP = stop

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"
 #include "Resources.h"
 #include "SampleCode.h"
 #include "SamplePipeControllers.h"
+#include "SkAnimTimer.h"
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDevice.h"
 #include "SkDocument.h"
 #include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPaint.h"
@@ skipping 71 matching lines @@
 #define FPS_REPEAT_COUNT    (10 * FPS_REPEAT_MULTIPLIER)
 
 static SampleWindow* gSampleWindow;
 
 static bool gShowGMBounds;
 
 static void post_event_to_sink(SkEvent* evt, SkEventSink* sink) {
     evt->setTargetID(sink->getSinkID())->post();
 }
 
+static SkAnimTimer gAnimTimer;
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static const char* skip_until(const char* str, const char* skip) {
     if (!str) {
         return NULL;
     }
     return strstr(str, skip);
 }
 
 static const char* skip_past(const char* str, const char* skip) {
@@ skipping 455 matching lines @@
     size[1] = height;
     evt->setScalars(gPrefSizeEvtName, 2, size);
 }
 
 bool SampleCode::FastTextQ(const SkEvent& evt) {
     return evt.isType(gFastTextEvtName, sizeof(gFastTextEvtName) - 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkMSec gAnimTime;
-static SkMSec gAnimTimePrev;
-
-SkMSec SampleCode::GetAnimTime() { return gAnimTime; }
-SkMSec SampleCode::GetAnimTimeDelta() { return gAnimTime - gAnimTimePrev; }
-SkScalar SampleCode::GetAnimSecondsDelta() {
-    return SkDoubleToScalar(GetAnimTimeDelta() / 1000.0);
-}
-
-SkScalar SampleCode::GetAnimScalar(SkScalar speed, SkScalar period) {
-    // since gAnimTime can be up to 32 bits, we can't convert it to a float
-    // or we'll lose the low bits. Hence we use doubles for the intermediate
-    // calculations
-    double seconds = (double)gAnimTime / 1000.0;
-    double value = SkScalarToDouble(speed) * seconds;
-    if (period) {
-        value = ::fmod(value, SkScalarToDouble(period));
-    }
-    return SkDoubleToScalar(value);
-}
-
-SkScalar SampleCode::GetAnimSinScalar(SkScalar amplitude,
-                                      SkScalar periodInSec,
-                                      SkScalar phaseInSec) {
-    if (!periodInSec) {
-        return 0;
-    }
-    double t = (double)gAnimTime / 1000.0 + phaseInSec;
-    t *= SkScalarToFloat(2 * SK_ScalarPI) / periodInSec;
-    amplitude = SK_ScalarHalf * amplitude;
-    return SkScalarMul(amplitude, SkDoubleToScalar(sin(t))) + amplitude;
-}
-
 enum TilingMode {
     kNo_Tiling,
     kAbs_128x128_Tiling,
     kAbs_256x256_Tiling,
     kRel_4x4_Tiling,
     kRel_1x16_Tiling,
     kRel_16x1_Tiling,
 
     kLast_TilingMode_Enum
 };
@@ skipping 35 matching lines @@
             title->set(evt.findString(gTitleEvtName));
             return true;
         }
     }
     return false;
 }
 
 bool SampleWindow::sendAnimatePulse() {
     SkView* view = curr_view(this);
     if (SampleView::IsSampleView(view)) {
-        if (fDoAnimate) {
-            return ((SampleView*)view)->animatePulse(gAnimTime, gAnimTimePrev);
-        } else {
-            // 0 signals the view that we are no longer animating
-            ((SampleView*)view)->animatePulse(0, 0);
-        }
+        return ((SampleView*)view)->animate(gAnimTimer);
     }
     return false;
 }
 
 void SampleWindow::setZoomCenter(float x, float y)
 {
     fZoomCenterX = x;
     fZoomCenterY = y;
 }
 
@@ skipping 145 matching lines @@
 
     fDeviceType = kRaster_DeviceType;
 
 #if DEFAULT_TO_GPU
     fDeviceType = kGPU_DeviceType;
 #endif
 #if SK_ANGLE && DEFAULT_TO_ANGLE
     fDeviceType = kANGLE_DeviceType;
 #endif
 
-    fDoAnimate = true;
     fUseClip = false;
     fNClip = false;
     fAnimating = false;
     fRotate = false;
-    fRotateAnimTime = 0;
     fPerspAnim = false;
-    fPerspAnimTime = 0;
     fRequestGrabImage = false;
     fPipeState = SkOSMenu::kOffState;
     fTilingMode = kNo_Tiling;
     fMeasureFPS = false;
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
     fSubpixelState = SkOSMenu::kMixedState;
     fHintingState = 0;
     fFilterLevelIndex = 0;
     fFlipAxis = 0;
@@ skipping 110 matching lines @@
     // onSizeChange gets called.
     if (this->height() && this->width()) {
         this->onSizeChange();
     }
 
     // can't call this synchronously, since it may require a subclass to
     // to implement, or the caller may need us to have returned from the
     // constructor first. Hence we post an event to ourselves.
 //    this->updateTitle();
     post_event_to_sink(new SkEvent(gUpdateWindowTitleEvtName), this);
+
+    gAnimTimer.run();
 }
 
 SampleWindow::~SampleWindow() {
     SkSafeUnref(fTypeface);
     SkSafeUnref(fDevManager);
 }
 
 
 int SampleWindow::findByTitle(const char title[]) {
     int i, count = fSamples.count();
@@ skipping 56 matching lines @@
         canvas->drawText(c_str, size, left + SK_Scalar1, top + SK_Scalar1, paint);
     }
     paint.setColor(desiredColor);
     canvas->drawText(c_str, size, left, top, paint);
 }
 
 #define XCLIP_N  8
 #define YCLIP_N  8
 
 void SampleWindow::draw(SkCanvas* canvas) {
-    // update the animation time
-    if (!gAnimTimePrev && !gAnimTime) {
-        // first time make delta be 0
-        gAnimTime = SkTime::GetMSecs();
-        gAnimTimePrev = gAnimTime;
-    } else {
-        gAnimTimePrev = gAnimTime;
-        gAnimTime = SkTime::GetMSecs();
-    }
+    gAnimTimer.updateTime();
 
     if (fGesture.isActive()) {
         this->updateMatrix();
     }
 
     if (fMeasureFPS) {
         fMeasureFPS_Time = 0;
     }
 
     if (fNClip) {
@@ skipping 329 matching lines @@
     }
 
     // Do this after presentGL and other finishing, rather than in afterChild
     if (fMeasureFPS && fMeasureFPS_StartTime) {
         fMeasureFPS_Time += SkTime::GetMSecs() - fMeasureFPS_StartTime;
     }
 }
 
 void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) {
     if (fRotate) {
-        fRotateAnimTime += SampleCode::GetAnimSecondsDelta();
-
         SkScalar cx = this->width() / 2;
         SkScalar cy = this->height() / 2;
         canvas->translate(cx, cy);
-        canvas->rotate(fRotateAnimTime * 10);
+        canvas->rotate(gAnimTimer.scaled(10));
         canvas->translate(-cx, -cy);
     }
 
     if (fPerspAnim) {
-        fPerspAnimTime += SampleCode::GetAnimSecondsDelta();
+        SkScalar secs = gAnimTimer.scaled(1);
 
         static const SkScalar gAnimPeriod = 10 * SK_Scalar1;
         static const SkScalar gAnimMag = SK_Scalar1 / 1000;
-        SkScalar t = SkScalarMod(fPerspAnimTime, gAnimPeriod);
-        if (SkScalarFloorToInt(SkScalarDiv(fPerspAnimTime, gAnimPeriod)) & 0x1) {
+        SkScalar t = SkScalarMod(secs, gAnimPeriod);
+        if (SkScalarFloorToInt(SkScalarDiv(secs, gAnimPeriod)) & 0x1) {
             t = gAnimPeriod - t;
         }
         t = 2 * t - gAnimPeriod;
         t = SkScalarMul(SkScalarDiv(t, gAnimPeriod), gAnimMag);
         SkMatrix m;
         m.reset();
 #if 1
         m.setPerspY(t);
 #else
         m.setPerspY(SK_Scalar1 / 1000);
@@ skipping 225 matching lines @@
         SkEvent evt(gFastTextEvtName);
         return curr_view(this)->doQuery(&evt);
     }
     if (query->isType("ignore-window-bitmap")) {
         query->setFast32(this->getGrContext() != NULL);
         return true;
     }
     return this->INHERITED::onQuery(query);
 }
 
-#if 0 // UNUSED
-static void cleanup_for_filename(SkString* name) {
-    char* str = name->writable_str();
-    for (size_t i = 0; i < name->size(); i++) {
-        switch (str[i]) {
-            case ':': str[i] = '-'; break;
-            case '/': str[i] = '-'; break;
-            case ' ': str[i] = '_'; break;
-            default: break;
-        }
-    }
-}
-#endif
-
 DECLARE_bool(portableFonts);
 
 bool SampleWindow::onHandleChar(SkUnichar uni) {
     {
         SkView* view = curr_view(this);
         if (view) {
             SkEvent evt(gCharEvtName);
             evt.setFast32(uni);
             if (view->doQuery(&evt)) {
                 return true;
@@ skipping 24 matching lines @@
             fScrollTestX = fScrollTestY = 0;
         } else {
             fScrollTestX += dx;
             fScrollTestY += dy;
         }
         this->inval(NULL);
         return true;
     }
 
     switch (uni) {
-        case ' ':
-            fDoAnimate = !fDoAnimate;
+        case 27:    // ESC
+            gAnimTimer.stop();
             if (this->sendAnimatePulse()) {
                 this->inval(NULL);
             }
+            break;
+        case ' ':
+            gAnimTimer.togglePauseResume();
+            if (this->sendAnimatePulse()) {
+                this->inval(NULL);
+            }
             break;
         case 'B':
             post_event_to_sink(SkNEW_ARGS(SkEvent, ("PictFileView::toggleBBox")), curr_view(this));
             // Cannot call updateTitle() synchronously, because the toggleBBox event is still in
             // the queue.
             post_event_to_sink(SkNEW_ARGS(SkEvent, (gUpdateWindowTitleEvtName)), this);
             this->inval(NULL);
             break;
         case 'D':
             toggleDistanceFieldFonts();
@@ skipping 17 matching lines @@
             this->inval(NULL);
             break;
         case 'i':
             this->zoomIn();
             break;
         case 'o':
             this->zoomOut();
             break;
         case 'r':
             fRotate = !fRotate;
-            fRotateAnimTime = 0;
             this->inval(NULL);
             this->updateTitle();
             return true;
         case 'k':
             fPerspAnim = !fPerspAnim;
             this->inval(NULL);
             this->updateTitle();
             return true;
 #if SK_SUPPORT_GPU
         case '\\':
@@ skipping 661 matching lines @@
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }