The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/animator/SkAnimateActive.cpp

gfx/skia/trunk/src/animator/SkAnimateActive.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:86ffe56939af
1
2 /*
3 * Copyright 2006 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10 #include "SkAnimateActive.h"
11 #include "SkAnimateBase.h"
12 #include "SkAnimateMaker.h"
13 #include "SkAnimateSet.h"
14 #include "SkDrawGroup.h"
15 #ifdef SK_DEBUG
16 #include "SkTime.h"
17 #endif
18
19 // SkActive holds array of interpolators
20
21 SkActive::SkActive(SkApply& apply, SkAnimateMaker& maker) : fApply(apply),
22 fMaxTime(0), fMaker(maker), fDrawIndex(0), fDrawMax(0) {
23 }
24
25 void SkActive::init()
26 {
27 fAnimators = fApply.fAnimators;
28 int animators = fAnimators.count();
29 fInterpolators.setCount(animators);
30 memset(fInterpolators.begin(), 0, animators * sizeof(SkOperandInterpolator*));
31 fState.setCount(animators);
32 int index;
33 for (index = 0; index < animators; index++)
34 fInterpolators[index] = SkNEW(SkOperandInterpolator);
35 initState(&fApply, 0);
36 // for (index = 0; index < animators; index++)
37 // fState[index].bumpSave();
38 SkASSERT(fInterpolators.count() == fAnimators.count());
39 }
40
41 SkActive::~SkActive() {
42 int index;
43 for (index = 0; index < fSaveRestore.count(); index++)
44 delete[] fSaveRestore[index];
45 for (index = 0; index < fSaveInterpolators.count(); index++)
46 delete[] fSaveInterpolators[index];
47 for (index = 0; index < fInterpolators.count(); index++)
48 delete fInterpolators[index];
49 }
50
51 void SkActive::advance() {
52 if (fDrawMax < fDrawIndex)
53 fDrawMax = fDrawIndex;
54 fDrawIndex += fAnimators.count();
55 }
56
57 void SkActive::append(SkApply* apply) {
58 int oldCount = fAnimators.count();
59 SkTDAnimateArray& animates = apply->fAnimators;
60 int newCount = animates.count();
61 int index;
62 int total = oldCount + newCount;
63 if (total == 0)
64 return;
65 fInterpolators.setCount(total);
66 memset(&fInterpolators.begin()[oldCount], 0, newCount * sizeof(SkOperandInterpolator*));
67 for (index = oldCount; index < total; index++)
68 fInterpolators[index] = SkNEW(SkOperandInterpolator);
69 fAnimators.setCount(total);
70 memcpy(&fAnimators[oldCount], animates.begin(), sizeof(fAnimators[0]) *
71 newCount);
72 fState.setCount(total);
73 initState(apply, oldCount);
74 SkASSERT(fApply.scope == apply->scope);
75 for (index = 0; index < newCount; index++) {
76 SkAnimateBase* test = animates[index];
77 // SkASSERT(fApply.scope == test->fTarget || fApply.scope->contains(test->fTarget));
78 SkActive::SkState& testState = fState[oldCount + index];
79 for (int inner = 0; inner < oldCount; inner++) {
80 SkAnimateBase* oldGuard = fAnimators[inner];
81 SkActive::SkState& oldState = fState[inner];
82 if (oldGuard->fTarget == test->fTarget && oldGuard->fFieldInfo == test->fFieldInfo &&
83 testState.fBegin == oldState.fBegin) {
84 delete fInterpolators[inner];
85 fInterpolators.remove(inner);
86 fAnimators.remove(inner);
87 testState.fSave = oldState.fSave;
88 if (oldState.fUnpostedEndEvent) {
89 // SkDEBUGF(("%8x %8x active append: post on end\n", this, oldGuard));
90 fMaker.postOnEnd(oldGuard, oldState.fBegin + oldState.fDuration);
91 }
92 fState.remove(inner);
93 if (fApply.restore) {
94 int saveIndex = fSaveRestore.count();
95 SkASSERT(fSaveInterpolators.count() == saveIndex);
96 saveIndex += inner;
97 do {
98 saveIndex -= oldCount;
99 delete[] fSaveRestore[saveIndex];
100 fSaveRestore.remove(saveIndex);
101 delete[] fSaveInterpolators[saveIndex];
102 fSaveInterpolators.remove(saveIndex);
103 } while (saveIndex > 0);
104 }
105 oldCount--;
106 break;
107 }
108 }
109 }
110 // total = oldCount + newCount;
111 // for (index = oldCount; index < total; index++)
112 // fState[index].bumpSave();
113 SkASSERT(fInterpolators.count() == fAnimators.count());
114 }
115
116 void SkActive::appendSave(int oldCount) {
117 SkASSERT(fDrawMax == 0); // if true, we can optimize below quite a bit
118 int newCount = fAnimators.count();
119 int saveIndex = fSaveRestore.count();
120 SkASSERT(fSaveInterpolators.count() == saveIndex);
121 int records = saveIndex / oldCount;
122 int newTotal = records * newCount;
123 fSaveRestore.setCount(newTotal);
124 do {
125 saveIndex -= oldCount;
126 newTotal -= newCount;
127 SkASSERT(saveIndex >= 0);
128 SkASSERT(newTotal >= 0);
129 memmove(&fSaveRestore[newTotal], &fSaveRestore[saveIndex], oldCount);
130 memset(&fSaveRestore[newTotal + oldCount], 0,
131 sizeof(fSaveRestore[0]) * (newCount - oldCount));
132 memmove(&fSaveInterpolators[newTotal],
133 &fSaveInterpolators[saveIndex], oldCount);
134 memset(&fSaveInterpolators[newTotal + oldCount], 0,
135 sizeof(fSaveRestore[0]) * (newCount - oldCount));
136 } while (saveIndex > 0);
137 SkASSERT(newTotal == 0);
138 }
139
140 void SkActive::calcDurations(int index)
141 {
142 SkAnimateBase* animate = fAnimators[index];
143 SkMSec duration = animate->dur;
144 SkState& state = fState[index];
145 switch (state.fMode) {
146 case SkApply::kMode_immediate:
147 case SkApply::kMode_create:
148 duration = state.fSteps ? state.fSteps * SK_MSec1 : 1;
149 break;
150 // case SkApply::kMode_hold: {
151 // int entries = animate->entries();
152 // SkScriptValue value;
153 // value.fOperand = animate->getValues()[entries - 1];
154 // value.fType = animate->getValuesType();
155 // bool result = SkScriptEngine::ConvertTo(NULL, SkType_Int, &value);
156 // SkASSERT(result);
157 // duration = value.fOperand.fS32 * SK_MSec1;
158 // break;
159 // }
160 }
161 state.fDuration = duration;
162 SkMSec maxTime = state.fBegin + duration;
163 if (fMaxTime < maxTime)
164 fMaxTime = maxTime;
165 }
166
167 void SkActive::create(SkDrawable* drawable, SkMSec time) {
168 fApply.fLastTime = time;
169 fApply.refresh(fMaker);
170 for (int index = 0; index < fAnimators.count(); index++) {
171 SkAnimateBase* animate = fAnimators[index];
172 SkOperandInterpolator& interpolator = *fInterpolators[index];
173 int count = animate->components();
174 if (animate->formula.size() > 0) {
175 SkTDOperandArray values;
176 values.setCount(count);
177 SkDEBUGCODE(bool success = ) animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
178 animate->getValuesType(), animate->formula);
179 SkASSERT(success);
180 fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
181 } else {
182 SkAutoSTMalloc<16, SkOperand> values(count);
183 interpolator.timeToValues(time, values.get());
184 fApply.applyValues(index, values.get(), count, animate->getValuesType(), time);
185 }
186 }
187 drawable->enable(fMaker);
188 SkASSERT(fAnimators.count() == fInterpolators.count());
189 }
190
191 bool SkActive::immediate(bool enable) {
192 SkMSec time = 0;
193 bool result = false;
194 SkDrawable* drawable = fApply.scope;
195 SkMSec final = fMaxTime;
196 do {
197 bool applied = fAnimators.count() == 0;
198 fApply.fLastTime = time;
199 fApply.refresh(fMaker);
200 for (int index = 0; index < fAnimators.count(); index++) {
201 SkAnimateBase* animate = fAnimators[index];
202 SkState& state = fState[index];
203 if (state.fMode != SkApply::kMode_immediate)
204 continue;
205 if (state.fBegin > time)
206 continue;
207 if (time > state.fBegin + state.fDuration)
208 continue;
209 applied = true;
210 SkOperandInterpolator& interpolator = *fInterpolators[index];
211 int count = animate->components();
212 if (animate->formula.size() > 0) {
213 SkTDOperandArray values;
214 values.setCount(count);
215 SkDEBUGCODE(bool success = ) animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
216 animate->getValuesType(), animate->formula);
217 SkASSERT(success);
218 fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
219 } else {
220 SkAutoSTMalloc<16, SkOperand> values(count);
221 interpolator.timeToValues(time, values.get());
222 fApply.applyValues(index, values.get(), count, animate->getValuesType(), time);
223 }
224 }
225 if (enable)
226 drawable->enable(fMaker);
227 else if (applied)
228 result |= drawable->draw(fMaker);
229 time += SK_MSec1;
230 } while (time <= final);
231 return result;
232 }
233
234 void SkActive::fixInterpolator(SkBool save) {
235 int animators = fAnimators.count();
236 for (int index = 0; index < animators; index++) {
237 SkAnimateBase* animate = fAnimators[index];
238 if (save) { // saved slots increased
239 animate->refresh(fMaker);
240 SkOperand* values = animate->getValues();
241 setInterpolator(index, values);
242 saveInterpolatorValues(index);
243 } else
244 restoreInterpolatorValues(index);
245 }
246 }
247
248 SkMSec SkActive::getTime(SkMSec inTime, int animatorIndex) {
249 fState[animatorIndex].fTicks = inTime;
250 return inTime - fState[animatorIndex].fStartTime;
251 }
252
253 bool SkActive::initializeSave() {
254 int animators = fAnimators.count();
255 int activeTotal = fDrawIndex + animators;
256 int oldCount = fSaveRestore.count();
257 if (oldCount < activeTotal) {
258 fSaveRestore.setCount(activeTotal);
259 memset(&fSaveRestore[oldCount], 0, sizeof(fSaveRestore[0]) * (activeTotal - oldCount));
260 SkASSERT(fSaveInterpolators.count() == oldCount);
261 fSaveInterpolators.setCount(activeTotal);
262 memset(&fSaveInterpolators[oldCount], 0,
263 sizeof(fSaveInterpolators[0]) * (activeTotal - oldCount));
264 return true;
265 }
266 return false;
267 }
268
269 void SkActive::initState(SkApply* apply, int offset) {
270 int count = fState.count();
271 for (int index = offset; index < count; index++) {
272 SkState& state = fState[index];
273 SkAnimateBase* animate = fAnimators[index];
274 #if 0 // def SK_DEBUG
275 if (animate->fHasEndEvent)
276 SkDebugf("%8x %8x active initState:\n", this, animate);
277 #endif
278 SkOperand* from = animate->getValues();
279 state.fStartTime = state.fBegin = apply->begin + animate->begin;
280 state.fMode = apply->mode;
281 state.fTransition = apply->transition;
282 #if 0
283 state.fPickup = (SkBool8) apply->pickup;
284 #endif
285 state.fRestore = (SkBool8) apply->restore;
286 state.fSave = apply->begin;
287 state.fStarted = false;
288 state.fSteps = apply->steps;
289 state.fTicks = 0;
290 state.fUnpostedEndEvent = (SkBool8) animate->fHasEndEvent;
291 calcDurations(index);
292 setInterpolator(index, from);
293 }
294 if (count == 0 && (apply->mode == SkApply::kMode_immediate || apply->mode == SkApply::kMode_create))
295 fMaxTime = apply->begin + apply->steps * SK_MSec1;
296 }
297
298 void SkActive::pickUp(SkActive* existing) {
299 SkTDOperandArray existingValues;
300 for (int index = 0; index < fAnimators.count(); index++) {
301 SkAnimateBase* animate = fAnimators[index];
302 SkASSERT(animate->getValuesType() == SkType_Float);
303 int components = animate->components();
304 SkOperand* from = animate->getValues();
305 SkOperand* to = &from[animate->components()];
306 existingValues.setCount(components);
307 existing->fInterpolators[index]->timeToValues(
308 existing->fState[index].fTicks - existing->fState[index].fStartTime, existingValues.begin());
309 SkScalar originalSum = 0;
310 SkScalar workingSum = 0;
311 for (int cIndex = 0; cIndex < components; cIndex++) {
312 SkScalar delta = to[cIndex].fScalar - from[cIndex].fScalar;
313 originalSum += SkScalarMul(delta, delta);
314 delta = to[cIndex].fScalar - existingValues[cIndex].fScalar;
315 workingSum += SkScalarMul(delta, delta);
316 }
317 if (workingSum < originalSum) {
318 SkScalar originalDistance = SkScalarSqrt(originalSum);
319 SkScalar workingDistance = SkScalarSqrt(workingSum);
320 existing->fState[index].fDuration = (SkMSec) SkScalarMulDiv(fState[index].fDuration,
321 workingDistance, originalDistance);
322 }
323 fInterpolators[index]->reset(components, 2, SkType_Float);
324 fInterpolators[index]->setKeyFrame(0, 0, existingValues.begin(), animate->blend[0]);
325 fInterpolators[index]->setKeyFrame(1, fState[index].fDuration, to, animate->blend[0]);
326 }
327 }
328
329 void SkActive::resetInterpolators() {
330 int animators = fAnimators.count();
331 for (int index = 0; index < animators; index++) {
332 SkAnimateBase* animate = fAnimators[index];
333 SkOperand* values = animate->getValues();
334 setInterpolator(index, values);
335 }
336 }
337
338 void SkActive::resetState() {
339 fDrawIndex = 0;
340 int count = fState.count();
341 for (int index = 0; index < count; index++) {
342 SkState& state = fState[index];
343 SkAnimateBase* animate = fAnimators[index];
344 #if 0 // def SK_DEBUG
345 if (animate->fHasEndEvent)
346 SkDebugf("%8x %8x active resetState: has end event\n", this, animate);
347 #endif
348 state.fStartTime = state.fBegin = fApply.begin + animate->begin;
349 state.fStarted = false;
350 state.fTicks = 0;
351 }
352 }
353
354 void SkActive::restoreInterpolatorValues(int index) {
355 SkOperandInterpolator& interpolator = *fInterpolators[index];
356 index += fDrawIndex ;
357 int count = interpolator.getValuesCount();
358 memcpy(interpolator.getValues(), fSaveInterpolators[index], count * sizeof(SkOperand));
359 }
360
361 void SkActive::saveInterpolatorValues(int index) {
362 SkOperandInterpolator& interpolator = *fInterpolators[index];
363 index += fDrawIndex ;
364 int count = interpolator.getValuesCount();
365 SkOperand* cache = new SkOperand[count]; // this should use sk_malloc/sk_free since SkOperand does not have a constructor/destructor
366 fSaveInterpolators[index] = cache;
367 memcpy(cache, interpolator.getValues(), count * sizeof(SkOperand));
368 }
369
370 void SkActive::setInterpolator(int index, SkOperand* from) {
371 if (from == NULL) // legitimate for set string
372 return;
373 SkAnimateBase* animate = fAnimators[index];
374 int entries = animate->entries();
375 SkASSERT(entries > 0);
376 SkMSec duration = fState[index].fDuration;
377 int components = animate->components();
378 SkOperandInterpolator& interpolator = *fInterpolators[index];
379 interpolator.reset(components, entries == 1 ? 2 : entries, animate->getValuesType());
380 interpolator.setMirror(SkToBool(animate->fMirror));
381 interpolator.setReset(SkToBool(animate->fReset));
382 interpolator.setRepeatCount(animate->repeat);
383 if (entries == 1) {
384 interpolator.setKeyFrame(0, 0, from, animate->blend[0]);
385 interpolator.setKeyFrame(1, duration, from, animate->blend[0]);
386 return;
387 }
388 for (int entry = 0; entry < entries; entry++) {
389 int blendIndex = SkMin32(animate->blend.count() - 1, entry);
390 interpolator.setKeyFrame(entry, entry * duration / (entries - 1), from,
391 animate->blend[blendIndex]);
392 from += components;
393 }
394 }
395
396 void SkActive::setSteps(int steps) {
397 int count = fState.count();
398 fMaxTime = 0;
399 for (int index = 0; index < count; index++) {
400 SkState& state = fState[index];
401 state.fSteps = steps;
402 calcDurations(index);
403 }
404 }
405
406 void SkActive::start() {
407 int count = fState.count();
408 SkASSERT(count == fAnimators.count());
409 SkASSERT(count == fInterpolators.count());
410 for (int index = 0; index < count; index++) {
411 SkState& state = fState[index];
412 if (state.fStarted)
413 continue;
414 state.fStarted = true;
415 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
416 SkString debugOut;
417 SkMSec time = fMaker.getAppTime();
418 debugOut.appendS32(time - fMaker.fDebugTimeBase);
419 debugOut.append(" active start adjust delay id=");
420 debugOut.append(fApply._id);
421 debugOut.append("; ");
422 debugOut.append(fAnimators[index]->_id);
423 debugOut.append("=");
424 debugOut.appendS32(fAnimators[index]->fStart - fMaker.fDebugTimeBase);
425 debugOut.append(":");
426 debugOut.appendS32(state.fStartTime);
427 #endif
428 if (state.fStartTime > 0) {
429 SkMSec future = fAnimators[index]->fStart + state.fStartTime;
430 if (future > fMaker.fEnableTime)
431 fMaker.notifyInvalTime(future);
432 else
433 fMaker.notifyInval();
434 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
435 debugOut.append(":");
436 debugOut.appendS32(future - fMaker.fDebugTimeBase);
437 #endif
438 }
439 if (state.fStartTime >= fMaker.fAdjustedStart) {
440 state.fStartTime -= fMaker.fAdjustedStart;
441 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
442 debugOut.append(" (less adjust = ");
443 debugOut.appendS32(fMaker.fAdjustedStart);
444 #endif
445 }
446 state.fStartTime += fAnimators[index]->fStart;
447 #if defined SK_DEBUG && defined SK_DEBUG_ANIMATION_TIMING
448 debugOut.append(") new start = ");
449 debugOut.appendS32(state.fStartTime - fMaker.fDebugTimeBase);
450 SkDebugf("%s\n", debugOut.c_str());
451 // SkASSERT((int) (state.fStartTime - fMaker.fDebugTimeBase) >= 0);
452 #endif
453 }
454 SkASSERT(fAnimators.count() == fInterpolators.count());
455 }
456
457 #ifdef SK_DEBUG
458 void SkActive::validate() {
459 int count = fState.count();
460 SkASSERT(count == fAnimators.count());
461 SkASSERT(count == fInterpolators.count());
462 for (int index = 0; index < count; index++) {
463 SkASSERT(fAnimators[index]);
464 SkASSERT(fInterpolators[index]);
465 // SkAnimateBase* test = fAnimators[index];
466 // SkASSERT(fApply.scope == test->fTarget || fApply.scope->contains(test->fTarget));
467 }
468 }
469 #endif
470
471 // think about this
472 // there should only be one animate object, not two, to go up and down
473 // when the apply with reverse came into play, it needs to pick up the value
474 // of the existing animate object then remove it from the list
475 // the code below should only be bumping fSave, and there shouldn't be anything
476 // it needs to be synchronized with
477
478 // however, if there are two animates both operating on the same field, then
479 // when one replaces the other, it may make sense to pick up the old value as a starting
480 // value for the new one somehow.
481
482 //void SkActive::SkState::bumpSave() {
483 // if (fMode != SkApply::kMode_hold)
484 // return;
485 // if (fTransition == SkApply::kTransition_reverse) {
486 // if (fSave > 0)
487 // fSave -= SK_MSec1;
488 // } else if (fSave < fDuration)
489 // fSave += SK_MSec1;
490 //}
491
492 SkMSec SkActive::SkState::getRelativeTime(SkMSec time) {
493 SkMSec result = time;
494 // if (fMode == SkApply::kMode_hold)
495 // result = fSave;
496 // else
497 if (fTransition == SkApply::kTransition_reverse) {
498 if (SkMSec_LT(fDuration, time))
499 result = 0;
500 else
501 result = fDuration - time;
502 }
503 return result;
504 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial