1 2/* 3 * Copyright 2011 Google Inc. 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#include "SkAnimatorScript2.h" 9#include "SkAnimateBase.h" 10#include "SkAnimateMaker.h" 11#include "SkDisplayTypes.h" 12#include "SkExtras.h" 13#include "SkMemberInfo.h" 14#include "SkOpArray.h" 15#include "SkParse.h" 16#include "SkScript2.h" 17#include "SkScriptCallBack.h" 18 19static const SkDisplayEnumMap gEnumMaps[] = { 20 { SkType_AddMode, "indirect|immediate" }, 21 { SkType_Align, "left|center|right" }, 22 { SkType_ApplyMode, "immediate|once" }, 23 { SkType_ApplyTransition, "reverse" }, 24 { SkType_BitmapEncoding, "jpeg|png" }, 25 { SkType_BitmapFormat, "none|A1|A8|Index8|RGB16|RGB32" }, 26 { SkType_Boolean, "false|true" }, 27 { SkType_Cap, "butt|round|square" }, 28 { SkType_EventCode, "none|up|down|left|right|back|end|OK|send|leftSoftKey|rightSoftKey|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash" }, 29 { SkType_EventKind, "none|keyChar|keyPress|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" }, 30 { SkType_EventMode, "deferred|immediate" }, 31 { SkType_FillType, "winding|evenOdd" }, 32 { SkType_FilterType, "none|bilinear" }, 33 { SkType_FromPathMode, "normal|angle|position" }, 34 { SkType_Join, "miter|round|blunt" }, 35 { SkType_MaskFilterBlurStyle, "normal|solid|outer|inner" }, 36 { SkType_PathDirection, "cw|ccw" }, 37 { SkType_Style, "fill|stroke|strokeAndFill" }, 38 { SkType_TextBoxAlign, "start|center|end" }, 39 { SkType_TextBoxMode, "oneLine|lineBreak" }, 40 { SkType_TileMode, "clamp|repeat|mirror" }, 41 { SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|" 42 "srcATop|dstATop|xor|darken|lighten" }, 43}; 44 45static int gEnumMapCount = SK_ARRAY_COUNT(gEnumMaps); 46 47 48class SkAnimatorScript_Box : public SkScriptCallBackConvert { 49public: 50 SkAnimatorScript_Box() {} 51 52 ~SkAnimatorScript_Box() { 53 for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++) 54 delete *dispPtr; 55 } 56 57 virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) { 58 SkDisplayable* displayable; 59 switch (type) { 60 case SkOperand2::kArray: { 61 SkDisplayArray* boxedValue = new SkDisplayArray(*operand->fArray); 62 displayable = boxedValue; 63 } break; 64 case SkOperand2::kS32: { 65 SkDisplayInt* boxedValue = new SkDisplayInt; 66 displayable = boxedValue; 67 boxedValue->value = operand->fS32; 68 } break; 69 case SkOperand2::kScalar: { 70 SkDisplayFloat* boxedValue = new SkDisplayFloat; 71 displayable = boxedValue; 72 boxedValue->value = operand->fScalar; 73 } break; 74 case SkOperand2::kString: { 75 SkDisplayString* boxedValue = new SkDisplayString(*operand->fString); 76 displayable = boxedValue; 77 } break; 78 case SkOperand2::kObject: 79 return true; 80 default: 81 SkASSERT(0); 82 return false; 83 } 84 track(displayable); 85 operand->fObject = (void*) displayable; 86 return true; 87 } 88 89 virtual SkOperand2::OpType getReturnType(int index) { 90 return SkOperand2::kObject; 91 } 92 93 virtual Type getType() const { 94 return kBox; 95 } 96 97 void track(SkDisplayable* displayable) { 98 SkASSERT(fTrackDisplayable.find(displayable) < 0); 99 *fTrackDisplayable.append() = displayable; 100 } 101 102 SkTDDisplayableArray fTrackDisplayable; 103}; 104 105 106class SkAnimatorScript_Enum : public SkScriptCallBackProperty { 107public: 108 SkAnimatorScript_Enum(const char* tokens) : fTokens(tokens) {} 109 110 virtual bool getConstValue(const char* name, int len, SkOperand2* value) { 111 return SkAnimatorScript2::MapEnums(fTokens, name, len, &value->fS32); 112 } 113 114private: 115 const char* fTokens; 116}; 117 118 // !!! if type is string, call invoke 119 // if any other type, return original value 120 // distinction is undone: could do this by returning index == 0 only if param is string 121 // still, caller of getParamTypes will attempt to convert param to string (I guess) 122class SkAnimatorScript_Eval : public SkScriptCallBackFunction { 123public: 124 SkAnimatorScript_Eval(SkAnimatorScript2* engine) : fEngine(engine) {} 125 126 virtual bool getIndex(const char* name, int len, size_t* result) { 127 if (SK_LITERAL_STR_EQUAL("eval", name, len) != 0) 128 return false; 129 *result = 0; 130 return true; 131 } 132 133 virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) { 134 types->setCount(1); 135 SkOperand2::OpType* type = types->begin(); 136 type[0] = SkOperand2::kString; 137 } 138 139 virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) { 140 SkAnimatorScript2 engine(fEngine->getMaker(), fEngine->getWorking(), 141 SkAnimatorScript2::ToDisplayType(fEngine->getReturnType())); 142 SkOperand2* op = params->begin(); 143 const char* script = op->fString->c_str(); 144 SkScriptValue2 value; 145 return engine.evaluateScript(&script, &value); 146 SkASSERT(value.fType == fEngine->getReturnType()); 147 *answer = value.fOperand; 148 // !!! incomplete ? 149 return true; 150 } 151 152private: 153 SkAnimatorScript2* fEngine; 154}; 155 156class SkAnimatorScript_ID : public SkScriptCallBackProperty { 157public: 158 SkAnimatorScript_ID(SkAnimatorScript2* engine) : fEngine(engine) {} 159 160 virtual bool getIndex(const char* token, int len, size_t* result) { 161 SkDisplayable* displayable; 162 bool success = fEngine->getMaker().find(token, len, &displayable); 163 if (success == false) { 164 *result = 0; 165 } else { 166 *result = (size_t) displayable; 167 SkDisplayable* working = fEngine->getWorking(); 168 if (displayable->canContainDependents() && working && working->isAnimate()) { 169 SkAnimateBase* animator = (SkAnimateBase*) working; 170 if (animator->isDynamic()) { 171 SkDisplayDepend* depend = (SkDisplayDepend* ) displayable; 172 depend->addDependent(working); 173 } 174 } 175 } 176 return true; 177 } 178 179 virtual bool getResult(size_t ref, SkOperand2* answer) { 180 answer->fObject = (void*) ref; 181 return true; 182 } 183 184 virtual SkOperand2::OpType getReturnType(size_t index) { 185 return index == 0 ? SkOperand2::kString : SkOperand2::kObject; 186 } 187 188private: 189 SkAnimatorScript2* fEngine; 190}; 191 192 193class SkAnimatorScript_Member : public SkScriptCallBackMember { 194public: 195 196 SkAnimatorScript_Member(SkAnimatorScript2* engine) : fEngine(engine) {} 197 198 bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) { 199 SkDisplayable* displayable = (SkDisplayable*) object; 200 SkString name(member, len); 201 SkDisplayable* named = displayable->contains(name); 202 if (named) { 203 ref->fType = SkOperand2::kObject; 204 ref->fOperand.fObject = named; 205 return true; 206 } 207 const SkMemberInfo* info = displayable->getMember(name.c_str()); 208 if (info == NULL) 209 return false; // !!! add additional error info? 210 ref->fType = SkAnimatorScript2::ToOpType(info->getType()); 211 ref->fOperand.fObject = (void*) info; 212 return true; 213 } 214 215 bool invoke(size_t ref, void* object, SkOperand2* value) { 216 const SkMemberInfo* info = (const SkMemberInfo* ) ref; 217 SkDisplayable* displayable = (SkDisplayable*) object; 218 if (info->fType == SkType_MemberProperty) { 219 if (displayable->getProperty2(info->propertyIndex(), value) == false) { 220 return false; 221 } 222 } 223 return fEngine->evalMemberCommon(info, displayable, value); 224 } 225 226 SkAnimatorScript2* fEngine; 227}; 228 229 230class SkAnimatorScript_MemberFunction : public SkScriptCallBackMemberFunction { 231public: 232 SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {} 233 234 bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) { 235 SkDisplayable* displayable = (SkDisplayable*) object; 236 SkString name(member, len); 237 const SkMemberInfo* info = displayable->getMember(name.c_str()); 238 if (info == NULL || info->fType != SkType_MemberFunction) 239 return false; // !!! add additional error info? 240 ref->fType = SkAnimatorScript2::ToOpType(info->getType()); 241 ref->fOperand.fObject = (void*) info; 242 return true; 243 } 244 245 virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) { 246 types->setCount(3); 247 SkOperand2::OpType* type = types->begin(); 248 type[0] = type[1] = type[2] = SkOperand2::kS32; 249 } 250 251 bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value) 252 { 253 const SkMemberInfo* info = (const SkMemberInfo* ) ref; 254 SkDisplayable* displayable = (SkDisplayable*) object; 255 displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(), 256 value); 257 return fEngine->evalMemberCommon(info, displayable, value); 258 } 259 260 SkAnimatorScript2* fEngine; 261}; 262 263 264class SkAnimatorScript_NamedColor : public SkScriptCallBackProperty { 265public: 266 virtual bool getConstValue(const char* name, int len, SkOperand2* value) { 267 return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL; 268 } 269}; 270 271 272class SkAnimatorScript_RGB : public SkScriptCallBackFunction { 273public: 274 virtual bool getIndex(const char* name, int len, size_t* result) { 275 if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0) 276 return false; 277 *result = 0; 278 return true; 279 } 280 281 virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) { 282 types->setCount(3); 283 SkOperand2::OpType* type = types->begin(); 284 type[0] = type[1] = type[2] = SkOperand2::kS32; 285 } 286 287 virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) { 288 SkASSERT(index == 0); 289 unsigned result = 0xFF000000; 290 int shift = 16; 291 for (int index = 0; index < 3; index++) { 292 result |= SkClampMax(params->begin()[index].fS32, 255) << shift; 293 shift -= 8; 294 } 295 answer->fS32 = result; 296 return true; 297 } 298 299}; 300 301 302class SkAnimatorScript_Unbox : public SkScriptCallBackConvert { 303public: 304 SkAnimatorScript_Unbox(SkAnimatorScript2* engine) : fEngine(engine) {} 305 306 virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) { 307 SkASSERT(type == SkOperand2::kObject); 308 SkDisplayable* displayable = (SkDisplayable*) operand->fObject; 309 switch (displayable->getType()) { 310 case SkType_Array: { 311 SkDisplayArray* boxedValue = (SkDisplayArray*) displayable; 312 operand->fArray = new SkOpArray(SkAnimatorScript2::ToOpType(boxedValue->values.getType())); 313 int count = boxedValue->values.count(); 314 operand->fArray->setCount(count); 315 memcpy(operand->fArray->begin(), boxedValue->values.begin(), count * sizeof(SkOperand2)); 316 fEngine->track(operand->fArray); 317 } break; 318 case SkType_Boolean: { 319 SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable; 320 operand->fS32 = boxedValue->value; 321 } break; 322 case SkType_Int: { 323 SkDisplayInt* boxedValue = (SkDisplayInt*) displayable; 324 operand->fS32 = boxedValue->value; 325 } break; 326 case SkType_Float: { 327 SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable; 328 operand->fScalar = boxedValue->value; 329 } break; 330 case SkType_String: { 331 SkDisplayString* boxedValue = (SkDisplayString*) displayable; 332 operand->fString = SkNEW_ARGS(SkString, (boxedValue->value)); 333 } break; 334 default: { 335 const char* id; 336 bool success = fEngine->getMaker().findKey(displayable, &id); 337 SkASSERT(success); 338 operand->fString = SkNEW_ARGS(SkString, (id)); 339 } 340 } 341 return true; 342 } 343 344 virtual SkOperand2::OpType getReturnType(int /*index*/, SkOperand2* operand) { 345 SkDisplayable* displayable = (SkDisplayable*) operand->fObject; 346 switch (displayable->getType()) { 347 case SkType_Array: 348 return SkOperand2::kArray; 349 case SkType_Int: 350 return SkOperand2::kS32; 351 case SkType_Float: 352 return SkOperand2::kScalar; 353 case SkType_String: 354 default: 355 return SkOperand2::kString; 356 } 357 } 358 359 virtual Type getType() const { 360 return kUnbox; 361 } 362 363 SkAnimatorScript2* fEngine; 364}; 365 366SkAnimatorScript2::SkAnimatorScript2(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) : 367 SkScriptEngine2(ToOpType(type)), fMaker(maker), fWorking(working) { 368 *fCallBackArray.append() = new SkAnimatorScript_Member(this); 369 *fCallBackArray.append() = new SkAnimatorScript_MemberFunction(this); 370 *fCallBackArray.append() = new SkAnimatorScript_Box(); 371 *fCallBackArray.append() = new SkAnimatorScript_Unbox(this); 372 *fCallBackArray.append() = new SkAnimatorScript_ID(this); 373 if (type == SkType_ARGB) { 374 *fCallBackArray.append() = new SkAnimatorScript_RGB(); 375 *fCallBackArray.append() = new SkAnimatorScript_NamedColor(); 376 } 377 if (SkDisplayType::IsEnum(&maker, type)) { 378 // !!! for SpiderMonkey, iterate through the enum values, and map them to globals 379 const SkDisplayEnumMap& map = GetEnumValues(type); 380 *fCallBackArray.append() = new SkAnimatorScript_Enum(map.fValues); 381 } 382 *fCallBackArray.append() = new SkAnimatorScript_Eval(this); 383#if 0 // !!! no extra support for now 384 for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) { 385 SkExtras* extra = *extraPtr; 386 if (extra->fExtraCallBack) 387 *fCallBackArray.append() = new propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage); 388 } 389#endif 390} 391 392SkAnimatorScript2::~SkAnimatorScript2() { 393 SkScriptCallBack** end = fCallBackArray.end(); 394 for (SkScriptCallBack** ptr = fCallBackArray.begin(); ptr < end; ptr++) 395 delete *ptr; 396} 397 398bool SkAnimatorScript2::evalMemberCommon(const SkMemberInfo* info, 399 SkDisplayable* displayable, SkOperand2* value) { 400 SkDisplayTypes original; 401 SkDisplayTypes type = original = (SkDisplayTypes) info->getType(); 402 if (info->fType == SkType_Array) 403 type = SkType_Array; 404 switch (type) { 405 case SkType_ARGB: 406 type = SkType_Int; 407 case SkType_Boolean: 408 case SkType_Int: 409 case SkType_MSec: 410 case SkType_Float: 411 SkASSERT(info->getCount() == 1); 412 if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) 413 value->fS32 = *(int32_t*) info->memberData(displayable); // OK for SkScalar too 414 if (type == SkType_MSec) { 415 value->fScalar = SkScalarDiv((SkScalar) value->fS32, 1000); // dividing two ints is the same as dividing two scalars 416 type = SkType_Float; 417 } 418 break; 419 case SkType_String: { 420 SkString* displayableString; 421 if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) { 422 info->getString(displayable, &displayableString); 423 value->fString = new SkString(*displayableString); 424 } 425 } break; 426 case SkType_Array: { 427 SkASSERT(info->fType != SkType_MemberProperty); // !!! incomplete 428 SkTDOperandArray* displayableArray = (SkTDOperandArray*) info->memberData(displayable); 429 if (displayable->getType() == SkType_Array) { 430 SkDisplayArray* typedArray = (SkDisplayArray*) displayable; 431 original = typedArray->values.getType(); 432 } 433 SkASSERT(original != SkType_Unknown); 434 SkOpArray* array = value->fArray = new SkOpArray(ToOpType(original)); 435 track(array); 436 int count = displayableArray->count(); 437 if (count > 0) { 438 array->setCount(count); 439 memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand2)); 440 } 441 } break; 442 default: 443 SkASSERT(0); // unimplemented 444 } 445 return true; 446} 447 448const SkDisplayEnumMap& SkAnimatorScript2::GetEnumValues(SkDisplayTypes type) { 449 int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type, 450 sizeof(SkDisplayEnumMap)); 451 SkASSERT(index >= 0); 452 return gEnumMaps[index]; 453} 454 455SkDisplayTypes SkAnimatorScript2::ToDisplayType(SkOperand2::OpType type) { 456 int val = type; 457 switch (val) { 458 case SkOperand2::kNoType: 459 return SkType_Unknown; 460 case SkOperand2::kS32: 461 return SkType_Int; 462 case SkOperand2::kScalar: 463 return SkType_Float; 464 case SkOperand2::kString: 465 return SkType_String; 466 case SkOperand2::kArray: 467 return SkType_Array; 468 case SkOperand2::kObject: 469 return SkType_Displayable; 470 default: 471 SkASSERT(0); 472 return SkType_Unknown; 473 } 474} 475 476SkOperand2::OpType SkAnimatorScript2::ToOpType(SkDisplayTypes type) { 477 if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type)) 478 return SkOperand2::kObject; 479 if (SkDisplayType::IsEnum(NULL /* fMaker */, type)) 480 return SkOperand2::kS32; 481 switch (type) { 482 case SkType_ARGB: 483 case SkType_MSec: 484 case SkType_Int: 485 return SkOperand2::kS32; 486 case SkType_Float: 487 case SkType_Point: 488 case SkType_3D_Point: 489 return SkOperand2::kScalar; 490 case SkType_Base64: 491 case SkType_DynamicString: 492 case SkType_String: 493 return SkOperand2::kString; 494 case SkType_Array: 495 return SkOperand2::kArray; 496 case SkType_Unknown: 497 return SkOperand2::kNoType; 498 default: 499 SkASSERT(0); 500 return SkOperand2::kNoType; 501 } 502} 503 504bool SkAnimatorScript2::MapEnums(const char* ptr, const char* match, size_t len, int* value) { 505 int index = 0; 506 bool more = true; 507 do { 508 const char* last = strchr(ptr, '|'); 509 if (last == NULL) { 510 last = &ptr[strlen(ptr)]; 511 more = false; 512 } 513 size_t length = last - ptr; 514 if (len == length && strncmp(ptr, match, length) == 0) { 515 *value = index; 516 return true; 517 } 518 index++; 519 ptr = last + 1; 520 } while (more); 521 return false; 522} 523 524#if defined SK_DEBUG 525 526#include "SkAnimator.h" 527 528static const char scriptTestSetup[] = 529"<screenplay>" 530 "<apply>" 531 "<paint>" 532 "<emboss id='emboss' direction='[1,1,1]' />" 533 "</paint>" 534 "<animateField id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>" 535 "<set lval='direction[0]' target='emboss' to='-1' />" 536 "</apply>" 537 "<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />" 538 "<color id='xColor' color='rgb(12,34,56)' />" 539 "<typedArray id='emptyArray' />" 540 "<typedArray id='intArray' values='[1, 4, 6]' />" 541 "<s32 id='idx' value='2' />" 542 "<s32 id='idy' value='2' />" 543 "<string id='alpha' value='abc' />" 544 "<rectangle id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />" 545 "<event id='evt'>" 546 "<input name='x' />" 547 "<apply scope='idy'>" 548 "<set field='value' to='evt.x.s32' />" 549 "</apply>" 550 "</event>" 551"</screenplay>"; 552 553static const SkScriptNAnswer scriptTests[] = { 554 { "alpha+alpha", SkType_String, 0, 0, "abcabc" }, 555 { "0 ? Math.sin(0) : 1", SkType_Int, 1 }, 556 { "intArray[4]", SkType_Unknown }, 557 { "emptyArray[4]", SkType_Unknown }, 558 { "idx", SkType_Int, 2 }, 559 { "intArray.length", SkType_Int, 3 }, 560 { "intArray.values[0]", SkType_Int, 1 }, 561 { "intArray[0]", SkType_Int, 1 }, 562 { "idx.value", SkType_Int, 2 }, 563 { "alpha.value", SkType_String, 0, 0, "abc" }, 564 { "alpha", SkType_String, 0, 0, "abc" }, 565 { "alpha.value+alpha.value", SkType_String, 0, 0, "abcabc" }, 566 { "alpha+idx", SkType_String, 0, 0, "abc2" }, 567 { "idx+alpha", SkType_String, 0, 0, "2abc" }, 568 { "intArray[idx]", SkType_Int, 6 }, 569 { "alpha.slice(1,2)", SkType_String, 0, 0, "b" }, 570 { "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" }, 571 { "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) }, 572 { "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) }, 573 { "0 ? intArray[0] : 1", SkType_Int, 1 }, 574 { "0 ? intArray.values[0] : 1", SkType_Int, 1 }, 575 { "0 ? idx : 1", SkType_Int, 1 }, 576 { "0 ? idx.value : 1", SkType_Int, 1 }, 577 { "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 }, 578 { "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 }, 579 { "idy", SkType_Int, 3 } 580}; 581 582#define SkScriptNAnswer_testCount SK_ARRAY_COUNT(scriptTests) 583 584void SkAnimatorScript2::UnitTest() { 585#if defined(SK_SUPPORT_UNITTEST) 586 SkAnimator animator; 587 SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1)); 588 SkEvent evt; 589 evt.setString("id", "evt"); 590 evt.setS32("x", 3); 591 animator.doUserEvent(evt); 592 // set up animator with memory script above, then run value tests 593 for (int index = 0; index < SkScriptNAnswer_testCount; index++) { 594 SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType); 595 SkScriptValue2 value; 596 const char* script = scriptTests[index].fScript; 597 bool success = engine.evaluateScript(&script, &value); 598 if (success == false) { 599 SkASSERT(scriptTests[index].fType == SkType_Unknown); 600 continue; 601 } 602 SkASSERT(value.fType == ToOpType(scriptTests[index].fType)); 603 SkScalar error; 604 switch (value.fType) { 605 case SkOperand2::kS32: 606 SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer); 607 break; 608 case SkOperand2::kScalar: 609 error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer); 610 SkASSERT(error < SK_Scalar1 / 10000); 611 break; 612 case SkOperand2::kString: 613 SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer)); 614 break; 615 default: 616 SkASSERT(0); 617 } 618 } 619#endif 620} 621 622#endif 623