--- /dev/null
+/*
+ * 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 "SkTime.h"
+
+#ifndef SkAnimTimer_DEFINED
+#define SkAnimTimer_DEFINED
+
+/**
+ * Class to track a "timer". It supports 3 states: stopped, paused, running.
+ *
+ * The caller must call updateTime() to resync with the clock (typically just before
+ * using the timer). Forcing the caller to do this ensures that the timer's return values
+ * are consistent if called repeatedly, as they only reflect the time since the last
+ * calle to updateTimer().
+ */
+class SkAnimTimer {
+public:
+ enum State {
+ kStopped_State,
+ kPaused_State,
+ kRunning_State
+ };
+
+ /**
+ * Class begins in the "stopped" state.
+ */
+ SkAnimTimer() : fBaseTime(0), fCurrTime(0), fState(kStopped_State) {}
+
+ bool isStopped() const { return kStopped_State == fState; }
+ bool isRunning() const { return kRunning_State == fState; }
+ bool isPaused() const { return kPaused_State == fState; }
+
+ /**
+ * Stops the timer, and resets it, such that the next call to run or togglePauseResume
+ * will begin at time 0.
+ */
+ void stop() {
+ this->setState(kStopped_State);
+ }
+
+ /**
+ * If the timer is paused or stopped, it will resume (or start if it was stopped).
+ */
+ void run() {
+ this->setState(kRunning_State);
+ }
+
+ /**
+ * If the timer is stopped, this has no effect, else it toggles between paused and running.
+ */
+ void togglePauseResume() {
+ if (kRunning_State == fState) {
+ this->setState(kPaused_State);
+ } else {
+ this->setState(kRunning_State);
+ }
+ }
+
+ /**
+ * Call this each time you want to sample the clock for the timer. This is NOT done
+ * automatically, so that repeated calls to msec() or secs() will always return the
+ * same value.
+ *
+ * This may safely be called with the timer in any state.
+ */
+ void updateTime() {
+ if (kRunning_State == fState) {
+ fCurrTime = SkTime::GetMSecs();
+ }
+ }
+
+ /**
+ * Return the time in milliseconds the timer has been in the running state.
+ * Returns 0 if the timer is stopped.
+ */
+ SkMSec msec() const { return fCurrTime - fBaseTime; }
+
+ /**
+ * Return the time in seconds the timer has been in the running state.
+ * Returns 0 if the timer is stopped.
+ */
+ double secs() const {
+ return this->msec() * 0.001;
+ }
+
+ /**
+ * Return the time in seconds the timer has been in the running state,
+ * scaled by "speed" and (if not zero) mod by period.
+ * Returns 0 if the timer is stopped.
+ */
+ SkScalar scaled(SkScalar speed, SkScalar period = 0) const {
+ double value = this->secs() * speed;
+ if (period) {
+ value = ::fmod(value, SkScalarToDouble(period));
+ }
+ return SkDoubleToScalar(value);
+ }
+
+private:
+ SkMSec fBaseTime;
+ SkMSec fCurrTime;
+ State fState;
+
+ void setState(State newState) {
+ switch (newState) {
+ case kStopped_State:
+ fBaseTime = fCurrTime = 0;
+ fState = kStopped_State;
+ break;
+ case kPaused_State:
+ if (kRunning_State == fState) {
+ fState = kPaused_State;
+ } // else stay stopped or paused
+ break;
+ case kRunning_State:
+ switch (fState) {
+ case kStopped_State:
+ fBaseTime = fCurrTime = SkTime::GetMSecs();
+ break;
+ case kPaused_State: {// they want "resume"
+ SkMSec now = SkTime::GetMSecs();
+ fBaseTime += now - fCurrTime;
+ fCurrTime = now;
+ } break;
+ case kRunning_State:
+ break;
+ }
+ fState = kRunning_State;
+ break;
+ }
+ }
+};
+
+#endif
*/
#include "gm.h"
+#include "SkAnimTimer.h"
#include "SkCanvas.h"
#include "SkRandom.h"
}
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fRotate = SkDoubleToScalar(fmod(curr * 0.001, 360));
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ fRotate = timer.scaled(1, 360);
return true;
}
fBGColor = color;
}
-bool GM::animatePulse(SkMSec curr, SkMSec prev) {
- return this->onAnimatePulse(curr, prev);
+bool GM::animate(const SkAnimTimer& timer) {
+ return this->onAnimate(timer);
}
/////////////////////////////////////////////////////////////////////////////////////////////
#include "SkTRegistry.h"
#include "sk_tool_utils.h"
+class SkAnimTimer;
+
#if SK_SUPPORT_GPU
#include "GrContext.h"
#endif
fStarterMatrix = matrix;
}
- bool animatePulse(SkMSec curr, SkMSec prev);
+ bool animate(const SkAnimTimer&);
protected:
/** draws a standard message that the GM is only intended to be used with the GPU.*/
virtual SkISize onISize() = 0;
virtual SkString onShortName() = 0;
- virtual bool onAnimatePulse(SkMSec curr, SkMSec prev) { return false; }
+ virtual bool onAnimate(const SkAnimTimer&) { return false; }
virtual SkMatrix onGetInitialTransform() const { return SkMatrix::I(); }
private:
fGM->drawBackground(canvas);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- return fGM->animatePulse(curr, prev);
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ return fGM->animate(timer);
}
private:
-
/*
* Copyright 2012 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 "SkBlurMaskFilter.h"
#include "SkColorPriv.h"
#include "SkCanvas.h"
#include "SkRandom.h"
-SkScalar get_anim_sin(SkMSec time, SkScalar amplitude, SkScalar periodInSec, SkScalar phaseInSec) {
+SkScalar get_anim_sin(double secs, SkScalar amplitude, SkScalar periodInSec, SkScalar phaseInSec) {
if (!periodInSec) {
return 0;
}
- double t = (double)time / 1000.0 + phaseInSec;
+ double t = secs + phaseInSec;
t *= SkScalarToFloat(2 * SK_ScalarPI) / periodInSec;
amplitude = SK_ScalarHalf * amplitude;
return amplitude * SkDoubleToScalar(sin(t)) + amplitude;
}
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fBlurSigma = get_anim_sin(curr, 100, 4, 5);
- fCircleRadius = 3 + get_anim_sin(curr, 150, 25, 3);
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ fBlurSigma = get_anim_sin(timer.secs(), 100, 4, 5);
+ fCircleRadius = 3 + get_anim_sin(timer.secs(), 150, 25, 3);
return true;
}
#include "Resources.h"
#include "SampleCode.h"
#include "SamplePipeControllers.h"
+#include "SkAnimTimer.h"
#include "SkCanvas.h"
#include "SkCommandLineFlags.h"
#include "SkData.h"
evt->setTargetID(sink->getSinkID())->post();
}
+static SkAnimTimer gAnimTimer;
+
///////////////////////////////////////////////////////////////////////////////
static const char* skip_until(const char* str, const char* skip) {
///////////////////////////////////////////////////////////////////////////////
-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,
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;
}
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;
// constructor first. Hence we post an event to ourselves.
// this->updateTitle();
post_event_to_sink(new SkEvent(gUpdateWindowTitleEvtName), this);
+
+ gAnimTimer.run();
}
SampleWindow::~SampleWindow() {
#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();
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;
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) {
}
switch (uni) {
+ case 27: // ESC
+ gAnimTimer.stop();
+ if (this->sendAnimatePulse()) {
+ this->inval(NULL);
+ }
+ break;
case ' ':
- fDoAnimate = !fDoAnimate;
+ gAnimTimer.togglePauseResume();
if (this->sendAnimatePulse()) {
this->inval(NULL);
}
break;
case 'r':
fRotate = !fRotate;
- fRotateAnimTime = 0;
this->inval(NULL);
this->updateTitle();
return true;
bool fSaveToPdf;
SkAutoTUnref<SkDocument> fPDFDocument;
- bool fDoAnimate;
bool fUseClip;
bool fNClip;
bool fAnimating;
bool fRotate;
- SkScalar fRotateAnimTime;
bool fPerspAnim;
- SkScalar fPerspAnimTime;
bool fRequestGrabImage;
bool fMeasureFPS;
SkMSec fMeasureFPS_Time;
-
/*
* 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 "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
canvas->EXPERIMENTAL_drawDrawable(fRootDrawable);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- SkScalar angle = SkDoubleToScalar(fmod(curr * 0.36 / 24, 360));
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ SkScalar angle = SkDoubleToScalar(fmod(timer.secs() * 360 / 24, 360));
fAnimatingDrawable->setSweep(angle);
return true;
}
-
/*
* 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 "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
bounce_pt(&fSrcPts[1], &fSrcVec[1], fSrcLimit);
}
-public:
- BitmapRectView() {
- this->setBGColor(SK_ColorGRAY);
-
+ void resetBounce() {
fSrcPts[0].set(0, 0);
fSrcPts[1].set(SCALAR_SIZE, SCALAR_SIZE);
-
+
fSrcVec[0] = unit_vec(30);
fSrcVec[1] = unit_vec(107);
+ }
+
+public:
+ BitmapRectView() {
+ this->setBGColor(SK_ColorGRAY);
+
+ this->resetBounce();
fSrcLimit.set(-SCALAR_SIZE/4, -SCALAR_SIZE/4,
SCALAR_SIZE*5/4, SCALAR_SIZE*5/4);
}
protected:
- // overrides from SkEventSink
- virtual bool onQuery(SkEvent* evt) {
+ bool onQuery(SkEvent* evt) SK_OVERRIDE {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "BitmapRect");
return true;
return this->INHERITED::onQuery(evt);
}
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
SkRect srcR;
srcR.set(fSrcPts[0], fSrcPts[1]);
srcR = SkRect::MakeXYWH(fSrcPts[0].fX, fSrcPts[0].fY, 32, 32);
canvas->drawBitmapRectToRect(bitmap, &srcR, fDstR[i], &paint);
canvas->drawRect(fDstR[i], paint);
}
+ }
- this->bounce();
- this->inval(NULL);
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ if (timer.isStopped()) {
+ this->resetBounce();
+ } else if (timer.isRunning()) {
+ this->bounce();
+ }
+ return true;
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
fSrcR.fRight = fSrcR.fLeft + width;
}
+ void resetBounce() {
+ fSrcR.iset(0, 0, fBitmap.height() * 3, fBitmap.height());
+ fDX = SK_Scalar1;
+ }
+
public:
BitmapRectView2() {
make_big_bitmap(&fBitmap);
this->setBGColor(SK_ColorGRAY);
- fSrcR.fLeft = 0;
- fSrcR.fTop = 0;
- fSrcR.fRight = SkIntToScalar(fBitmap.height()) * 3;
- fSrcR.fBottom = SkIntToScalar(fBitmap.height());
-
- fLimitR.set(0, 0,
- SkIntToScalar(fBitmap.width()),
- SkIntToScalar(fBitmap.height()));
+ this->resetBounce();
- fDX = SK_Scalar1;
+ fLimitR.iset(0, 0, fBitmap.width(), fBitmap.height());
- fDstR[0] = SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
- SkIntToScalar(600), SkIntToScalar(200));
+ fDstR[0] = SkRect::MakeXYWH(20, 20, 600, 200);
fDstR[1] = fDstR[0];
fDstR[1].offset(0, fDstR[0].height() * 5/4);
}
protected:
- // overrides from SkEventSink
- virtual bool onQuery(SkEvent* evt) {
+ bool onQuery(SkEvent* evt) SK_OVERRIDE {
if (SampleCode::TitleQ(*evt)) {
SampleCode::TitleR(evt, "BigBitmapRect");
return true;
return this->INHERITED::onQuery(evt);
}
- virtual void onDrawContent(SkCanvas* canvas) {
+ void onDrawContent(SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setColor(SK_ColorYELLOW);
canvas->drawBitmapRectToRect(fBitmap, &fSrcR, fDstR[i], &paint);
canvas->drawRect(fDstR[i], paint);
}
+ }
- this->bounceMe();
- this->inval(NULL);
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ if (timer.isStopped()) {
+ this->resetBounce();
+ } else if (timer.isRunning()) {
+ this->bounceMe();
+ }
+ return true;
}
private:
- typedef SkView INHERITED;
+ typedef SampleView INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
*/
#include "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkCamera.h"
}
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fRY += (curr - prev) * 0.09f;
- if (fRY >= 360) {
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ if (timer.isStopped()) {
fRY = 0;
+ } else {
+ fRY = timer.scaled(90, 360);
}
return true;
}
-
/*
* Copyright 2011 Google Inc.
*
* found in the LICENSE file.
*/
-
#ifndef SampleCode_DEFINED
#define SampleCode_DEFINED
#include "SkKey.h"
#include "SkView.h"
#include "SkOSMenu.h"
+
class GrContext;
+class SkAnimTimer;
#define DEF_SAMPLE(code) \
static SkView* SK_MACRO_APPEND_LINE(F_)() { code } \
static bool FastTextQ(const SkEvent&);
-private:
- static SkMSec GetAnimTime();
- static SkMSec GetAnimTimeDelta();
- static SkScalar GetAnimSecondsDelta();
- static SkScalar GetAnimScalar(SkScalar speedPerSec, SkScalar period = 0);
- // gives a sinusoidal value between 0 and amplitude
- static SkScalar GetAnimSinScalar(SkScalar amplitude,
- SkScalar periodInSec,
- SkScalar phaseInSec = 0);
-
friend class SampleWindow;
};
{}
void setBGColor(SkColor color) { fBGColor = color; }
- bool animatePulse(SkMSec curr, SkMSec prev) { return this->onAnimatePulse(curr, prev); }
+ bool animate(const SkAnimTimer& timer) { return this->onAnimate(timer); }
static bool IsSampleView(SkView*);
static bool SetRepeatDraw(SkView*, int count);
protected:
virtual void onDrawBackground(SkCanvas*);
virtual void onDrawContent(SkCanvas*) = 0;
- virtual bool onAnimatePulse(SkMSec curr, SkMSec prev) { return false; }
+ virtual bool onAnimate(const SkAnimTimer&) { return false; }
// overrides
virtual bool onEvent(const SkEvent& evt);
*/
#include "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
canvas->drawText(txt.c_str(), txt.size(), l + w/2 + w*DELTA_SCALE*delta, t + h + SK_Scalar1 * 10, paint);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fTime += (curr - prev) * 0.001f;
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ fTime = SkDoubleToScalar(timer.secs() / 15);
return true;
}
*/
#include "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkCanvasDrawable.h"
canvas->EXPERIMENTAL_drawDrawable(fRoot);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fTime = curr;
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ fTime = timer.msec();
for (int i = 0; i < N; ++i) {
fArray[i].fDrawable->setTime(fTime);
}
*/
#include "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkCornerPathEffect.h"
canvas->drawBitmap(bm2, SkIntToScalar(10), SkIntToScalar(10), NULL);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
+ bool onAnimate(const SkAnimTimer&) SK_OVERRIDE {
if (fDoAA) {
fProcIndex = cycle_hairproc_index(fProcIndex);
// todo: signal that we want to rebuild our TITLE
-
/*
* 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 "SampleCode.h"
+#include "SkAnimTimer.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "SkGradientShader.h"
canvas->drawPath(fPath, paint);
}
- bool onAnimatePulse(SkMSec curr, SkMSec prev) SK_OVERRIDE {
- fPhase -= (curr - prev) * 0.04f;
+ bool onAnimate(const SkAnimTimer& timer) SK_OVERRIDE {
+ fPhase = timer.scaled(40);
return true;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff