00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "LampBasic.h"
00026 #include "Animation/InputOutput/TextAnimationLoader.h"
00027 #include "Core/InputOutput/FilePath.h"
00028 #include "Core/InputOutput/TextFileReader.h"
00029 #include "Core/InputOutput/StreamTokenizer.h"
00030 #include "Animation/VectorInterpolator/VectorConstantInterpolator.h"
00031 #include "Animation/VectorInterpolator/VectorArrayInterpolator.h"
00032 #include "Animation/VectorInterpolator/VectorLinearInterpolator.h"
00033 #include "Animation/RotationInterpolator/RotationConstantInterpolator.h"
00034 #include "Animation/RotationInterpolator/EulerArrayInterpolator.h"
00035 #include "Animation/RotationInterpolator/QuaternionArrayInterpolator.h"
00036 #include "Animation/RotationInterpolator/QuaternionLinearInterpolator.h"
00037
00038 #include "Animation/System/AnimationManager.h"
00039 #include "Animation/System/AnimationSet.h"
00040 #include "Animation/Camera/CameraAnimation.h"
00041 #include "Animation/SceneNode/SceneNodeAnimation.h"
00042 #include "Animation/Model/CharacterModelAnimation.h"
00043
00044 namespace Lamp{
00045
00046
00047
00048 TextAnimationLoader::TextAnimationLoader(){
00049 }
00050
00051
00052 TextAnimationLoader::~TextAnimationLoader(){
00053 }
00054
00055
00056 void TextAnimationLoader::load(
00057 const String& filePath, AnimationManager* manager){
00058 FilePath path(filePath);
00059 Assert(path.existFile());
00060 TextFileReader* textFileReader = new TextFileReader(filePath);
00061 load(textFileReader, manager);
00062 delete textFileReader;
00063 }
00064
00065
00066 void TextAnimationLoader::load(
00067 TextReader* textReader, AnimationManager* manager){
00068 tokenizer_ = new StreamTokenizer(textReader);
00069 manager_ = manager;
00070
00071
00072 readHeader();
00073
00074 while(true){
00075
00076 if(!tokenizer_->nextToken()){ break; }
00077 String chunkName = tokenizer_->getToken();
00078 if(chunkName == "AnimationSet"){
00079 readAnimationSetList();
00080 }else if(chunkName == "CameraAnimation"){
00081
00082 openChunk();
00083 while(true){
00084 String token = readToken("readCameraAnimation()");
00085 if(token == "}"){ break; }
00086 readCameraAnimation(token);
00087 }
00088 }else if(chunkName == "CameraAnimationData"){
00089
00090 openChunk();
00091 while(true){
00092 String token = readToken("readCameraAnimationData()");
00093 if(token == "}"){ break; }
00094 readCameraAnimationData(token);
00095 }
00096 }else if(chunkName == "SceneNodeAnimation"){
00097
00098 openChunk();
00099 while(true){
00100 String token = readToken("readSceneNodeAnimation()");
00101 if(token == "}"){ break; }
00102 readSceneNodeAnimation(token);
00103 }
00104 }else if(chunkName == "SceneNodeAnimationData"){
00105
00106 openChunk();
00107 while(true){
00108 String token = readToken("readSceneNodeAnimationData()");
00109 if(token == "}"){ break; }
00110 readSceneNodeAnimationData(token);
00111 }
00112 }else if(chunkName == "CharacterModelAnimation"){
00113
00114 openChunk();
00115 while(true){
00116 String token = readToken("readCharacterModelAnimation()");
00117 if(token == "}"){ break; }
00118 readCharacterModelAnimation(token);
00119 }
00120 }else if(chunkName == "CharacterModelAnimationData"){
00121
00122 openChunk();
00123 while(true){
00124 String token = readToken("readCharacterModelAnimationData()");
00125 if(token == "}"){ break; }
00126 readCharacterModelAnimationData(token);
00127 }
00128 }else if(chunkName == "AnimationSetLink"){
00129 readAnimationSetLinkList();
00130 }else if(chunkName == "CameraLink"){
00131 readCameraLinkList();
00132 }else if(chunkName == "SceneNodeLink"){
00133 readSceneNodeLinkList();
00134 }else if(chunkName == "CharacterModelLink"){
00135 readCharacterModelLinkList();
00136 }else{
00137 ErrorOut("TextAnimationLoader::load() "
00138 "invalid chunk %s (line %d)",
00139 chunkName.getBytes(), tokenizer_->getLineNumber());
00140 }
00141 }
00142 delete tokenizer_;
00143 }
00144
00145
00146 void TextAnimationLoader::readHeader(){
00147 skipWord("Header");
00148 openChunk();
00149 skipWord("type");
00150 skipWord("LampTextAnimationFormat");
00151 skipWord("version");
00152 skipWord("0_9_0");
00153 closeChunk();
00154 }
00155
00156
00157
00158
00159 void TextAnimationLoader::readAnimationSetList(){
00160 openChunk();
00161 while(true){
00162 String token = readToken("readAnimationSetList()");
00163 if(token == "}"){ break; }
00164 readAnimationSet(token);
00165 }
00166 }
00167
00168
00169 void TextAnimationLoader::readAnimationSet(const String& name){
00170 AnimationSet* animation = manager_->createAnimationSet(name);
00171 openChunk();
00172
00173 skipWord("enabled");
00174 animation->setEnabled(readBool());
00175 closeChunk();
00176 }
00177
00178
00179
00180
00181 void TextAnimationLoader::readCameraAnimation(const String& name){
00182 CameraAnimation* animation = manager_->createCamera(name);
00183 openChunk();
00184
00185 skipWord("targetName");
00186 animation->setTargetName(readToken("readCameraAnimation()"));
00187
00188 skipWord("enabled");
00189 animation->setEnabled(readBool());
00190 closeChunk();
00191 }
00192
00193
00194 void TextAnimationLoader::readCameraAnimationData(const String& name){
00195 CameraAnimationData* data = manager_->createCameraData(name);
00196 openChunk();
00197 skipWord("sequenceCount");
00198 int sequenceCount = readInt();
00199 data->setSequenceCount(sequenceCount);
00200 for(int i = 0; i < sequenceCount; i++){
00201 skipWord("sequence");
00202 int sequenceNumber = readInt();
00203 Assert(i == sequenceNumber);
00204 openChunk();
00205
00206 skipWord("rotation");
00207 data->setRotation(i, readRotationInterpolator());
00208
00209 skipWord("translation");
00210 data->setTranslation(i, readVectorInterpolator());
00211
00212 skipWord("looped");
00213 data->setLooped(i, readBool());
00214 closeChunk();
00215 }
00216 closeChunk();
00217 }
00218
00219
00220
00221
00222 void TextAnimationLoader::readSceneNodeAnimation(const String& name){
00223 SceneNodeAnimation* animation = manager_->createSceneNode(name);
00224 openChunk();
00225 skipWord("targetName");
00226 animation->setTargetName(readToken("readSceneNodeAnimation()"));
00227
00228 skipWord("enabled");
00229 animation->setEnabled(readBool());
00230 closeChunk();
00231 }
00232
00233
00234 void TextAnimationLoader::readSceneNodeAnimationData(const String& name){
00235 SceneNodeAnimationData* data = manager_->createSceneNodeData(name);
00236 openChunk();
00237 skipWord("sequenceCount");
00238 int sequenceCount = readInt();
00239 data->setSequenceCount(sequenceCount);
00240 for(int i = 0; i < sequenceCount; i++){
00241 skipWord("sequence");
00242 int sequenceNumber = readInt();
00243 Assert(i == sequenceNumber);
00244 openChunk();
00245
00246 skipWord("scale");
00247 data->setScale(i, readVectorInterpolator());
00248
00249 skipWord("rotation");
00250 data->setRotation(i, readRotationInterpolator());
00251
00252 skipWord("translation");
00253 data->setTranslation(i, readVectorInterpolator());
00254
00255 skipWord("looped");
00256 data->setLooped(i, readBool());
00257 closeChunk();
00258 }
00259 closeChunk();
00260 }
00261
00262
00263
00264
00265 void TextAnimationLoader::readCharacterModelAnimation(const String& name){
00266 CharacterModelAnimation* animation =
00267 manager_->createCharacterModel(name);
00268 openChunk();
00269 skipWord("targetName");
00270 animation->setTargetName(readToken("readCharacterModelAnimation()"));
00271 skipWord("boneCount");
00272 int boneCount = readInt();
00273 animation->setBoneCount(boneCount);
00274 openChunk();
00275 for(int i = 0; i < boneCount; i++){
00276 animation->setBoneName(i, readToken("readCharacterModelAnimation()"));
00277 }
00278 closeChunk();
00279
00280 skipWord("enabled");
00281 animation->setEnabled(readBool());
00282 closeChunk();
00283 }
00284
00285
00286 void TextAnimationLoader::readCharacterModelAnimationData(const String& name){
00287 CharacterModelAnimationData* data =
00288 manager_->createCharacterModelData(name);
00289 openChunk();
00290 skipWord("boneCount");
00291 int boneCount = readInt();
00292 data->setBoneCount(boneCount);
00293 skipWord("sequenceCount");
00294 int sequenceCount = readInt();
00295 data->setSequenceCount(sequenceCount);
00296 for(int i = 0; i < sequenceCount; i++){
00297 skipWord("sequence");
00298 int sequenceNumber = readInt();
00299 Assert(i == sequenceNumber);
00300 openChunk();
00301 for(int j = 0; j < boneCount; j++){
00302 skipWord("bone");
00303 int boneNumber = readInt();
00304 Assert(j == boneNumber);
00305 openChunk();
00306
00307 skipWord("scale");
00308 data->setScale(i, j, readVectorInterpolator());
00309
00310 skipWord("rotation");
00311 data->setRotation(i, j, readRotationInterpolator());
00312
00313 skipWord("translation");
00314 data->setTranslation(i, j, readVectorInterpolator());
00315 closeChunk();
00316 }
00317
00318 skipWord("looped");
00319 data->setLooped(i, readBool());
00320 closeChunk();
00321 }
00322 closeChunk();
00323 }
00324
00325
00326
00327
00328 void TextAnimationLoader::readAnimationSetLinkList(){
00329 openChunk();
00330 while(true){
00331 String token = readToken("readAnimationSetLinkList()");
00332 if(token == "}"){ break; }
00333 readAnimationSetLink(token);
00334 }
00335 }
00336
00337
00338 void TextAnimationLoader::readAnimationSetLink(const String& name){
00339 AnimationSet* animationSet = NULL;
00340 Animation* animation = manager_->search(name);
00341 if(animation != NULL){ animationSet = animation->castAnimationSet(); }
00342 if(animationSet == NULL){
00343 ErrorOut("TextAnimationLoader::readAnimationSetLink() "
00344 "not found AnimationSet %s (line %d)",
00345 name.getBytes(), tokenizer_->getLineNumber());
00346 }
00347 openChunk();
00348 while(true){
00349 String token = readToken("readAnimationSetLink()");
00350 if(token == "}"){ break; }
00351
00352 Animation* child = manager_->search(token);
00353 if(child == NULL){
00354 ErrorOut("TextAnimationLoader::readAnimationSetLink() "
00355 "not found animation %s (line %d)",
00356 token.getBytes(), tokenizer_->getLineNumber());
00357 }
00358 animationSet->addAnimation(child);
00359 }
00360 }
00361
00362
00363
00364
00365 void TextAnimationLoader::readCameraLinkList(){
00366 CameraAnimation* camera;
00367 CameraAnimationData* cameraData;
00368 openChunk();
00369 while(true){
00370 String token = readToken("readCameraLinkList()");
00371 if(token == "}"){ break; }
00372 Animation* animation = manager_->search(token);
00373 if(animation == NULL){
00374 ErrorOut("TextAnimationLoader::readCameraLinkList() "
00375 "not found CameraAnimation %s (line %d)",
00376 token.getBytes(), tokenizer_->getLineNumber());
00377 }
00378 camera = animation->castCameraAnimation();
00379 if(camera == NULL){
00380 ErrorOut("TextAnimationLoader::readCameraLinkList() "
00381 "not found CameraAnimation %s (line %d)",
00382 token.getBytes(), tokenizer_->getLineNumber());
00383 }
00384 String target = readToken("readCameraLinkList()");
00385 AnimationData* data = manager_->searchData(target);
00386 if(data == NULL){
00387 ErrorOut("TextAnimationLoader::readCameraLinkList() "
00388 "not found CameraAnimationData %s (line %d)",
00389 token.getBytes(), tokenizer_->getLineNumber());
00390 }
00391 cameraData = data->castCameraAnimationData();
00392 if(cameraData == NULL){
00393 ErrorOut("TextAnimationLoader::readCameraLinkList() "
00394 "not found CameraAnimationData %s (line %d)",
00395 token.getBytes(), tokenizer_->getLineNumber());
00396 }
00397 camera->setCameraAnimationData(cameraData);
00398 }
00399 }
00400
00401
00402
00403
00404 void TextAnimationLoader::readSceneNodeLinkList(){
00405 SceneNodeAnimation* sceneNode;
00406 SceneNodeAnimationData* sceneNodeData;
00407 openChunk();
00408 while(true){
00409 String token = readToken("readSceneNodeLinkList()");
00410 if(token == "}"){ break; }
00411 Animation* animation = manager_->search(token);
00412 if(animation == NULL){
00413 ErrorOut("TextAnimationLoader::readSceneNodeLinkList() "
00414 "not found SceneNodeAnimation %s (line %d)",
00415 token.getBytes(), tokenizer_->getLineNumber());
00416 }
00417 sceneNode = animation->castSceneNodeAnimation();
00418 if(sceneNode == NULL){
00419 ErrorOut("TextAnimationLoader::readSceneNodeLinkList() "
00420 "not found SceneNodeAnimation %s (line %d)",
00421 token.getBytes(), tokenizer_->getLineNumber());
00422 }
00423 String target = readToken("readSceneNodeLinkList()");
00424 AnimationData* data = manager_->searchData(target);
00425 if(data == NULL){
00426 ErrorOut("TextAnimationLoader::readSceneNodeLinkList() "
00427 "not found SceneNodeAnimationData %s (line %d)",
00428 token.getBytes(), tokenizer_->getLineNumber());
00429 }
00430 sceneNodeData = data->castSceneNodeAnimationData();
00431 if(sceneNodeData == NULL){
00432 ErrorOut("TextAnimationLoader::readSceneNodeLinkList() "
00433 "not found SceneNodeAnimationData %s (line %d)",
00434 token.getBytes(), tokenizer_->getLineNumber());
00435 }
00436 sceneNode->setSceneNodeAnimationData(sceneNodeData);
00437 }
00438 }
00439
00440
00441
00442
00443 void TextAnimationLoader::readCharacterModelLinkList(){
00444 CharacterModelAnimation* characterModel;
00445 CharacterModelAnimationData* characterModelData;
00446 openChunk();
00447 while(true){
00448 String token = readToken("readCharacterModelLinkList()");
00449 if(token == "}"){ break; }
00450 Animation* animation = manager_->search(token);
00451 if(animation == NULL){
00452 ErrorOut("TextAnimationLoader::readCharacterModelLinkList() "
00453 "not found CharacterModelAnimation %s (line %d)",
00454 token.getBytes(), tokenizer_->getLineNumber());
00455 }
00456 characterModel = animation->castCharacterModelAnimation();
00457 if(characterModel == NULL){
00458 ErrorOut("TextAnimationLoader::readCharacterModelLinkList() "
00459 "not found CharacterModelAnimation %s (line %d)",
00460 token.getBytes(), tokenizer_->getLineNumber());
00461 }
00462 String target = readToken("readCharacterModelLinkList()");
00463 AnimationData* data = manager_->searchData(target);
00464 if(data == NULL){
00465 ErrorOut("TextAnimationLoader::readCharacterModelLinkList() "
00466 "not found CharacterModelAnimationData %s (line %d)",
00467 token.getBytes(), tokenizer_->getLineNumber());
00468 }
00469 characterModelData = data->castCharacterModelAnimationData();
00470 if(characterModelData == NULL){
00471 ErrorOut("TextAnimationLoader::readCharacterModelLinkList() "
00472 "not found CharacterModelAnimationData %s (line %d)",
00473 token.getBytes(), tokenizer_->getLineNumber());
00474 }
00475 characterModel->setCharacterModelAnimationData(characterModelData);
00476 }
00477 }
00478
00479
00480
00481
00482 bool TextAnimationLoader::readBool(){
00483 String token = readToken("readBool()");
00484 if(token == "true"){ return true; }
00485 else if(token == "false"){ return false; }
00486 ErrorOut("TextAnimationLoader::readBool() invalid token %s (line %d)",
00487 token.getBytes(), tokenizer_->getLineNumber());
00488 return false;
00489 }
00490
00491
00492 int TextAnimationLoader::readInt(){
00493 String token = readToken("readInt()");
00494 int value = 0;
00495 bool result = token.parseInt(&value);
00496 if(!result){
00497 ErrorOut("TextAnimationLoader::readInt() invalid token %s (line %d)",
00498 token.getBytes(), tokenizer_->getLineNumber());
00499 }
00500 return value;
00501 }
00502
00503
00504 float TextAnimationLoader::readFloat(){
00505 String token = readToken("readFloat()");
00506 float value = 0.f;
00507 bool result = token.parseFloat(&value);
00508 if(!result){
00509 ErrorOut("TextAnimationLoader::readFloat() invalid token %s (line %d)",
00510 token.getBytes(), tokenizer_->getLineNumber());
00511 }
00512 return value;
00513 }
00514
00515
00516 Vector3 TextAnimationLoader::readVector3(){
00517 Vector3 result;
00518 openChunk();
00519 result.x = readFloat();
00520 result.y = readFloat();
00521 result.z = readFloat();
00522 closeChunk();
00523 return result;
00524 }
00525
00526
00527 Quaternion TextAnimationLoader::readQuaternion(){
00528 Quaternion result;
00529 openChunk();
00530 result.x = readFloat();
00531 result.y = readFloat();
00532 result.z = readFloat();
00533 result.w = readFloat();
00534 closeChunk();
00535 return result;
00536 }
00537
00538
00539
00540
00541 VectorInterpolator* TextAnimationLoader::readVectorInterpolator(){
00542 String token = readToken("readVectorInterpolator()");
00543
00544 if(token.equals("NULL")){
00545 return NULL;
00546 }else if(token.equals("{")){
00547
00548 skipWord("type");
00549 String type = readToken("readVectorInterpolator()");
00550 if(type.equals("Constant")){
00551 return readVectorConstantInterpolator();
00552 }else if(type.equals("Array")){
00553 return readVectorArrayInterpolator();
00554 }else if(type.equals("Linear")){
00555 return readVectorLinearInterpolator();
00556 }else{
00557 ErrorOut("TextAnimationLoader::readVectorInterpolator() "
00558 "Unknown interpolator type %s (line %d)",
00559 token.getBytes(), tokenizer_->getLineNumber());
00560 }
00561 }else{
00562 ErrorOut("TextAnimationLoader::readVectorInterpolator() "
00563 "invalid token %s (line %d)",
00564 token.getBytes(), tokenizer_->getLineNumber());
00565 }
00566 return NULL;
00567 }
00568
00569
00570 VectorInterpolator* TextAnimationLoader::readVectorConstantInterpolator(){
00571 VectorConstantInterpolator* interpolator = new VectorConstantInterpolator();
00572 skipWord("length");
00573 interpolator->setLength(readFloat());
00574 skipWord("value");
00575 interpolator->setValue(readVector3());
00576 closeChunk();
00577 return interpolator;
00578 }
00579
00580
00581 VectorInterpolator* TextAnimationLoader::readVectorArrayInterpolator(){
00582 VectorArrayInterpolator* interpolator = new VectorArrayInterpolator();
00583 skipWord("value");
00584 int size = readInt();
00585 interpolator->setSize(size);
00586 openChunk();
00587 for(int i = 0; i < size; i++){ interpolator->setValue(i, readVector3()); }
00588 closeChunk();
00589 closeChunk();
00590 return interpolator;
00591 }
00592
00593
00594 VectorInterpolator* TextAnimationLoader::readVectorLinearInterpolator(){
00595 VectorLinearInterpolator* interpolator = new VectorLinearInterpolator();
00596 skipWord("value");
00597 int keyCount = readInt();
00598 interpolator->setKeyCount(keyCount);
00599 openChunk();
00600 for(int i = 0; i < keyCount; i++){
00601 float time = readFloat();
00602 interpolator->setKey(i, time, readVector3());
00603 }
00604 closeChunk();
00605 closeChunk();
00606 return interpolator;
00607 }
00608
00609
00610
00611
00612 RotationInterpolator* TextAnimationLoader::readRotationInterpolator(){
00613 String token = readToken("readRotationInterpolator()");
00614
00615 if(token.equals("NULL")){
00616 return NULL;
00617 }else if(token.equals("{")){
00618
00619 skipWord("type");
00620 String type = readToken("readRotationInterpolator()");
00621 if(type.equals("Constant")){
00622 return readRotationConstantInterpolator();
00623 }else if(type.equals("EulerArray")){
00624 return readEulerArrayInterpolator();
00625 }else if(type.equals("QuaternionArray")){
00626 return readQuaternionArrayInterpolator();
00627 }else if(type.equals("QuaternionLinear")){
00628 return readQuaternionLinearInterpolator();
00629 }else{
00630 ErrorOut("TextAnimationLoader::readRotationInterpolator() "
00631 "Unknown interpolator type %s (line %d)",
00632 token.getBytes(), tokenizer_->getLineNumber());
00633 }
00634 }else{
00635 ErrorOut("TextAnimationLoader::readRotationInterpolator() "
00636 "invalid token %s (line %d)",
00637 token.getBytes(), tokenizer_->getLineNumber());
00638 }
00639 return NULL;
00640 }
00641
00642
00643 RotationInterpolator* TextAnimationLoader::readRotationConstantInterpolator(){
00644 RotationConstantInterpolator* interpolator =
00645 new RotationConstantInterpolator();
00646 skipWord("length");
00647 interpolator->setLength(readFloat());
00648 String valueType = readToken("readRotationConstantInterpolator()");
00649 if(valueType.equals("quaternionValue")){
00650 interpolator->setQuaternion(readQuaternion());
00651 }else if(valueType.equals("eulerValue")){
00652 interpolator->setEuler(readVector3());
00653 }else{
00654 ErrorOut("TextAnimationLoader::readRotationConstantInterpolator() "
00655 "Unknown value type %s (line %d)",
00656 valueType.getBytes(), tokenizer_->getLineNumber());
00657 }
00658 closeChunk();
00659 return interpolator;
00660 }
00661
00662
00663 RotationInterpolator* TextAnimationLoader::readEulerArrayInterpolator(){
00664 EulerArrayInterpolator* interpolator =
00665 new EulerArrayInterpolator();
00666 skipWord("value");
00667 int size = readInt();
00668 interpolator->setSize(size);
00669 openChunk();
00670 for(int i = 0; i < size; i++){ interpolator->setValue(i, readVector3()); }
00671 closeChunk();
00672 closeChunk();
00673 return interpolator;
00674 }
00675
00676
00677 RotationInterpolator* TextAnimationLoader::readQuaternionArrayInterpolator(){
00678 QuaternionArrayInterpolator* interpolator =
00679 new QuaternionArrayInterpolator();
00680 skipWord("value");
00681 int size = readInt();
00682 interpolator->setSize(size);
00683 openChunk();
00684 for(int i = 0; i < size; i++){
00685 interpolator->setValue(i, readQuaternion());
00686 }
00687 closeChunk();
00688 closeChunk();
00689 return interpolator;
00690 }
00691
00692
00693 RotationInterpolator* TextAnimationLoader::readQuaternionLinearInterpolator(){
00694 QuaternionLinearInterpolator* interpolator =
00695 new QuaternionLinearInterpolator();
00696 skipWord("value");
00697 int keyCount = readInt();
00698 interpolator->setKeyCount(keyCount);
00699 openChunk();
00700 for(int i = 0; i < keyCount; i++){
00701 float time = readFloat();
00702 interpolator->setKey(i, time, readQuaternion());
00703 }
00704 closeChunk();
00705 closeChunk();
00706 return interpolator;
00707 }
00708
00709
00710
00711
00712 String TextAnimationLoader::readToken(const String& caller){
00713 bool hasNext = tokenizer_->nextToken();
00714 if(!hasNext){
00715 ErrorOut("TextAnimationLoader::%s nothing token (line %d)",
00716 caller.getBytes(), tokenizer_->getLineNumber());
00717 }
00718 return tokenizer_->getToken();
00719 }
00720
00721
00722 void TextAnimationLoader::skipWord(const String& word){
00723 String token = readToken("skipWord()");
00724 if(token != word){
00725 ErrorOut("TextAnimationLoader::skipWord(%s) "
00726 "invalid token %s (line %d)",
00727 word.getBytes(), token.getBytes(), tokenizer_->getLineNumber());
00728 }
00729 }
00730
00731 }
00732