Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Namespace Members | Compound Members | File Members

# TextSceneLoader.cpp

Go to the documentation of this file.

    00001 //------------------------------------------------------------------------------
    00002 // Lamp : Open source game middleware
    00003 // Copyright (C) 2004  Junpei Ohtani ( Email : junpee@users.sourceforge.jp )
    00004 //
    00005 // This library is free software; you can redistribute it and/or
    00006 // modify it under the terms of the GNU Lesser General Public
    00007 // License as published by the Free Software Foundation; either
    00008 // version 2.1 of the License, or (at your option) any later version.
    00009 //
    00010 // This library is distributed in the hope that it will be useful,
    00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013 // Lesser General Public License for more details.
    00014 //
    00015 // You should have received a copy of the GNU Lesser General Public
    00016 // License along with this library; if not, write to the Free Software
    00017 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    00018 //------------------------------------------------------------------------------
    00019
    00020 /** @file
    00021  * テキストシーンローダ実装
    00022  * @author Junpee
    00023  */
    00024
    00025 #include "LampBasic.h"
    00026 #include "Graphics/InputOutput/TextSceneLoader.h"
    00027 #include "Core/InputOutput/TextFileReader.h"
    00028 #include "Core/InputOutput/StreamTokenizer.h"
    00029 #include "Core/InputOutput/FilePath.h"
    00030 #include "Core/Codec/Tga/TargaLoader.h"
    00031
    00032 #include "Graphics/Scene/Scene.h"
    00033 #include "Graphics/Fog/Fog.h"
    00034 #include "Graphics/Light/LightManager.h"
    00035 #include "Graphics/SceneNode/SceneNodeManager.h"
    00036 #include "Graphics/Model/ModelManager.h"
    00037 #include "Graphics/Mesh/MeshManager.h"
    00038 #include "Graphics/MeshData/MeshDataManager.h"
    00039 #include "Graphics/Material/MaterialManager.h"
    00040 #include "Graphics/Texture/TextureManager.h"
    00041 #include "Graphics/Picture/PictureManager.h"
    00042
    00043 namespace Lamp{
    00044
    00045 //------------------------------------------------------------------------------
    00046 // コンストラクタ
    00047 TextSceneLoader::TextSceneLoader(){
    00048 }
    00049 //------------------------------------------------------------------------------
    00050 // デストラクタ
    00051 TextSceneLoader::~TextSceneLoader(){
    00052 }
    00053 //------------------------------------------------------------------------------
    00054 // ロード
    00055 void TextSceneLoader::load(const String& filePath, Scene* scene){
    00056     load(filePath, scene, scene->getRootNode());
    00057 }
    00058 //------------------------------------------------------------------------------
    00059 // ロード
    00060 void TextSceneLoader::load(const String& filePath, Scene* scene,
    00061     SceneNode* rootNode){
    00062     FilePath path(filePath);
    00063     Assert(path.existFile());
    00064     TextFileReader* textFileReader = new TextFileReader(filePath);
    00065     load(textFileReader, scene, rootNode, path.getFolderPath());
    00066     delete textFileReader;
    00067 }
    00068 //------------------------------------------------------------------------------
    00069 // ロード
    00070 void TextSceneLoader::load(TextReader* textReader, Scene* scene,
    00071     const String& basePath){
    00072     load(textReader, scene, scene->getRootNode(), basePath);
    00073 }
    00074 //------------------------------------------------------------------------------
    00075 // ロード
    00076 void TextSceneLoader::load(TextReader* textReader, Scene* scene,
    00077     SceneNode* rootNode, const String& basePath){
    00078     // 初期化
    00079     basePath_ = basePath;
    00080     tokenizer_ = new StreamTokenizer(textReader);
    00081     scene_ = scene;
    00082     rootNode_ = rootNode;
    00083     sceneNodeManager_ = scene->getSceneNodeManager();
    00084     lightManager_ = scene->getLightManager();
    00085     modelManager_ = scene->getModelManager();
    00086     meshManager_ = scene->getMeshManager();
    00087     meshDataManager_ = scene->getMeshDataManager();
    00088     materialManager_ = scene->getMaterialManager();
    00089     textureManager_ = scene->getTextureManager();
    00090     pictureManager_ = scene->getPictureManager();
    00091
    00092     // ルートノードを無効にしておく
    00093     bool rootNodeEnabled = rootNode_->isEnabled();
    00094     rootNode_->setEnabled(false);
    00095
    00096     // ヘッダの読み込み
    00097     readHeader();
    00098
    00099     while(true){
    00100         // トークン読み終わり
    00101         if(!tokenizer_->nextToken()){ break; }
    00102         String chunkName = tokenizer_->getToken();
    00103         if(chunkName == "Fog"){
    00104             readFog();
    00105         }else if(chunkName == "SceneNode"){
    00106             readSceneNodeList();
    00107         }else if(chunkName == "Light"){
    00108             readLightList();
    00109         }else if(chunkName == "Model"){
    00110             readModelList();
    00111         }else if(chunkName == "Mesh"){
    00112             readMeshList();
    00113         }else if(chunkName == "MeshData"){
    00114             readMeshDataList();
    00115         }else if(chunkName == "Material"){
    00116             readMaterialList();
    00117         }else if(chunkName == "Texture"){
    00118             readTextureList();
    00119         }else if(chunkName == "Picture"){
    00120             readPictureList();
    00121         }else if(chunkName == "SceneNodeLink"){
    00122             readSceneNodeLinkList();
    00123         }else if(chunkName == "ModelLink"){
    00124             readModelLinkList();
    00125         }else if(chunkName == "MeshLink"){
    00126             readMeshLinkList();
    00127         }else if(chunkName == "MaterialLink"){
    00128             readMaterialLinkList();
    00129         }else if(chunkName == "TextureLink"){
    00130             readTextureLinkList();
    00131         }else{
    00132             ErrorOut("TextSceneLoader::load() "
    00133                 "invalid chunk %s (line %d)",
    00134                 chunkName.getBytes(), tokenizer_->getLineNumber());
    00135         }
    00136     }
    00137     delete tokenizer_;
    00138
    00139     rootNode_->setEnabled(rootNodeEnabled);
    00140 }
    00141 //------------------------------------------------------------------------------
    00142 // ヘッダの読み込み
    00143 void TextSceneLoader::readHeader(){
    00144     skipWord("Header");
    00145     openChunk();
    00146     skipWord("type");
    00147     skipWord("LampTextSceneFormat");
    00148     skipWord("version");
    00149     skipWord("0_9_0");
    00150     closeChunk();
    00151 }
    00152 //------------------------------------------------------------------------------
    00153 // フォグ
    00154 //------------------------------------------------------------------------------
    00155 // フォグの読み込み
    00156 void TextSceneLoader::readFog(){
    00157     Fog* fog = scene_->getFog();
    00158     openChunk();
    00159     // カラー
    00160     skipWord("color");
    00161     fog->setColor(readColor4c());
    00162     // モード
    00163     skipWord("mode");
    00164     fog->setModeString(readToken("TextSceneLoader::readFog()"));
    00165     // 濃度
    00166     skipWord("density");
    00167     fog->setDensity(readFloat());
    00168     // ニア
    00169     skipWord("near");
    00170     fog->setNear(readFloat());
    00171     // ファー
    00172     skipWord("far");
    00173     fog->setFar(readFloat());
    00174     // 有効、無効
    00175     skipWord("enabled");
    00176     fog->setEnabled(readBool());
    00177     closeChunk();
    00178 }
    00179 //------------------------------------------------------------------------------
    00180 // シーンノード
    00181 //------------------------------------------------------------------------------
    00182 // シーンノードリストの読み込み
    00183 void TextSceneLoader::readSceneNodeList(){
    00184     openChunk();
    00185     while(true){
    00186         String token = readToken("readSceneNodeList()");
    00187         if(token == "}"){ break; }
    00188         // シーンノードの識別
    00189         openChunk();
    00190         skipWord("type");
    00191         String type = readToken("readSceneNodeList()");
    00192         if(type == "Standard"){
    00193             readSceneNode(token);
    00194         }else if(type == "LOD"){
    00195             readLODSceneNode(token);
    00196         }else{
    00197             ErrorOut("TextSceneLoader::readSceneNodeList() "
    00198                 "invalid type %s (line %d)",
    00199                 type.getBytes(), tokenizer_->getLineNumber());
    00200         }
    00201         closeChunk();
    00202     }
    00203 }
    00204 //------------------------------------------------------------------------------
    00205 // シーンノードの読み込み
    00206 void TextSceneLoader::readSceneNode(const String& name){
    00207     SceneNode* sceneNode = sceneNodeManager_->createSceneNode(name);
    00208     // スケール
    00209     skipWord("scale");
    00210     sceneNode->setScale(readVector3());
    00211     // 回転
    00212     skipWord("rotation");
    00213     sceneNode->setRotationXYZ(readVector3());
    00214     // 移動
    00215     skipWord("translation");
    00216     sceneNode->setTranslation(readVector3());
    00217     // 有効、無効フラグ
    00218     skipWord("enabled");
    00219     sceneNode->setEnabled(readBool());
    00220 }
    00221 //------------------------------------------------------------------------------
    00222 // レベルオブディティールシーンノードの読み込み
    00223 void TextSceneLoader::readLODSceneNode(const String& name){
    00224     LODSceneNode* sceneNode = sceneNodeManager_->createLODSceneNode(name);
    00225     // スケール
    00226     skipWord("scale");
    00227     sceneNode->setScale(readVector3());
    00228     // 回転
    00229     skipWord("rotation");
    00230     sceneNode->setRotationXYZ(readVector3());
    00231     // 移動
    00232     skipWord("translation");
    00233     sceneNode->setTranslation(readVector3());
    00234     // 有効、無効フラグ
    00235     skipWord("enabled");
    00236     sceneNode->setEnabled(readBool());
    00237     // LOD分割数
    00238     skipWord("lodThresholdCount");
    00239     int lodThresholdCount = readInt();
    00240     sceneNode->setLODThresholdCount(lodThresholdCount);
    00241     // LOD分割値
    00242     openChunk();
    00243     for(int i = 0; i < lodThresholdCount; i++){
    00244         sceneNode->setLODThreshold(i, readFloat());
    00245     }
    00246     closeChunk();
    00247 }
    00248 //------------------------------------------------------------------------------
    00249 // ライト
    00250 //------------------------------------------------------------------------------
    00251 // ライトリストの読み込み
    00252 void TextSceneLoader::readLightList(){
    00253     openChunk();
    00254     while(true){
    00255         String token = readToken("readLightList()");
    00256         if(token == "}"){ break; }
    00257         // ライトの識別
    00258         openChunk();
    00259         skipWord("type");
    00260         String type = readToken("readLightList()");
    00261         if(type == "Ambient"){
    00262             readAmbientLight(token);
    00263         }else if(type == "Directional"){
    00264             readDirectionalLight(token);
    00265         }else if(type == "Point"){
    00266             readPointLight(token);
    00267         }else{
    00268             ErrorOut("TextSceneLoader::readLightList() "
    00269                 "invalid type %s (line %d)",
    00270                 type.getBytes(), tokenizer_->getLineNumber());
    00271         }
    00272         closeChunk();
    00273     }
    00274 }
    00275 //------------------------------------------------------------------------------
    00276 // ライトの読み込み
    00277 void TextSceneLoader::readLight(Light* light){
    00278     skipWord("Light");
    00279     openChunk();
    00280     // ライトマスク
    00281     skipWord("lightMask");
    00282     light->setLightMask(readUInt());
    00283     // 有効、無効フラグ
    00284     skipWord("enabled");
    00285     light->setEnabled(readBool());
    00286     closeChunk();
    00287 }
    00288 //------------------------------------------------------------------------------
    00289 // アンビエントライトの読み込み
    00290 void TextSceneLoader::readAmbientLight(const String& name){
    00291     AmbientLight* light = lightManager_->createAmbientLight(name);
    00292     // ライトカラー
    00293     skipWord("color");
    00294     light->setColor(readColor3f());
    00295     // ライトの読み込み
    00296     readLight(light);
    00297 }
    00298 //------------------------------------------------------------------------------
    00299 // ディレクショナルライトの読み込み
    00300 void TextSceneLoader::readDirectionalLight(const String& name){
    00301     DirectionalLight* light = lightManager_->createDirectionalLight(name);
    00302     // ディフューズカラー
    00303     skipWord("diffuse");
    00304     light->setDiffuseColor(readColor3f());
    00305     // スペキュラカラー
    00306     skipWord("specular");
    00307     light->setSpecularColor(readColor3f());
    00308     // 方向
    00309     skipWord("direction");
    00310     light->setDirection(readVector3());
    00311     // ライトの読み込み
    00312     readLight(light);
    00313 }
    00314 //------------------------------------------------------------------------------
    00315 // ポイントライトの読み込み
    00316 void TextSceneLoader::readPointLight(const String& name){
    00317     PointLight* light = lightManager_->createPointLight(name);
    00318     // ディフューズカラー
    00319     skipWord("diffuse");
    00320     light->setDiffuseColor(readColor3f());
    00321     // スペキュラカラー
    00322     skipWord("specular");
    00323     light->setSpecularColor(readColor3f());
    00324     // 位置
    00325     skipWord("position");
    00326     light->setPosition(readVector3());
    00327     // レンジ
    00328     skipWord("range");
    00329     light->setRange(readFloat());
    00330     // 減衰係数
    00331     skipWord("attenuation");
    00332     Vector3 attenuation = readVector3();
    00333     light->setAttenuation(attenuation.x, attenuation.y, attenuation.z);
    00334     // ライトの読み込み
    00335     readLight(light);
    00336 }
    00337 //------------------------------------------------------------------------------
    00338 // モデル
    00339 //------------------------------------------------------------------------------
    00340 // モデルリストの読み込み
    00341 void TextSceneLoader::readModelList(){
    00342     openChunk();
    00343     while(true){
    00344         String token = readToken("readModelList()");
    00345         if(token == "}"){ break; }
    00346         // モデルの識別
    00347         openChunk();
    00348         skipWord("type");
    00349         String type = readToken("readModelList()");
    00350         if(type == "Standard"){
    00351             readStandardModel(token);
    00352         }else if(type == "Character"){
    00353             readCharacterModel(token);
    00354         }else{
    00355             ErrorOut("TextSceneLoader::readModelList() "
    00356                 "invalid type %s (line %d)",
    00357                 type.getBytes(), tokenizer_->getLineNumber());
    00358         }
    00359         closeChunk();
    00360     }
    00361 }
    00362 //------------------------------------------------------------------------------
    00363 // 標準モデルの読み込み
    00364 void TextSceneLoader::readStandardModel(const String& name){
    00365     StandardModel* model = modelManager_->createStandardModel(name);
    00366     // 有効、無効フラグ
    00367     skipWord("enabled");
    00368     model->setEnabled(readBool());
    00369 }
    00370 //------------------------------------------------------------------------------
    00371 // キャラクタモデルの読み込み
    00372 void TextSceneLoader::readCharacterModel(const String& name){
    00373     CharacterModel* model = modelManager_->createCharacterModel(name);
    00374     // 有効、無効フラグ
    00375     skipWord("enabled");
    00376     model->setEnabled(readBool());
    00377     // ボーン
    00378     skipWord("bone");
    00379     openChunk();
    00380     while(true){
    00381         String boneName = readToken("TextSceneLoader::readCharacterModel()");
    00382         if(boneName == "}"){ break; }
    00383         readBone(model, boneName);
    00384     }
    00385     // ボーンリンク
    00386     skipWord("boneLink");
    00387     openChunk();
    00388     while(true){
    00389         String boneName = readToken("TextSceneLoader::readCharacterModel()");
    00390         if(boneName == "}"){ break; }
    00391         Bone* bone = model->searchBone(boneName);
    00392         openChunk();
    00393         while(true){
    00394             String childName = readToken("TextSceneLoader::readCharacterModel()");
    00395             if(childName == "}"){ break; }
    00396             Bone* child = model->searchBone(childName);
    00397             bone->addBone(child);
    00398         }
    00399     }
    00400 }
    00401 //------------------------------------------------------------------------------
    00402 // ボーンの読み込み
    00403 void TextSceneLoader::readBone(CharacterModel* model, const String& name){
    00404     Bone* bone = model->createBone(name);
    00405     openChunk();
    00406     // ポーズ逆行列
    00407     skipWord("inversePoseMatrix");
    00408     skipWord("Matrix34");
    00409     bone->setInversePoseMatrix(readMatrix34());
    00410     // スケール
    00411     skipWord("scale");
    00412     bone->setScale(readVector3());
    00413     // 回転
    00414     skipWord("rotation");
    00415     bone->setRotationXYZ(readVector3());
    00416     // 移動
    00417     skipWord("translation");
    00418     bone->setTranslation(readVector3());
    00419     closeChunk();
    00420 }
    00421 //------------------------------------------------------------------------------
    00422 // メッシュ
    00423 //------------------------------------------------------------------------------
    00424 // メッシュリストの読み込み
    00425 void TextSceneLoader::readMeshList(){
    00426     openChunk();
    00427     while(true){
    00428         String token = readToken("readMeshList()");
    00429         if(token == "}"){ break; }
    00430         // メッシュの識別
    00431         openChunk();
    00432         skipWord("type");
    00433         String type = readToken("readMeshList()");
    00434         if(type == "Rigid"){
    00435             readRigidMesh(token);
    00436         }else if(type == "Character"){
    00437             readCharacterMesh(token);
    00438         }else{
    00439             ErrorOut("TextSceneLoader::readMeshList() "
    00440                 "invalid type %s (line %d)",
    00441                 type.getBytes(), tokenizer_->getLineNumber());
    00442         }
    00443         closeChunk();
    00444     }
    00445 }
    00446 //------------------------------------------------------------------------------
    00447 // 剛体メッシュの読み込み
    00448 void TextSceneLoader::readRigidMesh(const String& name){
    00449     RigidMesh* mesh = meshManager_->createRigidMesh(name);
    00450     // 有効、無効フラグ
    00451     skipWord("enabled");
    00452     mesh->setEnabled(readBool());
    00453 }
    00454 //------------------------------------------------------------------------------
    00455 // キャラクタメッシュの読み込み
    00456 void TextSceneLoader::readCharacterMesh(const String& name){
    00457     CharacterMesh* mesh = meshManager_->createCharacterMesh(name);
    00458     // 有効、無効フラグ
    00459     skipWord("enabled");
    00460     mesh->setEnabled(readBool());
    00461 }
    00462 //------------------------------------------------------------------------------
    00463 // メッシュデータ
    00464 //------------------------------------------------------------------------------
    00465 // メッシュデータリストの読み込み
    00466 void TextSceneLoader::readMeshDataList(){
    00467     openChunk();
    00468     while(true){
    00469         String token = readToken("readMeshDataList()");
    00470         if(token == "}"){ break; }
    00471         // メッシュデータの読み込み
    00472         readMeshData(token);
    00473     }
    00474 }
    00475 //------------------------------------------------------------------------------
    00476 // メッシュデータの読み込み
    00477 void TextSceneLoader::readMeshData(const String& name){
    00478     MeshData* meshData = meshDataManager_->createMeshData(name);
    00479     openChunk();
    00480     // バウンディングボックス
    00481     skipWord("boundingBox");
    00482     meshData->setBoundingBox(readAxisAlignedBox());
    00483     // バウンディングスフィア
    00484     skipWord("boundingSphere");
    00485     meshData->setBoundingSphere(readSphere());
    00486     // プリミティブタイプ
    00487     skipWord("primitiveType");
    00488     String primitiveType = readToken("readMeshData()");
    00489     meshData->setPrimitiveType(Mesh::primitiveTypeFromString(primitiveType));
    00490     // 頂点インデックスの読み出し
    00491     if(meshData->hasVertexIndices()){
    00492         skipWord("indices");
    00493         int indexCount = readInt();
    00494         meshData->setVertexIndexCount(indexCount);
    00495         openChunk();
    00496         for(int i = 0; i < indexCount; i++){
    00497             meshData->setVertexIndex(i, readUShort());
    00498         }
    00499         closeChunk();
    00500     }
    00501     // 法線を持っているか
    00502     skipWord("hasNormal");
    00503     bool hasNormal = readBool();
    00504     meshData->enableNormal(hasNormal);
    00505     // 頂点カラーを持っているか
    00506     skipWord("hasColor");
    00507     bool hasColor = readBool();
    00508     meshData->enableColor(hasColor);
    00509     // テクスチャ座標セット数
    00510     skipWord("texCoordSetCount");
    00511     int texCoordSetCount = readInt();
    00512     meshData->setTexCoordSetCount(texCoordSetCount);
    00513     // テクスチャ座標タイプ
    00514     skipWord("texCoordType");
    00515     int texCoordType[TexCoord::maxSetCount];
    00516     for(int i = 0; i < texCoordSetCount; i++){
    00517         texCoordType[i] = readInt();
    00518         meshData->setTexCoordType(i, (TexCoord::Type)texCoordType[i]);
    00519     }
    00520     // 頂点あたりボーン数
    00521     skipWord("bonesPerVertex");
    00522     int bonesPerVertex = readInt();
    00523     meshData->setBonesPerVertex(bonesPerVertex);
    00524     int weightsPerVertex = meshData->getWeightsPerVertex();
    00525     // 頂点データ
    00526     skipWord("vertices");
    00527     int vertexCount = readInt();
    00528     meshData->setVertexCount(vertexCount);
    00529     openChunk();
    00530     for(int i = 0; i < vertexCount; i++){
    00531         int index = readInt();
    00532         if(index != i){
    00533             ErrorOut("TextSceneLoader::readMeshData() "
    00534                 "invalid index %d (line %d)",
    00535                 index, tokenizer_->getLineNumber());
    00536         }
    00537         // 位置の読み込み
    00538         meshData->setPosition(i, readVector3());
    00539         // 法線の読み込み
    00540         if(hasNormal){ meshData->setNormal(i, readVector3()); }
    00541         // 頂点カラーの読み込み
    00542         if(hasColor){ meshData->setColor(i, readColor4c()); }
    00543         // テクスチャ座標の読み込み
    00544         float texCoord[4];
    00545         for(int j = 0; j < texCoordSetCount; j++){
    00546             openChunk();
    00547             for(int k = 0; k < texCoordType[j]; k++){
    00548                 texCoord[k] = readFloat();
    00549             }
    00550             closeChunk();
    00551             meshData->setTexCoord(i, j, texCoord, texCoordType[j]);
    00552         }
    00553         // ボーンインデックスの読み込み
    00554         if(bonesPerVertex != 0){
    00555             openChunk();
    00556             for(int j = 0; j < bonesPerVertex; j++){
    00557                 meshData->setBoneIndex(i, j, readUChar());
    00558             }
    00559             closeChunk();
    00560         }
    00561         // ウェイトの読み込み
    00562         if(weightsPerVertex != 0){
    00563             openChunk();
    00564             for(int j = 0; j < weightsPerVertex; j++){
    00565                 meshData->setWeight(i, j, readFloat());
    00566             }
    00567             closeChunk();
    00568         }
    00569     }
    00570     closeChunk();
    00571     closeChunk();
    00572 }
    00573 //------------------------------------------------------------------------------
    00574 // マテリアル
    00575 //------------------------------------------------------------------------------
    00576 // マテリアルリストの読み込み
    00577 void TextSceneLoader::readMaterialList(){
    00578     openChunk();
    00579     while(true){
    00580         String token = readToken("readMaterialList()");
    00581         if(token == "}"){ break; }
    00582         // マテリアルの識別
    00583         openChunk();
    00584         skipWord("type");
    00585         String type = readToken("readMaterialList()");
    00586         if(type == "Basic"){
    00587             readBasicMaterial(token);
    00588         }else{
    00589             ErrorOut("TextSceneLoader::readMaterialList() "
    00590                 "invalid type %s (line %d)",
    00591                 type.getBytes(), tokenizer_->getLineNumber());
    00592         }
    00593         closeChunk();
    00594     }
    00595 }
    00596 //------------------------------------------------------------------------------
    00597 // マテリアルの読み込み
    00598 void TextSceneLoader::readMaterial(Material* material){
    00599     skipWord("Material");
    00600     openChunk();
    00601     // 優先度
    00602     skipWord("priority");
    00603     material->setPriority(readInt());
    00604     // ブレンドモード
    00605     skipWord("blendMode");
    00606     String blendMode = readToken("readMaterial()");
    00607     material->setBlendMode(Material::blendModeFromString(blendMode));
    00608     // アルファ値
    00609     skipWord("alpha");
    00610     material->setAlpha(readFloat());
    00611     // ブレンドソース
    00612     skipWord("blendSource");
    00613     String blendSource = readToken("readMaterial()");
    00614     material->setBlendSource(Material::blendStateFromString(blendSource));
    00615     // ブレンドデスティネーション
    00616     skipWord("blendDestination");
    00617     String blendDestination = readToken("readMaterial()");
    00618     material->setBlendDestination(
    00619         Material::blendStateFromString(blendDestination));
    00620     // Z書き込み
    00621     skipWord("zWrite");
    00622     material->setZWrite(readBool());
    00623     // Zテスト
    00624     skipWord("zTest");
    00625     material->setZTest(readBool());
    00626     // フォグオプション
    00627     skipWord("fogOption");
    00628     String fogOption = readToken("readMaterial()");
    00629     material->setFogOption(Material::fogOptionFromString(fogOption));
    00630     // ライトマスク
    00631     skipWord("lightMask");
    00632     material->setLightMask(readUInt());
    00633     closeChunk();
    00634 }
    00635 //------------------------------------------------------------------------------
    00636 // 基本マテリアルの読み込み
    00637 void TextSceneLoader::readBasicMaterial(const String& name){
    00638     BasicMaterial* material = materialManager_->createBasicMaterial(name);
    00639     // ベースUVインデックス
    00640     skipWord("baseUVIndex");
    00641     material->setBaseUVIndex(readInt());
    00642     // 光沢UVインデックス
    00643     skipWord("glossUVIndex");
    00644     material->setGlossUVIndex(readInt());
    00645     // ライトUVインデックス
    00646     skipWord("lightUVIndex");
    00647     material->setLightUVIndex(readInt());
    00648     // 汚れUVインデックス
    00649     skipWord("stainUVIndex");
    00650     material->setStainUVIndex(readInt());
    00651
    00652     // ディフューズカラー
    00653     skipWord("diffuseColor");
    00654     material->setDiffuseColor(readColor3f());
    00655     // スペキュラカラー
    00656     skipWord("specularColor");
    00657     material->setSpecularColor(readColor3f());
    00658     // スペキュラパワー
    00659     skipWord("specularPower");
    00660     material->setSpecularPower(readFloat());
    00661     // アンビエントカラー
    00662     skipWord("ambientColor");
    00663     material->setAmbientColor(readColor3f());
    00664     // エミッシブカラー
    00665     skipWord("emissiveColor");
    00666     material->setEmissiveColor(readColor3f());
    00667     // マテリアルの読み込み
    00668     readMaterial(material);
    00669 }
    00670 //------------------------------------------------------------------------------
    00671 // テクスチャ
    00672 //------------------------------------------------------------------------------
    00673 // テクスチャリストの読み込み
    00674 void TextSceneLoader::readTextureList(){
    00675     openChunk();
    00676     while(true){
    00677         String token = readToken("readTextureList()");
    00678         if(token == "}"){ break; }
    00679         // テクスチャの識別
    00680         openChunk();
    00681         skipWord("type");
    00682         String type = readToken("readTextureList()");
    00683         if(type == "Surface"){
    00684             readSurfaceTexture(token);
    00685         }else{
    00686             ErrorOut("TextSceneLoader::readTextureList() "
    00687                 "invalid type %s (line %d)",
    00688                 type.getBytes(), tokenizer_->getLineNumber());
    00689         }
    00690         closeChunk();
    00691     }
    00692 }
    00693 //------------------------------------------------------------------------------
    00694 // サーフェーステクスチャの読み込み
    00695 void TextSceneLoader::readSurfaceTexture(const String& name){
    00696     SurfaceTexture* texture = textureManager_->createSurfaceTexture(name);
    00697     // アドレスモードU
    00698     skipWord("addressModeU");
    00699     String addressModeU = readToken("readSurfaceTexture()");
    00700     texture->setAddressModeU(Texture::addressModeFromString(addressModeU));
    00701     // アドレスモードV
    00702     skipWord("addressModeV");
    00703     String addressModeV = readToken("readSurfaceTexture()");
    00704     texture->setAddressModeV(Texture::addressModeFromString(addressModeV));
    00705     // リピートUV
    00706     skipWord("repeatUV");
    00707     texture->setRepeatUV(readTexCoord2());
    00708     // オフセットUV
    00709     skipWord("offsetUV");
    00710     texture->setOffsetUV(readTexCoord2());
    00711 }
    00712 //------------------------------------------------------------------------------
    00713 // ピクチャ
    00714 //------------------------------------------------------------------------------
    00715 // ピクチャリストの読み込み
    00716 void TextSceneLoader::readPictureList(){
    00717     openChunk();
    00718     while(true){
    00719         String token = readToken("readPictureList()");
    00720         if(token == "}"){ break; }
    00721         openChunk();
    00722         skipWord("path");
    00723         String path = readToken("readPictureList()");
    00724         closeChunk();
    00725         // 拡張子を取得
    00726         FilePath filePath(path);
    00727         String extension = filePath.getExtension();
    00728         // 拡張子にあわせてピクチャを読み分ける
    00729         Picture* picture;
    00730         if(extension == "tga"){
    00731             TargaLoader loader(basePath_ + path);
    00732             loader.loadHeader();
    00733             // アルファの有無
    00734             if(loader.hasAlpha()){
    00735                 picture = readPictureRGBA8(token, loader);
    00736             }else{
    00737                 picture = readPictureRGB8(token, loader);
    00738             }
    00739         }else{
    00740             ErrorOut("TextSceneLoader::readPictureList() "
    00741                 "Unsupported picture format %s (line %d)",
    00742                 path.getBytes(), tokenizer_->getLineNumber());
    00743             return;
    00744         }
    00745         // パスを設定する
    00746         picture->setPath(path);
    00747     }
    00748 }
    00749 //------------------------------------------------------------------------------
    00750 // RGB8ビットピクチャの読み込み
    00751 Picture* TextSceneLoader::readPictureRGB8(
    00752     const String& name, TargaLoader& loader){
    00753     PictureRGB8* picture = pictureManager_->createPictureRGB8(name);
    00754     picture->setSize(loader.getSize());
    00755     loader.loadImage(picture->getImageBuffer());
    00756     return picture;
    00757 }
    00758 //------------------------------------------------------------------------------
    00759 // RGBA8ビットピクチャの読み込み
    00760 Picture* TextSceneLoader::readPictureRGBA8(
    00761     const String& name, TargaLoader& loader){
    00762     PictureRGBA8* picture = pictureManager_->createPictureRGBA8(name);
    00763     picture->setSize(loader.getSize());
    00764     loader.loadImage(picture->getImageBuffer());
    00765     return picture;
    00766 }
    00767 //------------------------------------------------------------------------------
    00768 // シーンノードリンク
    00769 //------------------------------------------------------------------------------
    00770 // シーンノードリンクリストの読み込み
    00771 void TextSceneLoader::readSceneNodeLinkList(){
    00772     openChunk();
    00773     while(true){
    00774         String token = readToken("readSceneNodeLinkList()");
    00775         if(token == "}"){ break; }
    00776         readSceneNodeLink(token);
    00777     }
    00778 }
    00779 //------------------------------------------------------------------------------
    00780 // シーンノードリンクの読み込み
    00781 void TextSceneLoader::readSceneNodeLink(const String& name){
    00782     SceneNode* sceneNode;
    00783     if(name.equals("RootNode")){
    00784         sceneNode = rootNode_;
    00785     }else{
    00786         sceneNode = sceneNodeManager_->search(name);
    00787         if(sceneNode == NULL){
    00788             ErrorOut("TextSceneLoader::readSceneNodeLink() "
    00789                 "not found sceneNode %s (line %d)",
    00790                 name.getBytes(), tokenizer_->getLineNumber());
    00791         }
    00792     }
    00793
    00794     openChunk();
    00795     while(true){
    00796         String token = readToken("readSceneNodeLink()");
    00797         if(token == "}"){ break; }
    00798         if(token == "SceneNode"){
    00799             // シーンノードリンク
    00800             openChunk();
    00801             while(true){
    00802                 String subToken = readToken("readSceneNodeLink()");
    00803                 if(subToken == "}"){ break; }
    00804                 SceneNode* childNode = sceneNodeManager_->search(subToken);
    00805                 if(childNode == NULL){
    00806                     ErrorOut("TextSceneLoader::readSceneNodeLink() "
    00807                         "not found sceneNode %s (line %d)",
    00808                         subToken.getBytes(), tokenizer_->getLineNumber());
    00809                 }
    00810                 sceneNode->addSceneNode(childNode);
    00811             }
    00812         }else if(token == "SceneLeaf"){
    00813             // シーンリーフリンク
    00814             openChunk();
    00815             while(true){
    00816                 String subToken = readToken("readSceneNodeLink()");
    00817                 if(subToken == "}"){ break; }
    00818                 SceneLeaf* sceneLeaf = NULL;
    00819                 String sceneLeafName = readToken("readSceneNodeLink()");
    00820                 if(subToken.equals("Model")){
    00821                     sceneLeaf = modelManager_->search(sceneLeafName);
    00822                 }else if(subToken.equals("Light")){
    00823                     sceneLeaf = lightManager_->search(sceneLeafName);
    00824                 }else{
    00825                     ErrorOut("TextSceneLoader::readSceneNodeLink() "
    00826                         "unsupported type %s (line %d)",
    00827                         subToken.getBytes(), tokenizer_->getLineNumber());
    00828                 }
    00829                 if(sceneLeaf == NULL){
    00830                     ErrorOut("TextSceneLoader::readSceneNodeLink() "
    00831                         "not found sceneLeaf %s (line %d)",
    00832                         sceneLeafName.getBytes(), tokenizer_->getLineNumber());
    00833                 }
    00834                 sceneNode->addSceneLeaf(sceneLeaf);
    00835             }
    00836         }else{
    00837             ErrorOut("TextSceneLoader::readSceneNodeLink() "
    00838                 "invalid token %s (line %d)",
    00839                 token.getBytes(), tokenizer_->getLineNumber());
    00840         }
    00841     }
    00842 }
    00843 //------------------------------------------------------------------------------
    00844 // モデルリンク
    00845 //------------------------------------------------------------------------------
    00846 // モデルリンクリストの読み込み
    00847 void TextSceneLoader::readModelLinkList(){
    00848     openChunk();
    00849     while(true){
    00850         String token = readToken("readModelLinkList()");
    00851         if(token == "}"){ break; }
    00852         readModelLink(token);
    00853     }
    00854 }
    00855 //------------------------------------------------------------------------------
    00856 // モデルリンクの読み込み
    00857 void TextSceneLoader::readModelLink(const String& name){
    00858     Model* model = modelManager_->search(name);
    00859     if(model == NULL){
    00860         ErrorOut("TextSceneLoader::readModelLink() "
    00861             "not found model %s (line %d)",
    00862             name.getBytes(), tokenizer_->getLineNumber());
    00863     }
    00864     openChunk();
    00865     while(true){
    00866         String token = readToken("readModelLink()");
    00867         if(token == "}"){ break; }
    00868         // メッシュとのリンク
    00869         Mesh* mesh = meshManager_->search(token);
    00870         if(mesh == NULL){
    00871             ErrorOut("TextSceneLoader::readModelLink() "
    00872                 "not found mesh %s (line %d)",
    00873                 token.getBytes(), tokenizer_->getLineNumber());
    00874         }
    00875         model->addMesh(mesh);
    00876     }
    00877 }
    00878 //------------------------------------------------------------------------------
    00879 // メッシュリンク
    00880 //------------------------------------------------------------------------------
    00881 // メッシュリンクリストの読み込み
    00882 void TextSceneLoader::readMeshLinkList(){
    00883     openChunk();
    00884     while(true){
    00885         String token = readToken("readMeshLinkList()");
    00886         if(token == "}"){ break; }
    00887         readMeshLink(token);
    00888     }
    00889 }
    00890 //------------------------------------------------------------------------------
    00891 // メッシュリンクの読み込み
    00892 void TextSceneLoader::readMeshLink(const String& name){
    00893     Mesh* mesh = meshManager_->search(name);
    00894     if(mesh == NULL){
    00895         ErrorOut("TextSceneLoader::readMeshLink() "
    00896             "not found mesh %s (line %d)",
    00897             name.getBytes(), tokenizer_->getLineNumber());
    00898     }
    00899     openChunk();
    00900     while(true){
    00901         String token = readToken("readMeshLink()");
    00902         if(token == "}"){ break; }
    00903         if(token == "MeshData"){
    00904             // メッシュデータとのリンク
    00905             String subToken = readToken("readMeshLink()");
    00906             MeshData* meshData = meshDataManager_->search(subToken);
    00907             if(meshData == NULL){
    00908                 ErrorOut("TextSceneLoader::readMeshLink() "
    00909                     "not found meshData %s (line %d)",
    00910                     subToken.getBytes(), tokenizer_->getLineNumber());
    00911             }
    00912             mesh->setMeshData(meshData);
    00913         }else if(token == "Material"){
    00914             // マテリアルとのリンク
    00915             String subToken = readToken("readMeshLink()");
    00916             Material* material = materialManager_->search(subToken);
    00917             if(material == NULL){
    00918                 ErrorOut("TextSceneLoader::readMeshLink() "
    00919                     "not found material %s (line %d)",
    00920                     subToken.getBytes(), tokenizer_->getLineNumber());
    00921             }
    00922             mesh->setMaterial(material);
    00923         }else{
    00924             ErrorOut("TextSceneLoader::readMeshLink() "
    00925                 "invalid token %s (line %d)",
    00926                 token.getBytes(), tokenizer_->getLineNumber());
    00927         }
    00928     }
    00929 }
    00930 //------------------------------------------------------------------------------
    00931 // マテリアルリンク
    00932 //------------------------------------------------------------------------------
    00933 // マテリアルリンクリストの読み込み
    00934 void TextSceneLoader::readMaterialLinkList(){
    00935     openChunk();
    00936     while(true){
    00937         String token = readToken("readMaterialLinkList()");
    00938         if(token == "}"){ break; }
    00939         openChunk();
    00940         skipWord("type");
    00941         String type = readToken("readMaterialLinkList()");
    00942         if(type == "Basic"){
    00943             readBasicMaterialLink(token);
    00944         }else{
    00945             ErrorOut("TextSceneLoader::readMaterialLinkList() "
    00946                 "invalid type %s (line %d)",
    00947                 type.getBytes(), tokenizer_->getLineNumber());
    00948         }
    00949     }
    00950 }
    00951 //------------------------------------------------------------------------------
    00952 // マテリアルリンクの読み込み
    00953 void TextSceneLoader::readBasicMaterialLink(const String& name){
    00954     BasicMaterial* material =
    00955         materialManager_->search(name)->castBasicMaterial();
    00956     if(material == NULL){
    00957         ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    00958             "not found material %s (line %d)",
    00959             name.getBytes(), tokenizer_->getLineNumber());
    00960     }
    00961     while(true){
    00962         String token = readToken("readMaterialLink()");
    00963         if(token == "}"){ break; }
    00964         if(token == "baseTexture"){
    00965             // ベーステクスチャとのリンク
    00966             String textureName = readToken("readBasicMaterialLink()");
    00967             Texture* texture = textureManager_->search(textureName);
    00968             if(texture == NULL){
    00969                 ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    00970                     "not found baseTexture %s (line %d)",
    00971                     textureName.getBytes(), tokenizer_->getLineNumber());
    00972             }
    00973             material->setBaseTexture(texture);
    00974         }else if(token == "glossTexture"){
    00975             // 光沢テクスチャとのリンク
    00976             String textureName = readToken("readBasicMaterialLink()");
    00977             Texture* texture = textureManager_->search(textureName);
    00978             if(texture == NULL){
    00979                 ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    00980                     "not found glossTexture %s (line %d)",
    00981                     textureName.getBytes(), tokenizer_->getLineNumber());
    00982             }
    00983             material->setGlossTexture(texture);
    00984         }else if(token == "lightTexture"){
    00985             // ライトテクスチャとのリンク
    00986             String textureName = readToken("readBasicMaterialLink()");
    00987             Texture* texture = textureManager_->search(textureName);
    00988             if(texture == NULL){
    00989                 ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    00990                     "not found lightTexture %s (line %d)",
    00991                     textureName.getBytes(), tokenizer_->getLineNumber());
    00992             }
    00993             material->setLightTexture(texture);
    00994         }else if(token == "stainTexture"){
    00995             // 汚れテクスチャとのリンク
    00996             String textureName = readToken("readBasicMaterialLink()");
    00997             Texture* texture = textureManager_->search(textureName);
    00998             if(texture == NULL){
    00999                 ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    01000                     "not found stainTexture %s (line %d)",
    01001                     textureName.getBytes(), tokenizer_->getLineNumber());
    01002             }
    01003             material->setStainTexture(texture);
    01004         }else{
    01005             ErrorOut("TextSceneLoader::readBasicMaterialLink() "
    01006                 "invalid token %s (line %d)",
    01007                 token.getBytes(), tokenizer_->getLineNumber());
    01008         }
    01009     }
    01010 }
    01011 //------------------------------------------------------------------------------
    01012 // テクスチャリンク
    01013 //------------------------------------------------------------------------------
    01014 // テクスチャリンクリストの読み込み
    01015 void TextSceneLoader::readTextureLinkList(){
    01016     openChunk();
    01017     while(true){
    01018         String token = readToken("readTextureLinkList()");
    01019         if(token == "}"){ break; }
    01020         readTextureLink(token);
    01021     }
    01022 }
    01023 //------------------------------------------------------------------------------
    01024 // テクスチャリンクの読み込み
    01025 void TextSceneLoader::readTextureLink(const String& name){
    01026     Texture* texture = textureManager_->search(name);
    01027     if(texture == NULL){
    01028         ErrorOut("TextSceneLoader::readTextureLink() "
    01029             "not found texture %s (line %d)",
    01030             name.getBytes(), tokenizer_->getLineNumber());
    01031     }
    01032     openChunk();
    01033     while(true){
    01034         String token = readToken("readTextureLink()");
    01035         if(token == "}"){ break; }
    01036         // ピクチャとのリンク
    01037         Picture* picture = pictureManager_->search(token);
    01038         if(picture == NULL){
    01039             ErrorOut("TextSceneLoader::readTextureLink() "
    01040                 "not found picture %s (line %d)",
    01041                 token.getBytes(), tokenizer_->getLineNumber());
    01042         }
    01043         texture->addPicture(picture);
    01044     }
    01045 }
    01046 //------------------------------------------------------------------------------
    01047 // 値の読み込み
    01048 //------------------------------------------------------------------------------
    01049 // bool値の読み込み
    01050 bool TextSceneLoader::readBool(){
    01051     String token = readToken("readBool()");
    01052     if(token == "true"){ return true; }
    01053     else if(token == "false"){ return false; }
    01054     ErrorOut("TextSceneLoader::readBool() invalid token %s (line %d)",
    01055         token.getBytes(), tokenizer_->getLineNumber());
    01056     return false;
    01057 }
    01058 //------------------------------------------------------------------------------
    01059 // u_char値の読み込み
    01060 u_char TextSceneLoader::readUChar(){
    01061     String token = readToken("readUChar()");
    01062     u_char value = 0;
    01063     bool result = token.parseUChar(&value);
    01064     if(!result){
    01065         ErrorOut("TextSceneLoader::readUChar() invalid token %s (line %d)",
    01066             token.getBytes(), tokenizer_->getLineNumber());
    01067     }
    01068     return value;
    01069 }
    01070 //------------------------------------------------------------------------------
    01071 // u_short値の読み込み
    01072 u_short TextSceneLoader::readUShort(){
    01073     String token = readToken("readUShort()");
    01074     u_short value = 0;
    01075     bool result = token.parseUShort(&value);
    01076     if(!result){
    01077         ErrorOut("TextSceneLoader::readUShort() invalid token %s (line %d)",
    01078             token.getBytes(), tokenizer_->getLineNumber());
    01079     }
    01080     return value;
    01081 }
    01082 //------------------------------------------------------------------------------
    01083 // int値の読み込み
    01084 int TextSceneLoader::readInt(){
    01085     String token = readToken("readInt()");
    01086     int value = 0;
    01087     bool result = token.parseInt(&value);
    01088     if(!result){
    01089         ErrorOut("TextSceneLoader::readInt() invalid token %s (line %d)",
    01090             token.getBytes(), tokenizer_->getLineNumber());
    01091     }
    01092     return value;
    01093 }
    01094 //------------------------------------------------------------------------------
    01095 // u_int値の読み込み
    01096 u_int TextSceneLoader::readUInt(){
    01097     String token = readToken("readInt()");
    01098     u_int value = 0;
    01099     bool result = token.parseUInt(&value);
    01100     if(!result){
    01101         ErrorOut("TextSceneLoader::readUInt() invalid token %s (line %d)",
    01102             token.getBytes(), tokenizer_->getLineNumber());
    01103     }
    01104     return value;
    01105 }
    01106 //------------------------------------------------------------------------------
    01107 // float値の読み込み
    01108 float TextSceneLoader::readFloat(){
    01109     String token = readToken("readFloat()");
    01110     float value = 0.f;
    01111     bool result = token.parseFloat(&value);
    01112     if(!result){
    01113         ErrorOut("TextSceneLoader::readFloat() invalid token %s (line %d)",
    01114             token.getBytes(), tokenizer_->getLineNumber());
    01115     }
    01116     return value;
    01117 }
    01118 //------------------------------------------------------------------------------
    01119 // Vector3値の読み込み
    01120 Vector3 TextSceneLoader::readVector3(){
    01121     Vector3 result;
    01122     openChunk();
    01123     result.x = readFloat();
    01124     result.y = readFloat();
    01125     result.z = readFloat();
    01126     closeChunk();
    01127     return result;
    01128 }
    01129 //------------------------------------------------------------------------------
    01130 // Matrix34値の読み込み
    01131 Matrix34 TextSceneLoader::readMatrix34(){
    01132     Matrix34 result;
    01133     openChunk();
    01134     for(int i = 0; i < 12; i++){
    01135         result.array[i] = readFloat();
    01136     }
    01137     closeChunk();
    01138     return result;
    01139 }
    01140 //------------------------------------------------------------------------------
    01141 // 三要素整数カラー値の読み込み
    01142 Color3c TextSceneLoader::readColor3c(){
    01143     Color3c result;
    01144     openChunk();
    01145     result.r = readUChar();
    01146     result.g = readUChar();
    01147     result.b = readUChar();
    01148     closeChunk();
    01149     return result;
    01150 }
    01151 //------------------------------------------------------------------------------
    01152 // 四要素整数カラー値の読み込み
    01153 Color4c TextSceneLoader::readColor4c(){
    01154     Color4c result;
    01155     openChunk();
    01156     result.r = readUChar();
    01157     result.g = readUChar();
    01158     result.b = readUChar();
    01159     result.a = readUChar();
    01160     closeChunk();
    01161     return result;
    01162 }
    01163 //------------------------------------------------------------------------------
    01164 // 三要素実数カラー値の読み込み
    01165 Color3f TextSceneLoader::readColor3f(){
    01166     Color3f result;
    01167     openChunk();
    01168     result.r = readFloat();
    01169     result.g = readFloat();
    01170     result.b = readFloat();
    01171     closeChunk();
    01172     return result;
    01173 }
    01174 //------------------------------------------------------------------------------
    01175 // 四要素実数カラー値の読み込み
    01176 Color4f TextSceneLoader::readColor4f(){
    01177     Color4f result;
    01178     openChunk();
    01179     result.r = readFloat();
    01180     result.g = readFloat();
    01181     result.b = readFloat();
    01182     result.a = readFloat();
    01183     closeChunk();
    01184     return result;
    01185 }
    01186 //------------------------------------------------------------------------------
    01187 // 二次元テクスチャ座標値の読み込み
    01188 TexCoord2 TextSceneLoader::readTexCoord2(){
    01189     TexCoord2 result;
    01190     openChunk();
    01191     result.u = readFloat();
    01192     result.v = readFloat();
    01193     closeChunk();
    01194     return result;
    01195 }
    01196 //------------------------------------------------------------------------------
    01197 // 軸沿いボックスの読み込み
    01198 AxisAlignedBox TextSceneLoader::readAxisAlignedBox(){
    01199     AxisAlignedBox result;
    01200     Vector3 minimum, maximum;
    01201     openChunk();
    01202     minimum.x = readFloat();
    01203     minimum.y = readFloat();
    01204     minimum.z = readFloat();
    01205     closeChunk();
    01206     openChunk();
    01207     maximum.x = readFloat();
    01208     maximum.y = readFloat();
    01209     maximum.z = readFloat();
    01210     closeChunk();
    01211     result.set(minimum, maximum);
    01212     return result;
    01213 }
    01214 //------------------------------------------------------------------------------
    01215 // 球の読み込み
    01216 Sphere TextSceneLoader::readSphere(){
    01217     Sphere result;
    01218     Vector3 vector;
    01219     openChunk();
    01220     vector.x = readFloat();
    01221     vector.y = readFloat();
    01222     vector.z = readFloat();
    01223     result.setCenter(vector);
    01224     result.setRadius(readFloat());
    01225     closeChunk();
    01226     return result;
    01227 }
    01228 //------------------------------------------------------------------------------
    01229 // ユーティリティ
    01230 //------------------------------------------------------------------------------
    01231 // トークンの読み込み
    01232 String TextSceneLoader::readToken(const String& caller){
    01233     bool hasNext = tokenizer_->nextToken();
    01234     if(!hasNext){
    01235         ErrorOut("TextSceneLoader::%s nothing token (line %d)",
    01236             caller.getBytes(), tokenizer_->getLineNumber());
    01237     }
    01238     return tokenizer_->getToken();
    01239 }
    01240 //------------------------------------------------------------------------------
    01241 // 指定ワードの読み飛ばし
    01242 void TextSceneLoader::skipWord(const String& word){
    01243     String token = readToken("skipWord()");
    01244     if(token != word){
    01245         ErrorOut("TextSceneLoader::skipWord(%s) invalid token %s (line %d)",
    01246             word.getBytes(), token.getBytes(), tokenizer_->getLineNumber());
    01247     }
    01248 }
    01249 //------------------------------------------------------------------------------
    01250 // チャンクの読み飛ばし
    01251 void TextSceneLoader::skipChunk(){
    01252     int chunkLine = tokenizer_->getLineNumber();
    01253     int chunkCounter = 0;
    01254     while(true){
    01255         bool hasNext = tokenizer_->nextToken();
    01256         if(!hasNext){
    01257             ErrorOut("TextSceneLoader::skipChunk(%d) nothing token (line %d)",
    01258                 chunkLine, tokenizer_->getLineNumber());
    01259         }
    01260         String token = tokenizer_->getToken();
    01261         if(token == "{"){
    01262             chunkCounter++;
    01263         }else if(token == "}"){
    01264             chunkCounter--;
    01265             // デクリメント時にループを抜けるチェックを行う
    01266             if(chunkCounter == 0){ break; }
    01267             if(chunkCounter < 0){
    01268                 ErrorOut("TextSceneLoader::skipChunk(%d) "
    01269                     "invalid chunk (line %d)",
    01270                     chunkLine, tokenizer_->getLineNumber());
    01271             }
    01272         }
    01273     }
    01274 }
    01275 //------------------------------------------------------------------------------
    01276 } // End of namespace Lamp
    01277 //------------------------------------------------------------------------------