 |
TAPs 0.7.7.3
|
|
TAPs 0.7.7.3
|
00001 /****************************************************************************** 00002 TAPsRead3dsMaxASE.cpp 00003 00004 Create an OpenGL Polygonal Model Object from a 3ds Max .ASE file 00005 00006 SUKITTI PUNAK (04/28/2005) 00007 ******************************************************************************/ 00008 #include "TAPsRead3dsMaxASE.hpp" 00009 // Using Inclusion Model (i.e. definitions are included in declarations) 00010 // (this name.cpp is included in name.hpp) 00011 // Each friend is defined directly inside its declaration. 00012 00013 BEGIN_NAMESPACE_TAPs 00014 //============================================================================= 00015 template <typename T> FILE * Read3dsMaxASE<T>::fileIn = NULL; 00016 template <typename T> int Read3dsMaxASE<T>::halfEdgeCounter = 0; 00017 template <typename T> int Read3dsMaxASE<T>::vertexNo = 0; 00018 template <typename T> int Read3dsMaxASE<T>::faceNo = 0; 00019 00020 // main mat // sub mat 00021 template <typename T> std::vector< std::vector< OpenGL::Material * > > Read3dsMaxASE<T>::materialList; 00022 template <typename T> std::vector< OpenGL::Material * > Read3dsMaxASE<T>::materials; 00023 00024 #ifdef TAPs_SUPPORT_ASE_FORMAT 00025 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 00026 template <typename T> int Read3dsMaxASE<T>::m_iNumVertexColors = 0; 00027 template <typename T> int Read3dsMaxASE<T>::m_iNumFaceVertexColors = 0; 00028 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 00029 00030 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00031 template <typename T> int Read3dsMaxASE<T>::m_iNumVertexTextures = 0; 00032 template <typename T> int Read3dsMaxASE<T>::m_iNumFaceVertexTextures = 0; 00033 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00034 #endif//TAPs_SUPPORT_ASE_FORMAT 00035 00036 //============================================================================= 00037 //----------------------------------------------------------------------------- 00038 // Read an input file 00039 template <typename T> 00040 bool Read3dsMaxASE<T>::readFile ( 00041 const char *fileName, OpenGL::PolygonalModel<T> * const prModel ) 00042 { 00043 #ifdef TAPs_SUPPORT_ASE_FORMAT 00044 ClearMaterialList(); 00045 ClearMaterials(); 00046 #endif//TAPs_SUPPORT_ASE_FORMAT 00047 00048 //---------------------------------------------------------------- 00049 // Open the input file 00050 fileIn = fopen( fileName, "r" ); 00051 if ( !fileIn ) { 00052 std::perror( fileName ); 00053 return false; 00054 } 00055 //---------------------------------------------------------------- 00056 #ifdef TAPs_DEBUG_MODE 00057 std::cout << "START READING " << fileName << "\n"; 00058 #endif//TAPs_DEBUG_MODE 00059 00060 const int SIZE = 256; 00061 char line[SIZE]; 00062 char node[128]; 00063 // This will read only the first GEOMOBJECT in the .ASE file 00064 bool bAlreadyReadGEOMOBJECT = false; 00065 while ( !feof(fileIn) ) { 00066 fgets( line, SIZE, fileIn ); // read a line 00067 sscanf( line, "%s", node ); 00068 if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) && ( strlen(node) == strlen("*MATERIAL_LIST") ) ) { 00069 ProcessNodeMATERIAL_LIST( line ); 00070 } 00071 else if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00072 if ( bAlreadyReadGEOMOBJECT ) break; 00073 bAlreadyReadGEOMOBJECT = true; 00074 ProcessNodeGEOMOBJECT( line, prModel ); 00075 } 00076 } 00077 //---------------------------------------------------------------- 00078 fclose(fileIn); 00079 00080 #ifdef TAPs_DEBUG_MODE 00081 std::cout << "END READING " << fileName << "\n"; 00082 #endif//TAPs_DEBUG_MODE 00083 00084 prModel->GetMaterial()->ApplyMaterial(); 00085 00086 return true; 00087 } 00088 //----------------------------------------------------------------------------- 00089 // Read an input file 00090 template <typename T> 00091 bool Read3dsMaxASE<T>::readFile ( 00092 const char *fileName, OpenGL::XPolygonalModel<T> * const prModel ) 00093 { 00094 #ifdef TAPs_SUPPORT_ASE_FORMAT 00095 ClearMaterialList(); 00096 ClearMaterials(); 00097 #endif//TAPs_SUPPORT_ASE_FORMAT 00098 00099 //---------------------------------------------------------------- 00100 // Open the input file 00101 fileIn = fopen( fileName, "r" ); 00102 if ( !fileIn ) { 00103 std::perror( fileName ); 00104 return false; 00105 } 00106 //---------------------------------------------------------------- 00107 #ifdef TAPs_DEBUG_MODE 00108 std::cout << "START READING " << fileName << "\n"; 00109 #endif//TAPs_DEBUG_MODE 00110 00111 const int SIZE = 256; 00112 char line[SIZE]; 00113 char node[128]; 00114 // This will read only the first GEOMOBJECT in the .ASE file 00115 bool bAlreadyReadGEOMOBJECT = false; 00116 while ( !feof(fileIn) ) { 00117 fgets( line, SIZE, fileIn ); // read a line 00118 sscanf( line, "%s", node ); 00119 if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) && ( strlen(node) == strlen("*MATERIAL_LIST") ) ) { 00120 ProcessNodeMATERIAL_LIST( line ); 00121 } 00122 else if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00123 if ( bAlreadyReadGEOMOBJECT ) break; 00124 bAlreadyReadGEOMOBJECT = true; 00125 ProcessNodeGEOMOBJECT( line, prModel ); 00126 } 00127 } 00128 //---------------------------------------------------------------- 00129 fclose(fileIn); 00130 00131 #ifdef TAPs_DEBUG_MODE 00132 std::cout << "END READING " << fileName << "\n"; 00133 #endif//TAPs_DEBUG_MODE 00134 00135 prModel->GetMaterial()->ApplyMaterial(); 00136 00137 return true; 00138 } 00139 //----------------------------------------------------------------------------- 00140 // Read an input file 00141 template <typename T> 00142 bool Read3dsMaxASE<T>::readFile ( 00143 const char *fileName, OpenGL::HalfEdgeModel<T> * const prModel ) 00144 { 00145 #ifdef TAPs_SUPPORT_ASE_FORMAT 00146 ClearMaterialList(); 00147 ClearMaterials(); 00148 #endif//TAPs_SUPPORT_ASE_FORMAT 00149 00150 //---------------------------------------------------------------- 00151 // Initialization 00152 halfEdgeCounter = 0; 00153 vertexNo = 0; 00154 faceNo = 0; 00155 //---------------------------------------------------------------- 00156 // Open the input file 00157 fileIn = fopen( fileName, "r" ); 00158 if ( !fileIn ) { 00159 std::perror( fileName ); 00160 return false; 00161 } 00162 //---------------------------------------------------------------- 00163 #ifdef TAPs_DEBUG_MODE 00164 std::cout << "START READING " << fileName << "\n"; 00165 #endif//TAPs_DEBUG_MODE 00166 00167 const int SIZE = 256; 00168 char line[SIZE]; 00169 char node[128]; 00170 // This will read only the first GEOMOBJECT in the .ASE file 00171 bool bAlreadyReadGEOMOBJECT = false; 00172 while ( !feof(fileIn) ) { 00173 fgets( line, SIZE, fileIn ); // read a line 00174 sscanf( line, "%s", node ); 00175 if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) && ( strlen(node) == strlen("*MATERIAL_LIST") ) ) { 00176 ProcessNodeMATERIAL_LIST( line ); 00177 } 00178 else if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00179 if ( bAlreadyReadGEOMOBJECT ) break; 00180 bAlreadyReadGEOMOBJECT = true; 00181 ProcessNodeGEOMOBJECT( line, prModel ); 00182 } 00183 } 00184 //---------------------------------------------------------------- 00185 fclose(fileIn); 00186 //---------------------------------------------------------------- 00187 HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel ); 00188 //---------------------------------------------------------------- 00189 00190 #ifdef TAPs_DEBUG_MODE 00191 std::cout << "END READING " << fileName << "\n"; 00192 std::cout << "Number of Half-Edges: " << halfEdgeCounter << "\n"; 00193 #endif//TAPs_DEBUG_MODE 00194 00195 prModel->GetMaterial()->ApplyMaterial(); 00196 00197 return true; 00198 } 00199 //----------------------------------------------------------------------------- 00200 // Read an input file for MultiMeshModel 00201 template <typename T> 00202 bool Read3dsMaxASE<T>::readFile ( 00203 const char *fileName, OpenGL::MultiMeshModel<T> * const prModel, 00204 TAPs::Enum::ModelType eModelType ) 00205 { 00206 #ifdef TAPs_SUPPORT_ASE_FORMAT 00207 ClearMaterialList(); 00208 ClearMaterials(); 00209 #endif//TAPs_SUPPORT_ASE_FORMAT 00210 00211 //---------------------------------------------------------------- 00212 // Open the input file 00213 fileIn = fopen( fileName, "r" ); 00214 if ( !fileIn ) { 00215 std::perror( fileName ); 00216 return false; 00217 } 00218 //---------------------------------------------------------------- 00219 #ifdef TAPs_DEBUG_MODE 00220 std::cout << "START READING (for MultiMeshModel) " << fileName << "\n"; 00221 #endif//TAPs_DEBUG_MODE 00222 00223 int numberOfObject = 0; 00224 const int SIZE = 256; 00225 char line[SIZE]; 00226 char node[128]; 00227 while ( !feof(fileIn) ) { 00228 fgets( line, SIZE, fileIn ); // read a line 00229 sscanf( line, "%s", node ); 00230 if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) && ( strlen(node) == strlen("*MATERIAL_LIST") ) ) { 00231 ProcessNodeMATERIAL_LIST( line ); 00232 } 00233 00234 switch ( eModelType ) { 00235 case TAPs::Enum::MODEL_TYPE_POLYGONAL: 00236 //if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) ) { 00237 // ProcessNodeMATERIAL_LIST( line, prPolygonalModel ); 00238 //} 00239 if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00240 ++numberOfObject; 00241 OpenGL::OpenGLPolygonalModel<T> * prPolygonalModel = new OpenGL::OpenGLPolygonalModel<T>(); 00242 ProcessNodeGEOMOBJECT( line, prPolygonalModel ); 00243 prModel->GetModelList().push_back( prPolygonalModel ); 00244 } 00245 break; 00246 case TAPs::Enum::MODEL_TYPE_XPOLYGONAL: 00247 //if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) ) { 00248 // ProcessNodeMATERIAL_LIST( line, prXPolygonalModel ); 00249 //} 00250 if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00251 ++numberOfObject; 00252 OpenGL::OpenGLXPolygonalModel<T> * prXPolygonalModel = new OpenGL::OpenGLXPolygonalModel<T>(); 00253 ProcessNodeGEOMOBJECT( line, prXPolygonalModel ); 00254 prModel->GetModelList().push_back( prXPolygonalModel ); 00255 00256 std::cout << prXPolygonalModel->material << "\n"; 00257 00258 //std::cout << "\tObj#: " << numberOfObject << "\n"; 00259 } 00260 break; 00261 case TAPs::Enum::MODEL_TYPE_HALFEDGE: 00262 //if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) ) { 00263 // ProcessNodeMATERIAL_LIST( line, prHalfEdgeModel ); 00264 //} 00265 if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00266 //--------------------------------------------------------- 00267 // Initialization 00268 halfEdgeCounter = 0; 00269 vertexNo = 0; 00270 faceNo = 0; 00271 //--------------------------------------------------------- 00272 ++numberOfObject; 00273 OpenGL::OpenGLHalfEdgeModel<T> * prHalfEdgeModel = new OpenGL::OpenGLHalfEdgeModel<T>(); 00274 ProcessNodeGEOMOBJECT( line, prHalfEdgeModel ); 00275 HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prHalfEdgeModel ); 00276 prModel->GetModelList().push_back( prHalfEdgeModel ); 00277 00278 //std::cout << "\tObj#: " << numberOfObject << "\n"; 00279 } 00280 break; 00281 } 00282 } 00283 //---------------------------------------------------------------- 00284 fclose(fileIn); 00285 00286 #ifdef TAPs_DEBUG_MODE 00287 std::cout << "END READING " << fileName << "\n"; 00288 #endif//TAPs_DEBUG_MODE 00289 00290 return true; 00291 } 00292 //----------------------------------------------------------------------------- 00293 #if defined(__gl_h_) || defined(__GL_H__) 00294 // Read an input file for std::vector< OpenGL::HETriMeshOneModelMultiParts<T> * > 00295 template <typename T> 00296 bool Read3dsMaxASE<T>::readFile ( 00297 const char *fileName, 00298 std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * > & modelList 00299 ) 00300 { 00301 #ifdef TAPs_SUPPORT_ASE_FORMAT 00302 ClearMaterialList(); 00303 ClearMaterials(); 00304 #endif//TAPs_SUPPORT_ASE_FORMAT 00305 00306 //---------------------------------------------------------------- 00307 // Open the input file 00308 fileIn = fopen( fileName, "r" ); 00309 if ( !fileIn ) { 00310 std::perror( fileName ); 00311 return false; 00312 } 00313 //---------------------------------------------------------------- 00314 #ifdef TAPs_DEBUG_MODE 00315 std::cout << "START READING (for std::vector< OpenGL::HETriMeshOneModelMultiParts<T> * >) " << fileName << "\n"; 00316 #endif//TAPs_DEBUG_MODE 00317 00318 int numberOfObject = 0; 00319 const int SIZE = 256; 00320 char line[SIZE]; 00321 char node[128]; 00322 while ( !feof(fileIn) ) { 00323 fgets( line, SIZE, fileIn ); // read a line 00324 00325 //std::cout << line; 00326 00327 sscanf( line, "%s", node ); 00328 if ( !strncmp( node, "*MATERIAL_LIST", strlen("*MATERIAL_LIST") ) && ( strlen(node) == strlen("*MATERIAL_LIST") ) ) { 00329 ProcessNodeMATERIAL_LIST( line ); 00330 } 00331 else if ( !strncmp( node, "*GEOMOBJECT", strlen("*GEOMOBJECT") ) && ( strlen(node) == strlen("*GEOMOBJECT") ) ) { 00332 //--------------------------------------------------------- 00333 // Initialization 00334 halfEdgeCounter = 0; 00335 vertexNo = 0; 00336 faceNo = 0; 00337 //--------------------------------------------------------- 00338 ++numberOfObject; 00339 OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * prModel = new OpenGL::OpenGLHETriMeshOneModelMultiParts<T>(); 00340 ProcessNodeGEOMOBJECT( line, prModel ); 00341 HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel ); 00342 modelList.push_back( prModel ); 00343 00344 //std::cout << "\tT101 Obj#: " << numberOfObject << "\n"; 00345 } 00346 } 00347 //---------------------------------------------------------------- 00348 fclose(fileIn); 00349 00350 #ifdef TAPs_DEBUG_MODE 00351 std::cout << "END READING " << fileName << "\n"; 00352 #endif//TAPs_DEBUG_MODE 00353 00354 return true; 00355 } 00356 #endif // #if defined(__gl_h_) || defined(__GL_H__) 00357 //----------------------------------------------------------------------------- 00358 //============================================================================= 00359 //----------------------------------------------------------------------------- 00360 // Process MATERIAL_LIST 00361 template <typename T> 00362 void Read3dsMaxASE<T>::ProcessNodeMATERIAL_LIST ( char *line ) 00363 { 00364 #ifdef TAPs_DEBUG_MODE 00365 std::cout << "Start Processing Node MATERIAL_LIST\n"; 00366 #endif//TAPs_DEBUG_MODE 00367 00368 //------------------------------------------------------------------- 00369 // Example: 00370 // *MATERIAL_LIST { 00371 // *MATERIAL_COUNT 2 00372 // *MATERIAL 0 { 00373 // ... 00374 // } 00375 // *MATERIAL 1 { 00376 // ... 00377 // } 00378 // } 00379 char node[128]; 00380 const int SIZE = 256; 00381 do { 00382 fgets( line, SIZE, fileIn ); 00383 sscanf( line, "%s", node ); 00384 00385 #ifdef TAPs_DEBUG_MODE 00386 std::cout << node << "\n"; 00387 #endif//TAPs_DEBUG_MODE 00388 00389 if ( !strncmp( node, "*MATERIAL", strlen("*MATERIAL") ) && ( strlen(node) == strlen("*MATERIAL") ) ) { 00390 ProcessNodeMATERIAL( line ); 00391 } 00392 else if ( !strncmp( node, "*MATERIAL_COUNT", strlen("*MATERIAL_COUNT") ) && ( strlen(node) == strlen("*MATERIAL_COUNT") ) ) { 00393 #ifdef TAPs_DEBUG_MODE 00394 std::cout << "skip node: MATERIAL_COUNT\n"; 00395 #endif//TAPs_DEBUG_MODE 00396 } 00397 } while ( node[0] != '}' ); 00398 00399 #ifdef TAPs_DEBUG_MODE 00400 std::cout << "End Processing Node MATERIAL_LIST\n"; 00401 #endif//TAPs_DEBUG_MODE 00402 } 00403 //----------------------------------------------------------------------------- 00404 // Process MATERIAL 00405 template <typename T> 00406 void Read3dsMaxASE<T>::ProcessNodeMATERIAL ( char *line, bool isSubmaterialNode ) 00407 { 00408 int iNumOfSubImagesToBeProcessed = 0; 00409 00410 #ifdef TAPs_DEBUG_MODE 00411 std::cout << "Start Processing Node MATERIAL\n"; 00412 #endif//TAPs_DEBUG_MODE 00413 00414 //------------------------------------------------------------------- 00415 // Example: 00416 // *MATERIAL 1 { 00417 // *MATERIAL_NAME "Material #79" 00418 // *MATERIAL_CLASS "Multi/Sub-Object" 00419 // *MATERIAL_AMBIENT 0.5882 0.5882 0.8118 00420 // *MATERIAL_DIFFUSE 0.5882 0.5882 0.8118 00421 // *MATERIAL_SPECULAR 0.9000 0.9000 0.9000 00422 // *MATERIAL_SHINE 0.1000 <-- (Range [0.00,1.00]) adjusted by Glossiness of "Specular Highlights" in 3ds max's material can be set from [0,100] 00423 // *MATERIAL_SHINESTRENGTH 0.0000 <-- (Range [0.00,9.99]) adjusted by Specular Level of "Specular Highlights" in 3ds max's material can be set from [0,999] 00424 // *MATERIAL_TRANSPARENCY 0.0000 00425 // *MATERIAL_WIRESIZE 1.0000 00426 // *NUMSUBMTLS 2 00427 // *SUBMATERIAL 0 { 00428 // ... 00429 // } 00430 // *SUBMATERIAL 1 { 00431 // ... 00432 // } 00433 // } 00434 00435 // *MATERIAL_SHINE from [0.00,1.00] has to be conversed to GL_SHININESS from [0,128] 00436 00437 // For OpenGL Material 00438 GLfloat mat_ambient[4]; // range [0.0-1.0] 00439 GLfloat mat_diffuse[4]; // range [0.0-1.0] 00440 GLfloat mat_specular[4]; // range [0.0-1.0] 00441 GLfloat mat_shininess = 64; // range [0.0-128.0] 00442 GLfloat mat_emission[4] = { 0,0,0,0 }; // range [0.0-1.0] 00443 //GLfloat color_RGBA[4]; // range [0.0-1.0] 00444 00445 char node[128]; 00446 const int SIZE = 256; 00447 do { 00448 fgets( line, SIZE, fileIn ); 00449 sscanf( line, "%s", node ); 00450 00451 #ifdef TAPs_DEBUG_MODE 00452 std::cout << node << "\n"; 00453 #endif//TAPs_DEBUG_MODE 00454 00455 if ( !strncmp( node, "*MATERIAL_NAME", strlen("*MATERIAL_NAME") ) && ( strlen(node) == strlen("*MATERIAL_NAME") ) ) { 00456 #ifdef TAPs_DEBUG_MODE 00457 std::cout << "skip node: MATERIAL_NAME\n"; 00458 #endif//TAPs_DEBUG_MODE 00459 } 00460 else if ( !strncmp( node, "*MATERIAL_CLASS", strlen("*MATERIAL_CLASS") ) && ( strlen(node) == strlen("*MATERIAL_CLASS") ) ) { 00461 #ifdef TAPs_DEBUG_MODE 00462 std::cout << "skip node: MATERIAL_CLASS\n"; 00463 #endif//TAPs_DEBUG_MODE 00464 } 00465 else if ( !strncmp( node, "*MATERIAL_AMBIENT", strlen("*MATERIAL_AMBIENT") ) && ( strlen(node) == strlen("*MATERIAL_AMBIENT") ) ) { 00466 sscanf( line, "%s %g %g %g", node, &mat_ambient[0], &mat_ambient[1], &mat_ambient[2] ); 00467 } 00468 else if ( !strncmp( node, "*MATERIAL_DIFFUSE", strlen("*MATERIAL_DIFFUSE") ) && ( strlen(node) == strlen("*MATERIAL_DIFFUSE") ) ) { 00469 sscanf( line, "%s %g %g %g", node, &mat_diffuse[0], &mat_diffuse[1], &mat_diffuse[2] ); 00470 } 00471 else if ( !strncmp( node, "*MATERIAL_SPECULAR", strlen("*MATERIAL_SPECULAR") ) && ( strlen(node) == strlen("*MATERIAL_SPECULAR") ) ) { 00472 sscanf( line, "%s %g %g %g", node, &mat_specular[0], &mat_specular[1], &mat_specular[2] ); 00473 } 00474 else if ( !strncmp( node, "*MATERIAL_SHINE", strlen("*MATERIAL_SHINE") ) && ( strlen(node) == strlen("*MATERIAL_SHINE") ) ) { 00475 sscanf( line, "%s %g", node, &mat_shininess ); 00476 mat_shininess *= 128; // converse from [0.00,1.00] to GL_SHININESS from [0,128] 00477 } 00478 else if ( !strncmp( node, "*MATERIAL_SHINESTRENGTH", strlen("*MATERIAL_SHINESTRENGTH") ) && ( strlen(node) == strlen("*MATERIAL_SHINESTRENGTH") ) ) { 00479 #ifdef TAPs_DEBUG_MODE 00480 std::cout << "skip node: MATERIAL_SHINESTRENGTH\n"; 00481 #endif//TAPs_DEBUG_MODE 00482 } 00483 else if ( !strncmp( node, "*MATERIAL_TRANSPARENCY", strlen("*MATERIAL_TRANSPARENCY") ) && ( strlen(node) == strlen("*MATERIAL_TRANSPARENCY") ) ) { 00484 GLfloat opacity; 00485 sscanf( line, "%s %g", node, &opacity ); 00486 opacity = 1.0 - opacity; 00487 mat_ambient[3] = mat_diffuse[3] = mat_specular[3] = opacity; 00488 } 00489 else if ( !strncmp( node, "*MATERIAL_WIRESIZE", strlen("*MATERIAL_WIRESIZE") ) && ( strlen(node) == strlen("*MATERIAL_WIRESIZE") ) ) { 00490 #ifdef TAPs_DEBUG_MODE 00491 std::cout << "skip node: MATERIAL_WIRESIZE\n"; 00492 #endif//TAPs_DEBUG_MODE 00493 } 00494 else if ( !strncmp( node, "*MATERIAL_SHADING", strlen("*MATERIAL_SHADING") ) && ( strlen(node) == strlen("*MATERIAL_SHADING") ) ) { 00495 #ifdef TAPs_DEBUG_MODE 00496 std::cout << "skip node: MATERIAL_SHADING\n"; 00497 #endif//TAPs_DEBUG_MODE 00498 } 00499 else if ( !strncmp( node, "*MATERIAL_WIRESIZE", strlen("*MATERIAL_WIRESIZE") ) && ( strlen(node) == strlen("*MATERIAL_WIRESIZE") ) ) { 00500 #ifdef TAPs_DEBUG_MODE 00501 std::cout << "skip node: MATERIAL_WIRESIZE\n"; 00502 #endif//TAPs_DEBUG_MODE 00503 } 00504 else if ( !strncmp( node, "*MATERIAL_XP_FALLOFF", strlen("*MATERIAL_XP_FALLOFF") ) && ( strlen(node) == strlen("*MATERIAL_XP_FALLOFF") ) ) { 00505 #ifdef TAPs_DEBUG_MODE 00506 std::cout << "skip node: MATERIAL_XP_FALLOFF\n"; 00507 #endif//TAPs_DEBUG_MODE 00508 } 00509 else if ( !strncmp( node, "*MATERIAL_SELFILLUM", strlen("*MATERIAL_SELFILLUM") ) && ( strlen(node) == strlen("*MATERIAL_SELFILLUM") ) ) { 00510 #ifdef TAPs_DEBUG_MODE 00511 std::cout << "skip node: MATERIAL_SELFILLUM\n"; 00512 #endif//TAPs_DEBUG_MODE 00513 } 00514 else if ( !strncmp( node, "*MATERIAL_FALLOFF", strlen("*MATERIAL_FALLOFF") ) && ( strlen(node) == strlen("*MATERIAL_FALLOFF") ) ) { 00515 #ifdef TAPs_DEBUG_MODE 00516 std::cout << "skip node: MATERIAL_FALLOFF\n"; 00517 #endif//TAPs_DEBUG_MODE 00518 } 00519 else if ( !strncmp( node, "*MATERIAL_XP_TYPE", strlen("*MATERIAL_XP_TYPE") ) && ( strlen(node) == strlen("*MATERIAL_XP_TYPE") ) ) { 00520 #ifdef TAPs_DEBUG_MODE 00521 std::cout << "skip node: MATERIAL_XP_TYPE\n"; 00522 #endif//TAPs_DEBUG_MODE 00523 } 00524 00525 else if ( !strncmp( node, "*MAP_", strlen("*MAP_") ) ) { 00526 ProcessNodeMAP_( line ); 00527 } 00528 00529 00530 /* 00531 else if ( !strncmp( node, "*BITMAP", strlen("*BITMAP") ) && ( strlen(node) == strlen("*BITMAP") ) ) { 00532 char s[128]; 00533 char mapName[128]; 00534 sscanf( line, "%s %s", node, s ); 00535 int i; 00536 for ( i = 0; i < static_cast<int>(strlen(s))-2; ++i ) { 00537 mapName[i] = s[i+1]; 00538 } 00539 mapName[i] = NULL; 00540 00541 #ifdef TAPs_DEBUG_MODE 00542 std::cout << "MAP NAME: " << mapName << "\n"; 00543 #endif//TAPs_DEBUG_MODE 00544 00545 prModel->SetImageFileName( mapName ); 00546 prModel->m_pcImg = new BitmapImage(); 00547 if ( prModel->m_pcImg->LoadBitmapFile( mapName ) ) { 00548 //prModel->EnableTexture(); 00549 } 00550 else { 00551 //prModel->m_pcImg.~BitmapImage(); 00552 00553 #ifdef TAPs_DEBUG_MODE 00554 std::cout << "Read3dsMaxASE: Could not open the file named \"" 00555 << mapName << "\"!" << std::endl; 00556 #endif//TAPs_DEBUG_MODE 00557 } 00558 } 00559 //*/ 00560 00561 // Submaterial 00562 else if ( !strncmp( node, "*SUBMATERIAL", strlen("*SUBMATERIAL") ) && ( strlen(node) == strlen("*SUBMATERIAL") ) ) { 00563 // This makes a recursive call. 00564 // It can be done, since a submaterial node and a (main) material have the same properties. 00565 // The recursive call makes the (main) material to be placed last in the std::vector. 00566 ProcessNodeMATERIAL( line, true ); 00567 --iNumOfSubImagesToBeProcessed; 00568 } 00569 else if ( !strncmp( node, "*NUMSUBMTLS", strlen("*NUMSUBMTLS") ) && ( strlen(node) == strlen("*NUMSUBMTLS") ) ) { 00570 sscanf( line, "%s %i", node, &iNumOfSubImagesToBeProcessed ); 00571 } 00572 00573 } while ( node[0] != '}' ); 00574 00575 00576 #ifdef TAPs_SUPPORT_ASE_FORMAT 00577 // Create the material 00578 materials.push_back( new OpenGL::Material( mat_ambient, mat_diffuse, mat_specular, mat_shininess, mat_emission ) ); 00579 00580 // Add the set of materials to the material list 00581 if ( !isSubmaterialNode && 0 == iNumOfSubImagesToBeProcessed ) { 00582 materialList.push_back( materials ); 00583 materials.clear(); 00584 00585 #ifdef TAPs_DEBUG_MODE 00586 for ( int i = 0; i < static_cast<int>(materialList.size()); ++i ) { 00587 std::cout << "I: " << i << "\n"; 00588 for ( int j = 0; j < static_cast<int>(materialList[i].size()); ++j ) { 00589 std::cout << "J: " << j << "\n"; 00590 std::cout << *materialList[i][j] << "\n"; 00591 } 00592 } 00593 #endif//TAPs_DEBUG_MODE 00594 } 00595 #endif//TAPs_SUPPORT_ASE_FORMAT 00596 00597 #ifdef TAPs_DEBUG_MODE 00598 std::cout << "End Processing Node MATERIAL\n"; 00599 #endif//TAPs_DEBUG_MODE 00600 } 00601 //----------------------------------------------------------------------------- 00602 // Process MATERIAL_LIST 00603 template <typename T> 00604 void Read3dsMaxASE<T>::ProcessNodeMAP_ ( char *line ) 00605 { 00606 #ifdef TAPs_DEBUG_MODE 00607 std::cout << line << " is skipped!\n"; 00608 //std::cout << "Start Processing Node MAP_???\n"; 00609 #endif//TAPs_DEBUG_MODE 00610 00611 //------------------------------------------------------------------- 00612 // Example: 00613 // *MAP_DIFFUSE { 00614 // *MAP_NAME "Map #10" 00615 // *MAP_CLASS "Bitmap" 00616 // *MAP_SUBNO 1 00617 // *MAP_AMOUNT 1.0000 00618 // *BITMAP "Sandshor.jpg" 00619 // *MAP_TYPE Screen 00620 // *UVW_U_OFFSET 0.0000 00621 // *UVW_V_OFFSET 0.0000 00622 // *UVW_U_TILING 1.0000 00623 // *UVW_V_TILING 1.0000 00624 // *UVW_ANGLE 0.0000 00625 // *UVW_BLUR 1.0000 00626 // *UVW_BLUR_OFFSET 0.0000 00627 // *UVW_NOUSE_AMT 1.0000 00628 // *UVW_NOISE_SIZE 1.0000 00629 // *UVW_NOISE_LEVEL 1 00630 // *UVW_NOISE_PHASE 0.0000 00631 // *BITMAP_FILTER Pyramidal 00632 // } 00633 // *MAP_BUMP { 00634 // *MAP_NAME "Map #10" 00635 // *MAP_CLASS "Bitmap" 00636 // *MAP_SUBNO 8 00637 // *MAP_AMOUNT 0.1000 00638 // *BITMAP "Sandshor.jpg" 00639 // *MAP_TYPE Screen 00640 // *UVW_U_OFFSET 0.0000 00641 // *UVW_V_OFFSET 0.0000 00642 // *UVW_U_TILING 1.0000 00643 // *UVW_V_TILING 1.0000 00644 // *UVW_ANGLE 0.0000 00645 // *UVW_BLUR 1.0000 00646 // *UVW_BLUR_OFFSET 0.0000 00647 // *UVW_NOUSE_AMT 1.0000 00648 // *UVW_NOISE_SIZE 1.0000 00649 // *UVW_NOISE_LEVEL 1 00650 // *UVW_NOISE_PHASE 0.0000 00651 // *BITMAP_FILTER Pyramidal 00652 // } 00653 char node[128]; 00654 const int SIZE = 256; 00655 do { 00656 fgets( line, SIZE, fileIn ); 00657 sscanf( line, "%s", node ); 00658 00659 #ifdef TAPs_DEBUG_MODE 00660 //std::cout << node << "\n"; 00661 #endif//TAPs_DEBUG_MODE 00662 00663 if ( !strncmp( node, "*MAP_NAME", strlen("*MAP_NAME") ) && ( strlen(node) == strlen("*MAP_NAME") ) ) { 00664 //#ifdef TAPs_DEBUG_MODE 00665 //std::cout << "skip node: MAP_NAME\n"; 00666 //#endif//TAPs_DEBUG_MODE 00667 } 00668 else if ( !strncmp( node, "*MAP_CLASS", strlen("*MAP_CLASS") ) && ( strlen(node) == strlen("*MAP_CLASS") ) ) { 00669 //#ifdef TAPs_DEBUG_MODE 00670 //std::cout << "skip node: MAP_CLASS\n"; 00671 //#endif//TAPs_DEBUG_MODE 00672 } 00673 } while ( node[0] != '}' ); 00674 00675 #ifdef TAPs_DEBUG_MODE 00676 //std::cout << "End Processing Node MAP_???\n"; 00677 #endif//TAPs_DEBUG_MODE 00678 } 00679 //----------------------------------------------------------------------------- 00680 //============================================================================= 00681 //----------------------------------------------------------------------------- 00682 // Process GEOMOBJECT 00683 template <typename T> 00684 void Read3dsMaxASE<T>::ProcessNodeGEOMOBJECT ( 00685 char *line, OpenGL::PolygonalModel<T> * const prModel ) 00686 { 00687 #ifdef TAPs_DEBUG_MODE 00688 std::cout << "Processing Node GEOMOBJECT\n"; 00689 #endif//TAPs_DEBUG_MODE 00690 00691 //------------------------------------------------------------------- 00692 // Example: 00693 // *GEOMOBJECT { 00694 // *NODE_NAME "..." 00695 // *NODE_TM { 00696 // ... 00697 // } 00698 // *MESH { 00699 // ... 00700 // } 00701 // } 00702 //------------------------------------------------------------------- 00703 char node[128]; 00704 do { 00705 fgets( line, 256, fileIn ); 00706 sscanf( line, "%s", node ); 00707 00708 #ifdef TAPs_DEBUG_MODE 00709 std::cout << node << "\n"; 00710 #endif//TAPs_DEBUG_MODE 00711 00712 if ( !strncmp( node, "*NODE_NAME", strlen("*NODE_NAME") ) && ( strlen(node) == strlen("*NODE_NAME") ) ) { 00713 // Always in this format: *NODE_NAME "..." 00714 std::string strLine( line ); 00715 size_t first = strLine.find_first_of( "\"" ); 00716 size_t last = strLine.find_last_of( "\"" ); 00717 prModel->SetName( const_cast< char * >( strLine.substr( first+1, last-first-1 ).c_str() ) ); 00718 //std::cout << "Model Name: " << prModel->GetName() << "\n"; 00719 } 00720 else if ( !strncmp( node, "*NODE_TM", strlen("*NODE_TM") ) && ( strlen(node) == strlen("*NODE_TM") ) ) { 00721 ProcessNodeNODE_TM( line, prModel ); 00722 } 00723 else if ( !strncmp( node, "*MESH", strlen("*MESH") ) && ( strlen(node) == strlen("*MESH") ) ) { 00724 ProcessNodeMESH( line, prModel ); 00725 } 00726 else if ( !strncmp( node, "*MATERIAL_REF", strlen("*MATERIAL_REF") ) && ( strlen(node) == strlen("*MATERIAL_REF") ) ) { 00727 int refID; 00728 sscanf( line, "%s %i", node, &refID ); 00729 #ifdef TAPs_SUPPORT_ASE_FORMAT 00730 SetMaterial( refID, prModel ); 00731 #endif//TAPs_SUPPORT_ASE_FORMAT 00732 } 00733 else if ( !strncmp( node, "*WIREFRAME_COLOR", strlen("*WIREFRAME_COLOR") ) && ( strlen(node) == strlen("*WIREFRAME_COLOR") ) ) { 00734 float r, g, b; 00735 sscanf( line, "%s %g %g %g", node, &r, &g, &b ); 00736 prModel->GetMaterial()->SetColorRGB( r, g, b ); 00737 // ambi diff spec emis scale (for RGBA component before applied to each color type) 00738 prModel->GetMaterial()->SetToTheRGBAColor( true, true, false, false, Vector4<GLfloat>(1.0f,1.0f,1.0f,1.0f) ); 00739 prModel->GetMaterial()->SetSpecular( 1, 1, 1, 1 ); 00740 } 00741 } while ( node[0] != '}' ); 00742 00743 #ifdef TAPs_SUPPORT_ASE_FORMAT 00744 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 00745 if ( m_iNumFaceVertexColors > 0 ) { 00746 prModel->EnableVertexColors( true ); 00747 } 00748 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 00749 00750 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00751 if ( m_iNumFaceVertexTextures > 0 ) { 00752 prModel->EnableVertexTextures( true ); 00753 } 00754 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00755 #endif//TAPs_SUPPORT_ASE_FORMAT 00756 } 00757 //----------------------------------------------------------------------------- 00758 // Process GEOMOBJECT 00759 template <typename T> 00760 void Read3dsMaxASE<T>::ProcessNodeGEOMOBJECT ( 00761 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 00762 { 00763 #ifdef TAPs_DEBUG_MODE 00764 std::cout << "Processing Node GEOMOBJECT\n"; 00765 #endif//TAPs_DEBUG_MODE 00766 00767 //------------------------------------------------------------------- 00768 // Example: 00769 // *GEOMOBJECT { 00770 // *NODE_NAME "..." 00771 // *NODE_TM { 00772 // ... 00773 // } 00774 // *MESH { 00775 // ... 00776 // } 00777 // } 00778 //------------------------------------------------------------------- 00779 char node[128]; 00780 do { 00781 fgets( line, 256, fileIn ); 00782 sscanf( line, "%s", node ); 00783 00784 #ifdef TAPs_DEBUG_MODE 00785 std::cout << node << "\n"; 00786 #endif//TAPs_DEBUG_MODE 00787 00788 if ( !strncmp( node, "*NODE_NAME", strlen("*NODE_NAME") ) && ( strlen(node) == strlen("*NODE_NAME") ) ) { 00789 // Always in this format: *NODE_NAME "..." 00790 std::string strLine( line ); 00791 size_t first = strLine.find_first_of( "\"" ); 00792 size_t last = strLine.find_last_of( "\"" ); 00793 prModel->SetName( const_cast< char * >( strLine.substr( first+1, last-first-1 ).c_str() ) ); 00794 //std::cout << "Model Name: " << prModel->GetName() << "\n"; 00795 } 00796 else if ( !strncmp( node, "*NODE_TM", strlen("*NODE_TM") ) && ( strlen(node) == strlen("*NODE_TM") ) ) { 00797 ProcessNodeNODE_TM( line, prModel ); 00798 } 00799 else if ( !strncmp( node, "*MESH", strlen("*MESH") ) && ( strlen(node) == strlen("*MESH") ) ) { 00800 ProcessNodeMESH( line, prModel ); 00801 } 00802 else if ( !strncmp( node, "*MATERIAL_REF", strlen("*MATERIAL_REF") ) && ( strlen(node) == strlen("*MATERIAL_REF") ) ) { 00803 int refID; 00804 sscanf( line, "%s %i", node, &refID ); 00805 #ifdef TAPs_SUPPORT_ASE_FORMAT 00806 SetMaterial( refID, prModel ); 00807 #endif//TAPs_SUPPORT_ASE_FORMAT 00808 } 00809 else if ( !strncmp( node, "*WIREFRAME_COLOR", strlen("*WIREFRAME_COLOR") ) && ( strlen(node) == strlen("*WIREFRAME_COLOR") ) ) { 00810 float r, g, b; 00811 sscanf( line, "%s %g %g %g", node, &r, &g, &b ); 00812 prModel->GetMaterial()->SetColorRGB( r, g, b ); 00813 // ambi diff spec emis scale (for RGBA component before applied to each color type) 00814 prModel->GetMaterial()->SetToTheRGBAColor( true, true, false, false, Vector4<GLfloat>(1.0f,1.0f,1.0f,1.0f) ); 00815 prModel->GetMaterial()->SetSpecular( 1, 1, 1, 1 ); 00816 } 00817 } while ( node[0] != '}' ); 00818 00819 #ifdef TAPs_SUPPORT_ASE_FORMAT 00820 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 00821 if ( m_iNumFaceVertexColors > 0 ) { 00822 prModel->EnableVertexColors( true ); 00823 } 00824 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 00825 00826 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00827 if ( m_iNumFaceVertexTextures > 0 ) { 00828 prModel->EnableVertexTextures( true ); 00829 } 00830 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00831 #endif//TAPs_SUPPORT_ASE_FORMAT 00832 } 00833 //----------------------------------------------------------------------------- 00834 // Process GEOMOBJECT 00835 template <typename T> 00836 void Read3dsMaxASE<T>::ProcessNodeGEOMOBJECT ( 00837 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 00838 { 00839 #ifdef TAPs_DEBUG_MODE 00840 std::cout << "Processing Node GEOMOBJECT\n"; 00841 #endif//TAPs_DEBUG_MODE 00842 00843 //------------------------------------------------------------------- 00844 // Example: 00845 // *GEOMOBJECT { 00846 // *NODE_NAME "..." 00847 // *NODE_TM { 00848 // ... 00849 // } 00850 // *MESH { 00851 // ... 00852 // } 00853 // } 00854 //------------------------------------------------------------------- 00855 char node[128]; 00856 do { 00857 fgets( line, 256, fileIn ); 00858 sscanf( line, "%s", node ); 00859 00860 #ifdef TAPs_DEBUG_MODE 00861 std::cout << node << "\n"; 00862 #endif//TAPs_DEBUG_MODE 00863 00864 if ( !strncmp( node, "*NODE_NAME", strlen("*NODE_NAME") ) && ( strlen(node) == strlen("*NODE_NAME") ) ) { 00865 // Always in this format: *NODE_NAME "..." 00866 std::string strLine( line ); 00867 size_t first = strLine.find_first_of( "\"" ); 00868 size_t last = strLine.find_last_of( "\"" ); 00869 prModel->SetName( const_cast< char * >( strLine.substr( first+1, last-first-1 ).c_str() ) ); 00870 //std::cout << "Model Name: " << prModel->GetName() << "\n"; 00871 } 00872 else if ( !strncmp( node, "*NODE_TM", strlen("*NODE_TM") ) && ( strlen(node) == strlen("*NODE_TM") ) ) { 00873 ProcessNodeNODE_TM( line, prModel ); 00874 } 00875 else if ( !strncmp( node, "*MESH", strlen("*MESH") ) && ( strlen(node) == strlen("*MESH") ) ) { 00876 ProcessNodeMESH( line, prModel ); 00877 } 00878 else if ( !strncmp( node, "*MATERIAL_REF", strlen("*MATERIAL_REF") ) && ( strlen(node) == strlen("*MATERIAL_REF") ) ) { 00879 int refID; 00880 sscanf( line, "%s %i", node, &refID ); 00881 #ifdef TAPs_SUPPORT_ASE_FORMAT 00882 SetMaterial( refID, prModel ); 00883 #endif//TAPs_SUPPORT_ASE_FORMAT 00884 } 00885 else if ( !strncmp( node, "*WIREFRAME_COLOR", strlen("*WIREFRAME_COLOR") ) && ( strlen(node) == strlen("*WIREFRAME_COLOR") ) ) { 00886 float r, g, b; 00887 sscanf( line, "%s %g %g %g", node, &r, &g, &b ); 00888 prModel->GetMaterial()->SetColorRGB( r, g, b ); 00889 // ambi diff spec emis scale (for RGBA component before applied to each color type) 00890 prModel->GetMaterial()->SetToTheRGBAColor( true, true, false, false, Vector4<GLfloat>(1.0f,1.0f,1.0f,1.0f) ); 00891 prModel->GetMaterial()->SetSpecular( 1, 1, 1, 1 ); 00892 } 00893 } while ( node[0] != '}' ); 00894 00895 00896 #ifdef TAPs_SUPPORT_ASE_FORMAT 00897 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 00898 if ( m_iNumFaceVertexColors > 0 ) { 00899 prModel->EnableVertexColors( true ); 00900 } 00901 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 00902 00903 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00904 if ( m_iNumFaceVertexTextures > 0 ) { 00905 prModel->EnableVertexTextures( true ); 00906 } 00907 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 00908 #endif//TAPs_SUPPORT_ASE_FORMAT 00909 } 00910 //----------------------------------------------------------------------------- 00911 //============================================================================= 00912 //----------------------------------------------------------------------------- 00913 // Process NODE_TM 00914 template <typename T> 00915 void Read3dsMaxASE<T>::ProcessNodeNODE_TM ( 00916 char *line, OpenGL::PolygonalModel<T> * const prModel ) 00917 { 00918 //------------------------------------------------------------------- 00919 // Skip this node 00920 00921 #ifdef TAPs_DEBUG_MODE 00922 std::cout << "Processing Node NODE_TM\n"; 00923 #endif//TAPs_DEBUG_MODE 00924 00925 //------------------------------------------------------------------- 00926 char node[128]; 00927 do { 00928 fgets( line, 256, fileIn ); 00929 sscanf( line, "%s", node ); 00930 } while ( node[0] != '}' ); 00931 } 00932 //----------------------------------------------------------------------------- 00933 // Process NODE_TM 00934 template <typename T> 00935 void Read3dsMaxASE<T>::ProcessNodeNODE_TM ( 00936 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 00937 { 00938 //------------------------------------------------------------------- 00939 // Skip this node 00940 00941 #ifdef TAPs_DEBUG_MODE 00942 std::cout << "Processing Node NODE_TM\n"; 00943 #endif//TAPs_DEBUG_MODE 00944 00945 //------------------------------------------------------------------- 00946 char node[128]; 00947 do { 00948 fgets( line, 256, fileIn ); 00949 sscanf( line, "%s", node ); 00950 } while ( node[0] != '}' ); 00951 } 00952 //----------------------------------------------------------------------------- 00953 // Process NODE_TM 00954 template <typename T> 00955 void Read3dsMaxASE<T>::ProcessNodeNODE_TM ( 00956 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 00957 { 00958 //------------------------------------------------------------------- 00959 // Skip this node 00960 00961 #ifdef TAPs_DEBUG_MODE 00962 std::cout << "Processing Node NODE_TM\n"; 00963 #endif//TAPs_DEBUG_MODE 00964 00965 //------------------------------------------------------------------- 00966 char node[128]; 00967 do { 00968 fgets( line, 256, fileIn ); 00969 sscanf( line, "%s", node ); 00970 } while ( node[0] != '}' ); 00971 } 00972 //----------------------------------------------------------------------------- 00973 //============================================================================= 00974 //----------------------------------------------------------------------------- 00975 // Process MESH 00976 template <typename T> 00977 void Read3dsMaxASE<T>::ProcessNodeMESH ( 00978 char *line, OpenGL::PolygonalModel<T> * const prModel ) 00979 { 00980 #ifdef TAPs_DEBUG_MODE 00981 std::cout << "Processing Node MESH\n"; 00982 #endif//TAPs_DEBUG_MODE 00983 00984 //------------------------------------------------------------------- 00985 // Example: 00986 // *MESH { 00987 // *TIMEVALUE 0 00988 // *MESH_NUMVERTEX 26 00989 // *MEHS_NUMFACES 48 00990 // *MESH_VERTEX_LIST { 00991 // ... 00992 // } 00993 // *MESH_FACE_LIST { 00994 // ... 00995 // } 00996 // *MESH_NUMTVERTEX 27 00997 // *MESH_TVERTLIST { 00998 // ... 00999 // } 01000 // *MESH_NUMTVFACES 48 01001 // *MESH_TFACELIST { 01002 // ... 01003 // } 01004 // *MESH_NUMCVERTEX 7 01005 // *MESH_CVERTLIST { 01006 // ... 01007 // } 01008 // *MESH_NORMALS { 01009 // ... 01010 // } 01011 // } 01012 //------------------------------------------------------------------- 01013 char node[128]; 01014 T * UVW = NULL; // for texture coordinates 01015 do { 01016 fgets( line, 256, fileIn ); 01017 sscanf( line, "%s", node ); 01018 if ( !strncmp( node, "*MESH_NUMVERTEX", strlen("*MESH_NUMVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMVERTEX") ) ) { 01019 01020 #ifdef TAPs_DEBUG_MODE 01021 std::cout << "Processing Node MESH_NUMVERTEX\n"; 01022 #endif//TAPs_DEBUG_MODE 01023 01024 int size; 01025 sscanf( line, "%s %d", node, &size ); 01026 prModel->SetNoVertices( size ); 01027 prModel->NewVertexListByNoVertices(); 01028 01029 #ifdef TAPs_DEBUG_MODE 01030 std::cout << "NUMBER OF VERTICES: " << prModel->GetNoVertices() << "\n"; 01031 #endif//TAPs_DEBUG_MODE 01032 } 01033 else if ( !strncmp( node, "*MESH_NUMFACES", strlen("*MESH_NUMFACES") ) && ( strlen(node) == strlen("*MESH_NUMFACES") ) ) { 01034 01035 #ifdef TAPs_DEBUG_MODE 01036 std::cout << "Processing Node MESH_NUMFACES\n"; 01037 #endif//TAPs_DEBUG_MODE 01038 01039 int size; 01040 sscanf( line, "%s %d", node, &size ); 01041 prModel->SetNoFaces( size ); 01042 prModel->NewFaceListByNoFaces(); 01043 01044 #ifdef TAPs_DEBUG_MODE 01045 std::cout << "NUMBER OF FACES: " << prModel->GetNoFaces() << "\n"; 01046 #endif//TAPs_DEBUG_MODE 01047 } 01048 else if ( !strncmp( node, "*MESH_VERTEX_LIST", strlen("*MESH_VERTEX_LIST") ) && ( strlen(node) == strlen("*MESH_VERTEX_LIST") ) ) { 01049 ProcessNodeMESH_VERTEX_LIST( line, prModel ); 01050 } 01051 else if ( !strncmp( node, "*MESH_FACE_LIST", strlen("*MESH_FACE_LIST") ) && ( strlen(node) == strlen("*MESH_FACE_LIST") ) ) { 01052 ProcessNodeMESH_FACE_LIST( line, prModel ); 01053 } 01054 01055 #ifndef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01056 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01057 // Example: number of textured vertices 01058 // *MESH_NUMTVERTEX 12 01059 01060 #ifdef TAPs_DEBUG_MODE 01061 std::cout << "Processing Node MESH_NUMTVERTEX\n"; 01062 #endif//TAPs_DEBUG_MODE 01063 01064 int size; 01065 sscanf( line, "%s %d", node, &size ); 01066 UVW = new T[ size*3 ]; 01067 } 01068 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01069 ProcessNodeMESH_TVERTLIST( line, prModel, UVW ); 01070 } 01071 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01072 // Example: number of textured faces 01073 // *MESH_NUMTVFACES 12 01074 // Number of textured faces cannot exceed the total number of faces 01075 } 01076 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01077 ProcessNodeMESH_TFACELIST( line, prModel, UVW ); 01078 } 01079 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01080 01081 else if ( !strncmp( node, "*MESH_NORMALS", strlen("*MESH_NORMALS") ) && ( strlen(node) == strlen("*MESH_NORMALS") ) ) { 01082 ProcessNodeMESH_NORMALS( line, prModel ); 01083 } 01084 01085 #ifdef TAPs_SUPPORT_ASE_FORMAT 01086 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 01087 else if ( !strncmp( node, "*MESH_NUMCVERTEX", strlen("*MESH_NUMCVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMCVERTEX") ) ) { 01088 ProcessNodeMESH_NUMCVERTEX( line ); 01089 } 01090 else if ( !strncmp( node, "*MESH_CVERTLIST", strlen("*MESH_CVERTLIST") ) && ( strlen(node) == strlen("*MESH_CVERTLIST") ) ) { 01091 ProcessNodeMESH_CVERTLIST( line, prModel ); 01092 } 01093 else if ( !strncmp( node, "*MESH_NUMCVFACES", strlen("*MESH_NUMCVFACES") ) && ( strlen(node) == strlen("*MESH_NUMCVFACES") ) ) { 01094 ProcessNodeMESH_NUMCVFACES( line ); 01095 } 01096 else if ( !strncmp( node, "*MESH_CFACELIST", strlen("*MESH_CFACELIST") ) && ( strlen(node) == strlen("*MESH_CFACELIST") ) ) { 01097 ProcessNodeMESH_CFACELIST( line, prModel ); 01098 } 01099 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 01100 01101 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01102 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01103 ProcessNodeMESH_NUMTVERTEX( line ); 01104 } 01105 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01106 ProcessNodeMESH_TVERTLIST( line, prModel ); 01107 } 01108 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01109 ProcessNodeMESH_NUMTVFACES( line ); 01110 } 01111 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01112 ProcessNodeMESH_TFACELIST( line, prModel ); 01113 } 01114 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01115 #endif//TAPs_SUPPORT_ASE_FORMAT 01116 01117 } while ( node[0] != '}' ); 01118 //------------------------------------------------------------------- 01119 // Delete UVW (Texture Coordinates) 01120 if ( UVW ) { 01121 delete [] UVW; 01122 } 01123 } 01124 //----------------------------------------------------------------------------- 01125 // Process MESH 01126 template <typename T> 01127 void Read3dsMaxASE<T>::ProcessNodeMESH ( 01128 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 01129 { 01130 #ifdef TAPs_DEBUG_MODE 01131 std::cout << "Processing Node MESH\n"; 01132 #endif//TAPs_DEBUG_MODE 01133 01134 //------------------------------------------------------------------- 01135 // Example: 01136 // *MESH { 01137 // *TIMEVALUE 0 01138 // *MESH_NUMVERTEX 26 01139 // *MEHS_NUMFACES 48 01140 // *MESH_VERTEX_LIST { 01141 // ... 01142 // } 01143 // *MESH_FACE_LIST { 01144 // ... 01145 // } 01146 // *MESH_NUMTVERTEX 27 01147 // *MESH_TVERTLIST { 01148 // ... 01149 // } 01150 // *MESH_NUMTVFACES 48 01151 // *MESH_TFACELIST { 01152 // ... 01153 // } 01154 // *MESH_NUMCVERTEX 7 01155 // *MESH_CVERTLIST { 01156 // ... 01157 // } 01158 // *MESH_NORMALS { 01159 // ... 01160 // } 01161 // } 01162 //------------------------------------------------------------------- 01163 char node[128]; 01164 T * UVW = NULL; // for texture coordinates 01165 do { 01166 fgets( line, 256, fileIn ); 01167 sscanf( line, "%s", node ); 01168 if ( !strncmp( node, "*MESH_NUMVERTEX", strlen("*MESH_NUMVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMVERTEX") ) ) { 01169 01170 #ifdef TAPs_DEBUG_MODE 01171 std::cout << "Processing Node MESH_NUMVERTEX\n"; 01172 #endif//TAPs_DEBUG_MODE 01173 01174 int size; 01175 sscanf( line, "%s %d", node, &size ); 01176 prModel->SetNoVertices( size ); 01177 prModel->NewVertexListByNoVertices(); 01178 01179 #ifdef TAPs_DEBUG_MODE 01180 std::cout << "NUMBER OF VERTICES: " << prModel->GetNoVertices() << "\n"; 01181 #endif//TAPs_DEBUG_MODE 01182 } 01183 else if ( !strncmp( node, "*MESH_NUMFACES", strlen("*MESH_NUMFACES") ) && ( strlen(node) == strlen("*MESH_NUMFACES") ) ) { 01184 01185 #ifdef TAPs_DEBUG_MODE 01186 std::cout << "Processing Node MESH_NUMFACES\n"; 01187 #endif//TAPs_DEBUG_MODE 01188 01189 int size; 01190 sscanf( line, "%s %d", node, &size ); 01191 prModel->SetNoFaces( size ); 01192 prModel->NewFaceListByNoFaces(); 01193 01194 #ifdef TAPs_DEBUG_MODE 01195 std::cout << "NUMBER OF FACES: " << prModel->GetNoFaces() << "\n"; 01196 #endif//TAPs_DEBUG_MODE 01197 } 01198 else if ( !strncmp( node, "*MESH_VERTEX_LIST", strlen("*MESH_VERTEX_LIST") ) && ( strlen(node) == strlen("*MESH_VERTEX_LIST") ) ) { 01199 ProcessNodeMESH_VERTEX_LIST( line, prModel ); 01200 } 01201 else if ( !strncmp( node, "*MESH_FACE_LIST", strlen("*MESH_FACE_LIST") ) && ( strlen(node) == strlen("*MESH_FACE_LIST") ) ) { 01202 ProcessNodeMESH_FACE_LIST( line, prModel ); 01203 } 01204 01205 #ifndef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01206 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01207 // Example: number of textured vertices 01208 // *MESH_NUMTVERTEX 12 01209 01210 #ifdef TAPs_DEBUG_MODE 01211 std::cout << "Processing Node MESH_NUMTVERTEX\n"; 01212 #endif//TAPs_DEBUG_MODE 01213 01214 int size; 01215 sscanf( line, "%s %d", node, &size ); 01216 UVW = new T[ size*3 ]; 01217 } 01218 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01219 ProcessNodeMESH_TVERTLIST( line, prModel, UVW ); 01220 } 01221 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01222 // Example: number of textured faces 01223 // *MESH_NUMTVFACES 12 01224 // Number of textured faces cannot exceed the total number of faces 01225 } 01226 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01227 ProcessNodeMESH_TFACELIST( line, prModel, UVW ); 01228 } 01229 #endif TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01230 01231 else if ( !strncmp( node, "*MESH_NORMALS", strlen("*MESH_NORMALS") ) && ( strlen(node) == strlen("*MESH_NORMALS") ) ) { 01232 ProcessNodeMESH_NORMALS( line, prModel ); 01233 } 01234 01235 #ifdef TAPs_SUPPORT_ASE_FORMAT 01236 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 01237 else if ( !strncmp( node, "*MESH_NUMCVERTEX", strlen("*MESH_NUMCVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMCVERTEX") ) ) { 01238 ProcessNodeMESH_NUMCVERTEX( line ); 01239 } 01240 else if ( !strncmp( node, "*MESH_CVERTLIST", strlen("*MESH_CVERTLIST") ) && ( strlen(node) == strlen("*MESH_CVERTLIST") ) ) { 01241 ProcessNodeMESH_CVERTLIST( line, prModel ); 01242 } 01243 else if ( !strncmp( node, "*MESH_NUMCVFACES", strlen("*MESH_NUMCVFACES") ) && ( strlen(node) == strlen("*MESH_NUMCVFACES") ) ) { 01244 ProcessNodeMESH_NUMCVFACES( line ); 01245 } 01246 else if ( !strncmp( node, "*MESH_CFACELIST", strlen("*MESH_CFACELIST") ) && ( strlen(node) == strlen("*MESH_CFACELIST") ) ) { 01247 ProcessNodeMESH_CFACELIST( line, prModel ); 01248 } 01249 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 01250 01251 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01252 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01253 ProcessNodeMESH_NUMTVERTEX( line ); 01254 } 01255 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01256 ProcessNodeMESH_TVERTLIST( line, prModel ); 01257 } 01258 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01259 ProcessNodeMESH_NUMTVFACES( line ); 01260 } 01261 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01262 ProcessNodeMESH_TFACELIST( line, prModel ); 01263 } 01264 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01265 #endif//TAPs_SUPPORT_ASE_FORMAT 01266 01267 } while ( node[0] != '}' ); 01268 //------------------------------------------------------------------- 01269 // Delete UVW (Texture Coordinates) 01270 if ( UVW ) { 01271 delete [] UVW; 01272 } 01273 } 01274 //----------------------------------------------------------------------------- 01275 // Process MESH 01276 template <typename T> 01277 void Read3dsMaxASE<T>::ProcessNodeMESH ( 01278 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 01279 { 01280 #ifdef TAPs_DEBUG_MODE 01281 std::cout << "Processing Node MESH\n"; 01282 #endif//TAPs_DEBUG_MODE 01283 01284 //------------------------------------------------------------------- 01285 // Example: 01286 // *MESH { 01287 // *TIMEVALUE 0 01288 // *MESH_NUMVERTEX 26 01289 // *MEHS_NUMFACES 48 01290 // *MESH_VERTEX_LIST { 01291 // ... 01292 // } 01293 // *MESH_FACE_LIST { 01294 // ... 01295 // } 01296 // *MESH_NUMTVERTEX 27 01297 // *MESH_TVERTLIST { 01298 // ... 01299 // } 01300 // *MESH_NUMTVFACES 48 01301 // *MESH_TFACELIST { 01302 // ... 01303 // } 01304 // *MESH_NUMCVERTEX 7 01305 // *MESH_CVERTLIST { 01306 // ... 01307 // } 01308 // *MESH_NORMALS { 01309 // ... 01310 // } 01311 // } 01312 //------------------------------------------------------------------- 01313 char node[128]; 01314 T * UVW = NULL; // for texture coordinates 01315 do { 01316 fgets( line, 256, fileIn ); 01317 sscanf( line, "%s", node ); 01318 if ( !strncmp( node, "*MESH_NUMVERTEX", strlen("*MESH_NUMVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMVERTEX") ) ) { 01319 01320 #ifdef TAPs_DEBUG_MODE 01321 std::cout << "Processing Node MESH_NUMVERTEX\n"; 01322 #endif//TAPs_DEBUG_MODE 01323 01324 int size; 01325 sscanf( line, "%s %d", node, &size ); 01326 prModel->SetNoVertices( size ); 01327 01328 HelpCreateHalfEdgeModel<T>::vertexList = 01329 new HEVertex<T>*[ size ]; 01330 HelpCreateHalfEdgeModel<T>::vertexRingList = 01331 new DS::HashTableBySTLVector<int>( size ); 01332 HelpCreateHalfEdgeModel<T>::halfEdgeRingList = 01333 new DS::HashTableBySTLVector< HEHalfEdge<T> * >( size ); 01334 01335 #ifdef TAPs_DEBUG_MODE 01336 std::cout << "NUMBER OF VERTICES: " << prModel->GetNoVertices() << "\n"; 01337 #endif//TAPs_DEBUG_MODE 01338 } 01339 else if ( !strncmp( node, "*MESH_NUMFACES", strlen("*MESH_NUMFACES") ) && ( strlen(node) == strlen("*MESH_NUMFACES") ) ) { 01340 01341 #ifdef TAPs_DEBUG_MODE 01342 std::cout << "Processing Node MESH_NUMFACES\n"; 01343 #endif//TAPs_DEBUG_MODE 01344 01345 int size; 01346 sscanf( line, "%s %d", node, &size ); 01347 prModel->SetNoFaces( size ); 01348 //??? prModel->NewFaceListByNoFaces(); 01349 01350 //std::cout << "[DEBUG IN Read3dsMaxASE] Number of Faces: " << size << std::endl; 01351 01352 #ifdef TAPs_DEBUG_MODE 01353 std::cout << "NUMBER OF FACES: " << prModel->GetNoFaces() << "\n"; 01354 #endif//TAPs_DEBUG_MODE 01355 } 01356 else if ( !strncmp( node, "*MESH_VERTEX_LIST", strlen("*MESH_VERTEX_LIST") ) && ( strlen(node) == strlen("*MESH_VERTEX_LIST") ) ) { 01357 ProcessNodeMESH_VERTEX_LIST( line, prModel ); 01358 } 01359 else if ( !strncmp( node, "*MESH_FACE_LIST", strlen("*MESH_FACE_LIST") ) && ( strlen(node) == strlen("*MESH_FACE_LIST") ) ) { 01360 ProcessNodeMESH_FACE_LIST( line, prModel ); 01361 } 01362 01363 #ifndef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01364 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01365 // Example: number of textured vertices 01366 // *MESH_NUMTVERTEX 12 01367 01368 #ifdef TAPs_DEBUG_MODE 01369 std::cout << "Processing Node MESH_NUMTVERTEX\n"; 01370 #endif//TAPs_DEBUG_MODE 01371 01372 int size; 01373 sscanf( line, "%s %d", node, &size ); 01374 UVW = new T[ size*3 ]; 01375 } 01376 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01377 ProcessNodeMESH_TVERTLIST( line, prModel, UVW ); 01378 } 01379 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01380 // Example: number of textured faces 01381 // *MESH_NUMTVFACES 12 01382 // Number of textured faces cannot exceed the total number of faces 01383 } 01384 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01385 ProcessNodeMESH_TFACELIST( line, prModel, UVW ); 01386 } 01387 #endif TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01388 01389 else if ( !strncmp( node, "*MESH_NORMALS", strlen("*MESH_NORMALS") ) && ( strlen(node) == strlen("*MESH_NORMALS") ) ) { 01390 ProcessNodeMESH_NORMALS( line, prModel ); 01391 } 01392 01393 #ifdef TAPs_SUPPORT_ASE_FORMAT 01394 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 01395 else if ( !strncmp( node, "*MESH_NUMCVERTEX", strlen("*MESH_NUMCVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMCVERTEX") ) ) { 01396 ProcessNodeMESH_NUMCVERTEX( line ); 01397 } 01398 else if ( !strncmp( node, "*MESH_CVERTLIST", strlen("*MESH_CVERTLIST") ) && ( strlen(node) == strlen("*MESH_CVERTLIST") ) ) { 01399 ProcessNodeMESH_CVERTLIST( line, prModel ); 01400 } 01401 else if ( !strncmp( node, "*MESH_NUMCVFACES", strlen("*MESH_NUMCVFACES") ) && ( strlen(node) == strlen("*MESH_NUMCVFACES") ) ) { 01402 ProcessNodeMESH_NUMCVFACES( line ); 01403 } 01404 else if ( !strncmp( node, "*MESH_CFACELIST", strlen("*MESH_CFACELIST") ) && ( strlen(node) == strlen("*MESH_CFACELIST") ) ) { 01405 ProcessNodeMESH_CFACELIST( line, prModel ); 01406 } 01407 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 01408 01409 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01410 else if ( !strncmp( node, "*MESH_NUMTVERTEX", strlen("*MESH_NUMTVERTEX") ) && ( strlen(node) == strlen("*MESH_NUMTVERTEX") ) ) { 01411 ProcessNodeMESH_NUMTVERTEX( line ); 01412 } 01413 else if ( !strncmp( node, "*MESH_TVERTLIST", strlen("*MESH_TVERTLIST") ) && ( strlen(node) == strlen("*MESH_TVERTLIST") ) ) { 01414 ProcessNodeMESH_TVERTLIST( line, prModel ); 01415 } 01416 else if ( !strncmp( node, "*MESH_NUMTVFACES", strlen("*MESH_NUMTVFACES") ) && ( strlen(node) == strlen("*MESH_NUMTVFACES") ) ) { 01417 ProcessNodeMESH_NUMTVFACES( line ); 01418 } 01419 else if ( !strncmp( node, "*MESH_TFACELIST", strlen("*MESH_TFACELIST") ) && ( strlen(node) == strlen("*MESH_TFACELIST") ) ) { 01420 ProcessNodeMESH_TFACELIST( line, prModel ); 01421 } 01422 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 01423 #endif//TAPs_SUPPORT_ASE_FORMAT 01424 01425 } while ( node[0] != '}' ); 01426 //------------------------------------------------------------------- 01427 // Delete UVW (Texture Coordinates) 01428 if ( UVW ) { 01429 delete [] UVW; 01430 } 01431 } 01432 //----------------------------------------------------------------------------- 01433 //============================================================================= 01434 //----------------------------------------------------------------------------- 01435 // Process MESH_VERTEX_LIST 01436 template <typename T> 01437 void Read3dsMaxASE<T>::ProcessNodeMESH_VERTEX_LIST ( 01438 char *line, OpenGL::PolygonalModel<T> * const prModel ) 01439 { 01440 #ifdef TAPs_DEBUG_MODE 01441 std::cout << "Processing Node MESH_VERTEX_LIST\n"; 01442 #endif//TAPs_DEBUG_MODE 01443 01444 //------------------------------------------------------------------- 01445 // Example: 01446 // *MESH_VERTEX_LIST { 01447 // *MESH_VERTEX 0 -10.000000 -5.000000 0.000000 01448 // *MESH_VERTEX 1 10.000000 -5.000000 0.000000 01449 // *MESH_VERTEX 2 -10.000000 5.000000 0.000000 01450 // ... 01451 // } 01452 //------------------------------------------------------------------- 01453 char node[128]; 01454 int n; 01455 float x, y, z; 01456 fgets( line, 256, fileIn ); 01457 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01458 while ( node[0] != '}' ) { 01459 prModel->GetVertexList()[n][0] = x; 01460 prModel->GetVertexList()[n][1] = y; 01461 prModel->GetVertexList()[n][2] = z; 01462 01463 #ifdef TAPs_DEBUG_MODE 01464 //std::cout << "Vertex#" << n << "\t" << prModel->GetVertexList()[n] << "\n"; 01465 #endif//TAPs_DEBUG_MODE 01466 01467 fgets( line, 256, fileIn ); 01468 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01469 } 01470 } 01471 //----------------------------------------------------------------------------- 01472 // Process MESH_VERTEX_LIST 01473 template <typename T> 01474 void Read3dsMaxASE<T>::ProcessNodeMESH_VERTEX_LIST ( 01475 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 01476 { 01477 #ifdef TAPs_DEBUG_MODE 01478 std::cout << "Processing Node MESH_VERTEX_LIST\n"; 01479 #endif//TAPs_DEBUG_MODE 01480 01481 //------------------------------------------------------------------- 01482 // Example: 01483 // *MESH_VERTEX_LIST { 01484 // *MESH_VERTEX 0 -10.000000 -5.000000 0.000000 01485 // *MESH_VERTEX 1 10.000000 -5.000000 0.000000 01486 // *MESH_VERTEX 2 -10.000000 5.000000 0.000000 01487 // ... 01488 // } 01489 //------------------------------------------------------------------- 01490 char node[128]; 01491 int n; 01492 float x, y, z; 01493 fgets( line, 256, fileIn ); 01494 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01495 while ( node[0] != '}' ) { 01496 prModel->GetVertexList()[n][0] = x; 01497 prModel->GetVertexList()[n][1] = y; 01498 prModel->GetVertexList()[n][2] = z; 01499 01500 ++vertexNo; // next vertex# 01501 01502 #ifdef TAPs_DEBUG_MODE 01503 //std::cout << "Vertex: " << vertexNo << "\n"; 01504 //std::cout << "Vertex#" << n << "\t" << prModel->GetVertexList()[n] << "\n"; 01505 #endif//TAPs_DEBUG_MODE 01506 01507 fgets( line, 256, fileIn ); 01508 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01509 } 01510 } 01511 //----------------------------------------------------------------------------- 01512 // Process MESH_VERTEX_LIST 01513 template <typename T> 01514 void Read3dsMaxASE<T>::ProcessNodeMESH_VERTEX_LIST ( 01515 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 01516 { 01517 #ifdef TAPs_DEBUG_MODE 01518 std::cout << "Processing Node MESH_VERTEX_LIST\n"; 01519 #endif//TAPs_DEBUG_MODE 01520 01521 //------------------------------------------------------------------- 01522 // Example: 01523 // *MESH_VERTEX_LIST { 01524 // *MESH_VERTEX 0 -10.000000 -5.000000 0.000000 01525 // *MESH_VERTEX 1 10.000000 -5.000000 0.000000 01526 // *MESH_VERTEX 2 -10.000000 5.000000 0.000000 01527 // ... 01528 // } 01529 //------------------------------------------------------------------- 01530 char node[128]; 01531 int n; 01532 float x, y, z; 01533 fgets( line, 256, fileIn ); 01534 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01535 while ( node[0] != '}' ) { 01536 //------------------------------------------------------ 01537 // Put created vertex in vertexList for look up later 01538 HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] = new HEVertex<T>( 01539 x, y, z, 01540 0, 0, 0 01541 #ifdef TAPs_USE_DATA_POOL 01542 , prModel->GetArrayOfVertexPositions().GetAddressOfDataNumber( vertexNo ) 01543 , prModel->GetArrayOfVertexNormals().GetAddressOfDataNumber( vertexNo ) 01544 #endif//TAPs_USE_DATA_POOL 01545 ); 01546 // Put created vertex in vertexList of the model 01547 prModel->GetVertexList()->Append( HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] ); 01548 ++vertexNo; // next vertex# 01549 01550 #ifdef TAPs_DEBUG_MODE 01551 //std::cout << "Vertex: " << vertexNo << "\n"; 01552 #endif//TAPs_DEBUG_MODE 01553 01554 //------------------------------------------------------ 01555 fgets( line, 256, fileIn ); 01556 sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z ); 01557 } 01558 01559 //std::cout << prModel->GetArrayOfVertexPositions().StrArrayData(); 01560 } 01561 //----------------------------------------------------------------------------- 01562 //============================================================================= 01563 //----------------------------------------------------------------------------- 01564 // Process MESH_FACE_LIST 01565 template <typename T> 01566 void Read3dsMaxASE<T>::ProcessNodeMESH_FACE_LIST ( 01567 char *line, OpenGL::PolygonalModel<T> * const prModel ) 01568 { 01569 #ifdef TAPs_DEBUG_MODE 01570 std::cout << "Processing Node MESH_FACE_LIST\n"; 01571 #endif//TAPs_DEBUG_MODE 01572 01573 //------------------------------------------------------------------- 01574 // Example: 01575 // face id v0 v1 v2 e0 e1 e2 mesh smooth material id 01576 // *MESH_FACE_LIST { 01577 // *MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01578 // *MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01579 // *MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0 01580 // ... 01581 // } 01582 //------------------------------------------------------------------- 01583 char node[128]; 01584 char N[16], A[4], B[4], C[4]; 01585 int v0, v1, v2; 01586 fgets( line, 256, fileIn ); 01587 01588 #ifdef TAPs_SUPPORT_ASE_FORMAT 01589 char AB[8], BC[8], CA[8], SMOOTH[32], MATID[32]; 01590 int e0, e1, e2, mesh_smooth, mesh_mtlid; 01591 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01592 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01593 #else //TAPs_SUPPORT_ASE_FORMAT 01594 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01595 #endif//TAPs_SUPPORT_ASE_FORMAT 01596 01597 faceNo = 0; 01598 while ( node[0] != '}' ) { 01599 prModel->GetFaceList()[faceNo].SetNoVertices( 3 ); 01600 prModel->GetFaceList()[faceNo].SetVertexNo( 0, v0 ); 01601 prModel->GetFaceList()[faceNo].SetVertexNo( 1, v1 ); 01602 prModel->GetFaceList()[faceNo].SetVertexNo( 2, v2 ); 01603 #ifdef TAPs_SUPPORT_ASE_FORMAT 01604 prModel->GetFaceList()[faceNo].SetMaterialID( mesh_mtlid ); 01605 #endif//TAPs_SUPPORT_ASE_FORMAT 01606 01607 #ifdef TAPs_DEBUG_MODE 01608 //std::cout << "Face#" << n << "\t" << prModel->GetFaceList()[n] << "\n"; 01609 #endif//TAPs_DEBUG_MODE 01610 01611 ++faceNo; 01612 fgets( line, 256, fileIn ); 01613 #ifdef TAPs_SUPPORT_ASE_FORMAT 01614 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01615 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01616 #else //TAPs_SUPPORT_ASE_FORMAT 01617 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01618 #endif//TAPs_SUPPORT_ASE_FORMAT 01619 } 01620 } 01621 //----------------------------------------------------------------------------- 01622 // Process MESH_FACE_LIST 01623 template <typename T> 01624 void Read3dsMaxASE<T>::ProcessNodeMESH_FACE_LIST ( 01625 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 01626 { 01627 #ifdef TAPs_DEBUG_MODE 01628 std::cout << "Processing Node MESH_FACE_LIST\n"; 01629 #endif//TAPs_DEBUG_MODE 01630 01631 //------------------------------------------------------------------- 01632 // Example: 01633 // *MESH_FACE_LIST { 01634 // face id v0 v1 v2 e0 e1 e2 mesh smooth material id 01635 // *MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01636 // *MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01637 // *MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0 01638 // ... 01639 // } 01640 //------------------------------------------------------------------- 01641 char node[128]; 01642 char N[16], A[4], B[4], C[4]; 01643 int v0, v1, v2; 01644 fgets( line, 256, fileIn ); 01645 01646 #ifdef TAPs_SUPPORT_ASE_FORMAT 01647 char AB[8], BC[8], CA[8], SMOOTH[32], MATID[32]; 01648 int e0, e1, e2, mesh_smooth, mesh_mtlid; 01649 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01650 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01651 #else //TAPs_SUPPORT_ASE_FORMAT 01652 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01653 #endif//TAPs_SUPPORT_ASE_FORMAT 01654 01655 faceNo = 0; 01656 while ( node[0] != '}' ) { 01657 prModel->GetFaceList()[faceNo].SetNoVertices( 3 ); 01658 prModel->GetFaceList()[faceNo].SetVertexNo( 0, v0 ); 01659 prModel->GetFaceList()[faceNo].SetVertexNo( 1, v1 ); 01660 prModel->GetFaceList()[faceNo].SetVertexNo( 2, v2 ); 01661 #ifdef TAPs_SUPPORT_ASE_FORMAT 01662 prModel->GetFaceList()[faceNo].SetMaterialID( mesh_mtlid ); 01663 #endif//TAPs_SUPPORT_ASE_FORMAT 01664 01665 #ifdef TAPs_DEBUG_MODE 01666 //std::cout << "Face#" << n << "\t" << prModel->GetFaceList()[n] << "\n"; 01667 #endif//TAPs_DEBUG_MODE 01668 01669 ++faceNo; 01670 fgets( line, 256, fileIn ); 01671 #ifdef TAPs_SUPPORT_ASE_FORMAT 01672 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01673 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01674 #else //TAPs_SUPPORT_ASE_FORMAT 01675 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01676 #endif//TAPs_SUPPORT_ASE_FORMAT 01677 } 01678 } 01679 //----------------------------------------------------------------------------- 01680 // Process MESH_FACE_LIST 01681 template <typename T> 01682 void Read3dsMaxASE<T>::ProcessNodeMESH_FACE_LIST ( 01683 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 01684 { 01685 #ifdef TAPs_DEBUG_MODE 01686 std::cout << "Processing Node MESH_FACE_LIST\n"; 01687 #endif//TAPs_DEBUG_MODE 01688 //------------------------------------------------------------------- 01689 // Example: 01690 // *MESH_FACE_LIST { 01691 // face id v0 v1 v2 e0 e1 e2 mesh smooth material id 01692 // *MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01693 // *MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1 01694 // *MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0 01695 // ... 01696 // } 01697 //------------------------------------------------------------------- 01698 HEFace<T> *heFace; 01699 char node[128]; 01700 char N[16], A[4], B[4], C[4]; 01701 int v0, v1, v2; 01702 fgets( line, 256, fileIn ); 01703 01704 #ifdef TAPs_SUPPORT_ASE_FORMAT 01705 char AB[8], BC[8], CA[8], SMOOTH[32], MATID[32]; 01706 int e0, e1, e2, mesh_smooth, mesh_mtlid; 01707 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01708 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01709 #else //TAPs_SUPPORT_ASE_FORMAT 01710 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01711 #endif//TAPs_SUPPORT_ASE_FORMAT 01712 01713 faceNo = 0; 01714 while ( node[0] != '}' ) { 01715 heFace = new HEFace<T>(); 01716 prModel->GetFaceList()->Append( heFace ); 01717 //---------------------------------------------------------------- 01718 // Create and Set all three half-edges 01719 HEHalfEdge<T> *heHalfEdge0 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 01720 HelpCreateHalfEdgeModel<T>::vertexList[v0], 01721 HelpCreateHalfEdgeModel<T>::vertexList[v1], 01722 heFace ); 01723 HEHalfEdge<T> *heHalfEdge1 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 01724 HelpCreateHalfEdgeModel<T>::vertexList[v1], 01725 HelpCreateHalfEdgeModel<T>::vertexList[v2], 01726 heFace, heHalfEdge0 ); 01727 HEHalfEdge<T> *heHalfEdge2 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 01728 HelpCreateHalfEdgeModel<T>::vertexList[v2], 01729 HelpCreateHalfEdgeModel<T>::vertexList[v0], 01730 heFace, heHalfEdge1, heHalfEdge0 ); 01731 halfEdgeCounter += 3; 01732 //---------------------------------------------------------------- 01733 // Set incident half-edge of this face 01734 heFace->IncidentHalfEdge( heHalfEdge0 ); 01735 //---------------------------------------------------------------- 01736 #ifdef TAPs_SUPPORT_ASE_FORMAT 01737 heFace->SetMaterialID( mesh_mtlid ); 01738 #endif//TAPs_SUPPORT_ASE_FORMAT 01739 //---------------------------------------------------------------- 01740 // (CCW) Record v0 to v1, v1 to v2, and v2 to v0 in vertexRingList 01741 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v1, v0 ); // put v1 in bucket v0 01742 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v2, v1 ); // put v2 in bucket v1 01743 HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v0, v2 ); // put v0 in bucket v2 01744 //---------------------------------------------------------------- 01745 // Record half-edges in halfEdgeRingList 01746 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge0, v0 ); // put in bucket v0 01747 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge1, v1 ); // put in bucket v1 01748 HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge2, v2 ); // put in bucket v2 01749 //---------------------------------------------------------------- 01750 01751 #ifdef TAPs_USE_DATA_POOL 01752 prModel->SetTriFace( faceNo, v0, v1, v2 ); 01753 #endif//TAPs_USE_DATA_POOL 01754 01755 ++faceNo; 01756 fgets( line, 256, fileIn ); 01757 #ifdef TAPs_SUPPORT_ASE_FORMAT 01758 sscanf( line, "%s %s %s %d %s %d %s %d %s %d %s %d %s %d %s %d %s %d ", 01759 node, N, A, &v0, B, &v1, C, &v2, AB, &e0, BC, &e1, CA, &e2, SMOOTH, &mesh_smooth, MATID, &mesh_mtlid ); 01760 #else //TAPs_SUPPORT_ASE_FORMAT 01761 sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 ); 01762 #endif//TAPs_SUPPORT_ASE_FORMAT 01763 } 01764 01765 #ifdef TAPs_USE_DATA_POOL 01766 std::cout << "[DEBUG IN Read3dsMaxASE] Face Index List: " << prModel->GetArrayOfIndexFaces().StrArrayData() << "\n"; 01767 #endif//TAPs_USE_DATA_POOL 01768 } 01769 //----------------------------------------------------------------------------- 01770 01771 01772 // OBSOLETE CODE -- WILL BE REMOVED!!! 01773 #if (!defined TAPs_SUPPORT_ASE_FORMAT || (defined TAPs_SUPPORT_ASE_FORMAT && !defined TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES)) 01774 //============================================================================= 01775 //----------------------------------------------------------------------------- 01776 // Process MESH_TVERTLIST 01777 template <typename T> 01778 void Read3dsMaxASE<T>::ProcessNodeMESH_TVERTLIST ( 01779 char *line, OpenGL::PolygonalModel<T> * const prModel, T * UVW ) 01780 { 01781 #ifdef TAPs_DEBUG_MODE 01782 std::cout << "Processing Node MESH_TVERTLIST\n"; 01783 #endif//TAPs_DEBUG_MODE 01784 01785 //------------------------------------------------------------------- 01786 // Example: 01787 // *MESH_TVERTLIST { 01788 // *MESH_TVERT 0 0.000000 0.000000 0.000000 01789 // *MESH_TVERT 1 1.000000 0.000000 0.000000 01790 // *MESH_TVERT 2 0.000000 1.000000 0.000000 01791 // ... 01792 // } 01793 //------------------------------------------------------------------- 01794 char node[128]; 01795 int n; 01796 float u, v, w; 01797 fgets( line, 256, fileIn ); 01798 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01799 while ( node[0] != '}' ) { 01800 UVW[ n*3 ] = u; 01801 UVW[ n*3+1 ] = v; 01802 UVW[ n*3+2 ] = w; 01803 fgets( line, 256, fileIn ); 01804 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01805 } 01806 } 01807 //----------------------------------------------------------------------------- 01808 // Process MESH_TVERTLIST 01809 template <typename T> 01810 void Read3dsMaxASE<T>::ProcessNodeMESH_TVERTLIST ( 01811 char *line, OpenGL::XPolygonalModel<T> * const prModel, T * UVW ) 01812 { 01813 #ifdef TAPs_DEBUG_MODE 01814 std::cout << "Processing Node MESH_TVERTLIST\n"; 01815 #endif//TAPs_DEBUG_MODE 01816 01817 //------------------------------------------------------------------- 01818 // Example: 01819 // *MESH_TVERTLIST { 01820 // *MESH_TVERT 0 0.000000 0.000000 0.000000 01821 // *MESH_TVERT 1 1.000000 0.000000 0.000000 01822 // *MESH_TVERT 2 0.000000 1.000000 0.000000 01823 // ... 01824 // } 01825 //------------------------------------------------------------------- 01826 char node[128]; 01827 int n; 01828 float u, v, w; 01829 fgets( line, 256, fileIn ); 01830 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01831 while ( node[0] != '}' ) { 01832 UVW[ n*3 ] = u; 01833 UVW[ n*3+1 ] = v; 01834 UVW[ n*3+2 ] = w; 01835 fgets( line, 256, fileIn ); 01836 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01837 } 01838 } 01839 //----------------------------------------------------------------------------- 01840 // Process MESH_TVERTLIST 01841 template <typename T> 01842 void Read3dsMaxASE<T>::ProcessNodeMESH_TVERTLIST ( 01843 char *line, OpenGL::HalfEdgeModel<T> * const prModel, T * UVW ) 01844 { 01845 #ifdef TAPs_DEBUG_MODE 01846 std::cout << "Processing Node MESH_TVERTLIST\n"; 01847 #endif//TAPs_DEBUG_MODE 01848 01849 //------------------------------------------------------------------- 01850 // Example: 01851 // *MESH_TVERTLIST { 01852 // *MESH_TVERT 0 0.000000 0.000000 0.000000 01853 // *MESH_TVERT 1 1.000000 0.000000 0.000000 01854 // *MESH_TVERT 2 0.000000 1.000000 0.000000 01855 // ... 01856 // } 01857 //------------------------------------------------------------------- 01858 char node[128]; 01859 int n; 01860 float u, v, w; 01861 fgets( line, 256, fileIn ); 01862 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01863 while ( node[0] != '}' ) { 01864 UVW[ n*3 ] = u; 01865 UVW[ n*3+1 ] = v; 01866 UVW[ n*3+2 ] = w; 01867 fgets( line, 256, fileIn ); 01868 sscanf( line, "%s %d %g %g %g", node, &n, &u, &v, &w ); 01869 } 01870 } 01871 //----------------------------------------------------------------------------- 01872 //============================================================================= 01873 //----------------------------------------------------------------------------- 01874 // Process MESH_TFACELIST 01875 template <typename T> 01876 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST ( 01877 char *line, OpenGL::PolygonalModel<T> * const prModel, T * UVW ) 01878 { 01879 #ifdef TAPs_DEBUG_MODE 01880 std::cout << "Processing Node MESH_TFACELIST\n"; 01881 #endif//TAPs_DEBUG_MODE 01882 01883 //------------------------------------------------------------------- 01884 // Example: 01885 // *MESH_TFACELIST { 01886 // *MESH_TFACE 0 9 11 10 01887 // *MESH_TFACE 1 10 8 9 01888 // *MESH_TFACE 2 8 9 11 01889 // ... 01890 // } 01891 //------------------------------------------------------------------- 01892 // textured coordinates are u, v, and w 01893 // use only u and v (or s and t) for 2-D mapping, ignore w 01894 //------------------------------------------------------------------- 01895 char node[128]; 01896 int n, v0, v1, v2; 01897 fgets( line, 256, fileIn ); 01898 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01899 while ( node[0] != '}' ) { 01900 prModel->GetFaceList()[n].SetNoTexCoords( 3 ); 01901 prModel->GetFaceList()[n].SetTexCoordNo( 0, UVW[v0*3], UVW[v0*3+1] ); 01902 prModel->GetFaceList()[n].SetTexCoordNo( 1, UVW[v1*3], UVW[v1*3+1] ); 01903 prModel->GetFaceList()[n].SetTexCoordNo( 2, UVW[v2*3], UVW[v2*3+1] ); 01904 01905 #ifdef TAPs_DEBUG_MODE 01906 //std::cout << "Face#" << n << "\t" << prModel->GetFaceList()[n] << "\n"; 01907 #endif//TAPs_DEBUG_MODE 01908 01909 fgets( line, 256, fileIn ); 01910 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01911 } 01912 } 01913 //----------------------------------------------------------------------------- 01914 // Process MESH_TFACELIST 01915 template <typename T> 01916 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST ( 01917 char *line, OpenGL::XPolygonalModel<T> * const prModel, T * UVW ) 01918 { 01919 #ifdef TAPs_DEBUG_MODE 01920 std::cout << "Processing Node MESH_TFACELIST\n"; 01921 #endif//TAPs_DEBUG_MODE 01922 01923 //------------------------------------------------------------------- 01924 // Example: 01925 // *MESH_TFACELIST { 01926 // *MESH_TFACE 0 9 11 10 01927 // *MESH_TFACE 1 10 8 9 01928 // *MESH_TFACE 2 8 9 11 01929 // ... 01930 // } 01931 //------------------------------------------------------------------- 01932 // textured coordinates are u, v, and w 01933 // use only u and v (or s and t) for 2-D mapping, ignore w 01934 //------------------------------------------------------------------- 01935 char node[128]; 01936 int n, v0, v1, v2; 01937 fgets( line, 256, fileIn ); 01938 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01939 while ( node[0] != '}' ) { 01940 prModel->GetFaceList()[n].SetNoTexCoords( 3 ); 01941 prModel->GetFaceList()[n].SetTexCoordNo( 0, UVW[v0*3], UVW[v0*3+1] ); 01942 prModel->GetFaceList()[n].SetTexCoordNo( 1, UVW[v1*3], UVW[v1*3+1] ); 01943 prModel->GetFaceList()[n].SetTexCoordNo( 2, UVW[v2*3], UVW[v2*3+1] ); 01944 01945 #ifdef TAPs_DEBUG_MODE 01946 //std::cout << "Face#" << n << "\t" << prModel->GetFaceList()[n] << "\n"; 01947 #endif//TAPs_DEBUG_MODE 01948 01949 fgets( line, 256, fileIn ); 01950 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01951 } 01952 } 01953 //----------------------------------------------------------------------------- 01954 // Process MESH_TFACELIST 01955 template <typename T> 01956 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST ( 01957 char *line, OpenGL::HalfEdgeModel<T> * const prModel, T * UVW ) 01958 { 01959 #ifdef TAPs_DEBUG_MODE 01960 std::cout << "Processing Node MESH_TFACELIST\n"; 01961 #endif//TAPs_DEBUG_MODE 01962 01963 //------------------------------------------------------------------- 01964 // Example: 01965 // *MESH_TFACELIST { 01966 // *MESH_TFACE 0 9 11 10 01967 // *MESH_TFACE 1 10 8 9 01968 // *MESH_TFACE 2 8 9 11 01969 // ... 01970 // } 01971 //------------------------------------------------------------------- 01972 // textured coordinates are u, v, and w 01973 // use only u and v (or s and t) for 2-D mapping, ignore w 01974 //------------------------------------------------------------------- 01975 char node[128]; 01976 int n, v0, v1, v2; 01977 fgets( line, 256, fileIn ); 01978 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01979 while ( node[0] != '}' ) { 01980 01981 // ??? 01982 01983 //prModel->GetFaceList()[n].SetNoTexCoords( 3 ); 01984 //prModel->GetFaceList()[n].SetTexCoordNo( 0, UVW[v0*3], UVW[v0*3+1] ); 01985 //prModel->GetFaceList()[n].SetTexCoordNo( 1, UVW[v1*3], UVW[v1*3+1] ); 01986 //prModel->GetFaceList()[n].SetTexCoordNo( 2, UVW[v2*3], UVW[v2*3+1] ); 01987 01988 #ifdef TAPs_DEBUG_MODE 01989 //std::cout << "Face#" << n << "\t" << prModel->GetFaceList()[n] << "\n"; 01990 #endif//TAPs_DEBUG_MODE 01991 01992 fgets( line, 256, fileIn ); 01993 sscanf( line, "%s %d %d %d %d", node, &n, &v0, &v1, &v2 ); 01994 } 01995 } 01996 //----------------------------------------------------------------------------- 01997 //============================================================================= 01998 #endif 01999 02000 02001 //----------------------------------------------------------------------------- 02002 // Process MESH_NORMALS 02003 template <typename T> 02004 void Read3dsMaxASE<T>::ProcessNodeMESH_NORMALS ( 02005 char *line, OpenGL::PolygonalModel<T> * const prModel ) 02006 { 02007 //------------------------------------------------------------------- 02008 #ifdef TAPs_DEBUG_MODE 02009 std::cout << "Processing Node MESH_NORMALS\n"; 02010 #endif//TAPs_DEBUG_MODE 02011 //------------------------------------------------------------------- 02012 char node[128]; 02013 int idx; 02014 float x, y, z; 02015 do { 02016 fgets( line, 256, fileIn ); 02017 sscanf( line, "%s", node ); 02018 if ( !strncmp( node, "*MESH_VERTEXNORMAL", strlen("*MESH_VERTEXNORMAL") ) && ( strlen(node) == strlen("*MESH_VERTEXNORMAL") ) ) { 02019 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02020 02021 #ifdef TAPs_DEBUG_MODE 02022 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02023 #endif//TAPs_DEBUG_MODE 02024 02025 prModel->GetVertexList()[idx].SetNormal( x, y, z ); 02026 } 02027 else if ( !strncmp( node, "*MESH_FACENORMAL", strlen("*MESH_FACENORMAL") ) && ( strlen(node) == strlen("*MESH_FACENORMAL") ) ) { 02028 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02029 02030 #ifdef TAPs_DEBUG_MODE 02031 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02032 #endif//TAPs_DEBUG_MODE 02033 02034 prModel->GetFaceList()[idx].SetNormal( x, y, z ); 02035 } 02036 } while ( node[0] != '}' ); 02037 } 02038 //----------------------------------------------------------------------------- 02039 // Process MESH_NORMALS 02040 template <typename T> 02041 void Read3dsMaxASE<T>::ProcessNodeMESH_NORMALS ( 02042 char *line, OpenGL::XPolygonalModel<T> * const prModel ) 02043 { 02044 //--------------------------------------------------------------- 02045 #ifdef TAPs_DEBUG_MODE 02046 std::cout << "Processing Node MESH_NORMALS\n"; 02047 #endif//TAPs_DEBUG_MODE 02048 //--------------------------------------------------------------- 02049 char node[128]; 02050 int idx; 02051 float x, y, z; 02052 do { 02053 fgets( line, 256, fileIn ); 02054 sscanf( line, "%s", node ); 02055 if ( !strncmp( node, "*MESH_VERTEXNORMAL", strlen("*MESH_VERTEXNORMAL") ) && ( strlen(node) == strlen("*MESH_VERTEXNORMAL") ) ) { 02056 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02057 02058 #ifdef TAPs_DEBUG_MODE 02059 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02060 #endif//TAPs_DEBUG_MODE 02061 02062 prModel->GetVertexList()[idx].SetNormal( x, y, z ); 02063 } 02064 else if ( !strncmp( node, "*MESH_FACENORMAL", strlen("*MESH_FACENORMAL") ) && ( strlen(node) == strlen("*MESH_FACENORMAL") ) ) { 02065 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02066 02067 #ifdef TAPs_DEBUG_MODE 02068 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02069 #endif//TAPs_DEBUG_MODE 02070 02071 prModel->GetFaceList()[idx].SetNormal( x, y, z ); 02072 } 02073 } while ( node[0] != '}' ); 02074 } 02075 //----------------------------------------------------------------------------- 02076 // Process MESH_NORMALS 02077 template <typename T> 02078 void Read3dsMaxASE<T>::ProcessNodeMESH_NORMALS ( 02079 char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 02080 { 02081 //--------------------------------------------------------------- 02082 #ifdef TAPs_DEBUG_MODE 02083 std::cout << "Processing Node MESH_NORMALS\n"; 02084 #endif//TAPs_DEBUG_MODE 02085 //--------------------------------------------------------------- 02086 char node[128]; 02087 int idx; 02088 float x, y, z; 02089 HEFace<T> *facePtr = prModel->GetFaceList()->Head(); 02090 HEHalfEdge<T> *halfEdgePtr = facePtr->IncidentHalfEdge(); 02091 int countNumVertices = 0; 02092 02093 fgets( line, 256, fileIn ); 02094 sscanf( line, "%s", node ); 02095 while ( node[0] != '}' && facePtr != NULL ) { 02096 if ( !strncmp( node, "*MESH_VERTEXNORMAL", strlen("*MESH_VERTEXNORMAL") ) && ( strlen(node) == strlen("*MESH_VERTEXNORMAL") ) ) { 02097 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02098 02099 #ifdef TAPs_DEBUG_MODE 02100 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02101 #endif//TAPs_DEBUG_MODE 02102 02103 halfEdgePtr->Vertex()->SetNormal( x, y, z ); 02104 halfEdgePtr = halfEdgePtr->Next(); 02105 ++countNumVertices; 02106 } 02107 else if ( !strncmp( node, "*MESH_FACENORMAL", strlen("*MESH_FACENORMAL") ) && ( strlen(node) == strlen("*MESH_FACENORMAL") ) ) { 02108 sscanf( line, "%s %d %g %g %g", node, &idx, &x, &y, &z ); 02109 02110 #ifdef TAPs_DEBUG_MODE 02111 //std::cout << idx << "\t" << x << "\t" << y << "\t" << z << "\n"; 02112 #endif//TAPs_DEBUG_MODE 02113 02114 facePtr->SetNormal( x, y, z ); 02115 } 02116 02117 fgets( line, 256, fileIn ); 02118 sscanf( line, "%s", node ); 02119 if ( countNumVertices == 3 ) { 02120 countNumVertices = 0; 02121 facePtr = facePtr->Next(); 02122 if ( facePtr != NULL ) halfEdgePtr = facePtr->IncidentHalfEdge(); 02123 } 02124 } 02125 } 02126 //----------------------------------------------------------------------------- 02127 template <typename T> 02128 void Read3dsMaxASE<T>::ClearMaterialList () 02129 { 02130 for ( int i = 0; i < static_cast<int>( materialList.size() ); ++i ) { 02131 for ( int j = 0; j < static_cast<int>( materialList[i].size() ); ++j ) { 02132 delete materialList[i][j]; 02133 materialList[i][j] = NULL; 02134 } 02135 } 02136 materialList.clear(); 02137 } 02138 //----------------------------------------------------------------------------- 02139 template <typename T> 02140 void Read3dsMaxASE<T>::ClearMaterials () 02141 { 02142 for ( int i = 0; i < static_cast<int>( materials.size() ); ++i ) { 02143 delete materials[i]; 02144 materials[i] = NULL; 02145 } 02146 materials.clear(); 02147 } 02148 //----------------------------------------------------------------------------- 02149 template <typename T> 02150 void Read3dsMaxASE<T>::SetMaterial ( int id, OpenGL::OpenGLModel<T> * prModel ) 02151 { 02153 #ifdef TAPs_SUPPORT_ASE_FORMAT 02154 02155 02156 /* 02157 // Add the set of materials to the material list 02158 if ( true ) { 02159 std::cout << "START LIST in SetMaterial: \n"; 02160 for ( int i = 0; i < materialList.size(); ++i ) { 02161 std::cout << "I: " << i << "\n"; 02162 for ( int j = 0; j < materialList[i].size(); ++j ) { 02163 std::cout << "J: " << j << "\n"; 02164 std::cout << *materialList[i][j] << "\n"; 02165 } 02166 } 02167 std::cout << "END LIST in SetMaterial: \n"; 02168 } 02169 //*/ 02170 02171 //std::cout << "id: " << id << std::endl; 02172 //std::cout << "materialList size: " << materialList.size() << std::endl; 02173 if ( materialList.size() == 0 ) { 02174 std::cout << "materialList size is too low: " << static_cast<int>( materialList.size() ) << std::endl; 02175 return; 02176 } 02177 02178 //return; 02179 02180 //std::cout << "MAT SIZE: " << materialList[id].size() << std::endl; 02181 for ( int i = 0; i < static_cast<int>( materialList[id].size()-1 ); ++i ) { 02182 prModel->submaterials.push_back( new OpenGL::Material( *materialList[id][i] ) ); 02183 //std::cout << "Submat# " << i << std::endl; 02184 //std::cout << prModel->submaterials[i] << std::endl; 02185 } 02186 #endif//TAPs_SUPPORT_ASE_FORMAT 02187 02188 // Main Material 02189 prModel->material = *(materialList[id][materialList[id].size()-1]); 02190 //std::cout << "Mainmat" << std::endl; 02191 //std::cout << prModel->material << std::endl; 02192 } 02193 //----------------------------------------------------------------------------- 02194 02195 02196 //============================================================================= 02197 #ifdef TAPs_SUPPORT_ASE_FORMAT 02198 //----------------------------------------------------------------------------- 02199 02200 //=================================================================== 02201 #ifdef TAPs_ENABLE_FACE_VERTEX_COLOR 02202 //------------------------------------------------------------------- 02203 template <typename T> 02204 void Read3dsMaxASE<T>::ProcessNodeMESH_NUMCVERTEX( char *line ) 02205 { 02206 //----------------------------------------------------- 02207 // Example: 02208 // *MESH_NUMCVERTEX 7 02209 char node[128]; 02210 sscanf( line, "%s %d", node, &m_iNumVertexColors ); 02211 02212 #ifdef TAPs_DEBUG_MODE 02213 std::cout << "Number of Vertex Colors is " << m_iNumVertexColors << ".\n"; 02214 #endif//TAPs_DEBUG_MODE 02215 } 02216 //--------------------------------------------------------- 02217 template <typename T> 02218 void Read3dsMaxASE<T>::ProcessNodeMESH_CVERTLIST( char *line, OpenGL::MeshModel<T> * const prModel ) 02219 { 02220 #ifdef TAPs_DEBUG_MODE 02221 std::cout << "Processing Node MESH_CVERTLIST\n"; 02222 #endif//TAPs_DEBUG_MODE 02223 02224 //----------------------------------------------------- 02225 // Example: 02226 // *MESH_CVERTLIST { 02227 // *MESH_VERTCOL 0 1.0000 1.0000 1.0000 02228 // *MESH_VERTCOL 1 1.0000 1.0000 1.0000 02229 // *MESH_VERTCOL 2 1.0000 1.0000 1.0000 02230 // ... 02231 // } 02232 //----------------------------------------------------- 02233 02234 // Set number of face's vertex colors 02235 prModel->SetNumVetexColors( m_iNumVertexColors, 3 ); // # vertex colors and its dimension 02236 02237 char node[128]; 02238 int n; 02239 float r, g, b; 02240 fgets( line, 256, fileIn ); 02241 sscanf( line, "%s %d %g %g %g", node, &n, &r, &g, &b ); 02242 while ( node[0] != '}' ) { 02243 prModel->SetVertexColor( n, &r, &g, &b ); 02244 02245 #ifdef TAPs_DEBUG_MODE 02246 prModel->GetVertexColor( n, &r, &g, &b ); 02247 std::cout << "Vertex Color#" << n << "\t" << r << ", " << g << ", " << b << "\n"; 02248 #endif//TAPs_DEBUG_MODE 02249 02250 fgets( line, 256, fileIn ); 02251 sscanf( line, "%s %d %g %g %g", node, &n, &r, &g, &b ); 02252 } 02253 } 02254 //------------------------------------------------------------------- 02255 02256 //------------------------------------------------------------------- 02257 template <typename T> 02258 void Read3dsMaxASE<T>::ProcessNodeMESH_NUMCVFACES( char *line ) 02259 { 02260 //----------------------------------------------------- 02261 // Example: 02262 // *MESH_NUMCVFACES 7 02263 char node[128]; 02264 sscanf( line, "%s %d", node, &m_iNumFaceVertexColors ); 02265 02266 #ifdef TAPs_DEBUG_MODE 02267 std::cout << "Number of Face's Vertex Colors is " << m_iNumFaceVertexColors << ".\n"; 02268 #endif//TAPs_DEBUG_MODE 02269 } 02270 //--------------------------------------------------------- 02271 template <typename T> 02272 void Read3dsMaxASE<T>::ProcessNodeMESH_CFACELIST( char *line, OpenGL::PolygonalModel<T> * const prModel ) 02273 { 02274 #ifdef TAPs_DEBUG_MODE 02275 std::cout << "Processing Node MESH_CFACELIST\n"; 02276 #endif//TAPs_DEBUG_MODE 02277 02278 //----------------------------------------------------- 02279 // Example: 02280 // *MESH_CFACELIST { 02281 // *MESH_CFACE 0 0 1 2 02282 // *MESH_CFACE 1 0 2 3 02283 // *MESH_CFACE 2 0 3 4 02284 // ... 02285 // } 02286 //----------------------------------------------------- 02287 02288 char node[128]; 02289 int n; 02290 int vc0, vc1, vc2; 02291 fgets( line, 256, fileIn ); 02292 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02293 while ( node[0] != '}' ) { 02294 prModel->GetFaceList()[n].SetVertexColorNo( 0, vc0 ); 02295 prModel->GetFaceList()[n].SetVertexColorNo( 1, vc1 ); 02296 prModel->GetFaceList()[n].SetVertexColorNo( 2, vc2 ); 02297 02298 #ifdef TAPs_DEBUG_MODE 02299 vc0 = prModel->GetFaceList()[n].GetVertexColorNo( 0 ); 02300 vc1 = prModel->GetFaceList()[n].GetVertexColorNo( 1 ); 02301 vc2 = prModel->GetFaceList()[n].GetVertexColorNo( 2 ); 02302 std::cout << "Face's Vertex Color#" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02303 #endif//TAPs_DEBUG_MODE 02304 02305 fgets( line, 256, fileIn ); 02306 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02307 } 02308 } 02309 //------------------------------------------------------------------- 02310 template <typename T> 02311 void Read3dsMaxASE<T>::ProcessNodeMESH_CFACELIST( char *line, OpenGL::XPolygonalModel<T> * const prModel ) 02312 { 02313 #ifdef TAPs_DEBUG_MODE 02314 std::cout << "Processing Node MESH_CFACELIST\n"; 02315 #endif//TAPs_DEBUG_MODE 02316 02317 //----------------------------------------------------- 02318 // Example: 02319 // *MESH_CFACELIST { 02320 // *MESH_CFACE 0 0 1 2 02321 // *MESH_CFACE 1 0 2 3 02322 // *MESH_CFACE 2 0 3 4 02323 // ... 02324 // } 02325 //----------------------------------------------------- 02326 02327 char node[128]; 02328 int n; 02329 int vc0, vc1, vc2; 02330 fgets( line, 256, fileIn ); 02331 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02332 while ( node[0] != '}' ) { 02333 prModel->GetFaceList()[n].SetVertexColorNo( 0, vc0 ); 02334 prModel->GetFaceList()[n].SetVertexColorNo( 1, vc1 ); 02335 prModel->GetFaceList()[n].SetVertexColorNo( 2, vc2 ); 02336 02337 #ifdef TAPs_DEBUG_MODE 02338 vc0 = prModel->GetFaceList()[n].GetVertexColorNo( 0 ); 02339 vc1 = prModel->GetFaceList()[n].GetVertexColorNo( 1 ); 02340 vc2 = prModel->GetFaceList()[n].GetVertexColorNo( 2 ); 02341 std::cout << "Face's Vertex Color#" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02342 #endif//TAPs_DEBUG_MODE 02343 02344 fgets( line, 256, fileIn ); 02345 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02346 } 02347 } 02348 //------------------------------------------------------------------- 02349 template <typename T> 02350 void Read3dsMaxASE<T>::ProcessNodeMESH_CFACELIST( char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 02351 { 02352 #ifdef TAPs_DEBUG_MODE 02353 std::cout << "Processing Node MESH_CFACELIST\n"; 02354 #endif//TAPs_DEBUG_MODE 02355 02356 //----------------------------------------------------- 02357 // Example: 02358 // *MESH_CFACELIST { 02359 // *MESH_CFACE 0 0 1 2 02360 // *MESH_CFACE 1 0 2 3 02361 // *MESH_CFACE 2 0 3 4 02362 // ... 02363 // } 02364 //----------------------------------------------------- 02365 02366 char node[128]; 02367 int n; 02368 int vc0, vc1, vc2; 02369 fgets( line, 256, fileIn ); 02370 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02371 HEFace<T> *facePtr = prModel->GetFaceList()->Head(); 02372 while ( node[0] != '}' && facePtr != NULL ) { 02373 facePtr->InitVertexColorList( 3 ); // 3 vertices, since it is a triangle 02374 facePtr->SetVertexColorNo( 0, vc0 ); 02375 facePtr->SetVertexColorNo( 1, vc1 ); 02376 facePtr->SetVertexColorNo( 2, vc2 ); 02377 02378 #ifdef TAPs_DEBUG_MODE 02379 vc0 = facePtr->GetVertexColorNo( 0 ); 02380 vc1 = facePtr->GetVertexColorNo( 1 ); 02381 vc2 = facePtr->GetVertexColorNo( 2 ); 02382 std::cout << "Face's Vertex Color#" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02383 #endif//TAPs_DEBUG_MODE 02384 02385 fgets( line, 256, fileIn ); 02386 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02387 facePtr = facePtr->Next(); 02388 } 02389 } 02390 //------------------------------------------------------------------- 02391 #endif//TAPs_ENABLE_FACE_VERTEX_COLOR 02392 //=================================================================== 02393 02394 //=================================================================== 02395 #ifdef TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 02396 //------------------------------------------------------------------- 02397 template <typename T> 02398 void Read3dsMaxASE<T>::ProcessNodeMESH_NUMTVERTEX( char *line ) 02399 { 02400 //----------------------------------------------------- 02401 // Example: 02402 // *MESH_NUMTVERTEX 7 02403 char node[128]; 02404 sscanf( line, "%s %d", node, &m_iNumVertexTextures ); 02405 02406 #ifdef TAPs_DEBUG_MODE 02407 std::cout << "Number of Vertex Texture Coordinates is " << m_iNumVertexTextures << ".\n"; 02408 #endif//TAPs_DEBUG_MODE 02409 } 02410 //--------------------------------------------------------- 02411 template <typename T> 02412 void Read3dsMaxASE<T>::ProcessNodeMESH_TVERTLIST( char *line, OpenGL::MeshModel<T> * const prModel ) 02413 { 02414 #ifdef TAPs_DEBUG_MODE 02415 std::cout << "Processing Node MESH_TVERTLIST\n"; 02416 #endif//TAPs_DEBUG_MODE 02417 02418 //----------------------------------------------------- 02419 // Example: 02420 // *MESH_TVERTLIST { 02421 // *MESH_TVERT 0 0.4000 1.0000 22.7888 02422 // *MESH_TVERT 1 0.5000 0.6476 22.7888 02423 // *MESH_TVERT 2 0.7000 0.6476 22.7888 02424 // ... 02425 // } 02426 //----------------------------------------------------- 02427 02428 // Set number of face's vertex texture coordinates 02429 prModel->SetNumVetexTextures( m_iNumVertexTextures, 3 ); // # vertex texture coordinates and its dimension 02430 02431 char node[128]; 02432 int n; 02433 float s, t, r; 02434 fgets( line, 256, fileIn ); 02435 sscanf( line, "%s %d %g %g %g", node, &n, &s, &t, &r ); 02436 while ( node[0] != '}' ) { 02437 prModel->SetVertexTexture( n, &s, &t, &r ); 02438 02439 #ifdef TAPs_DEBUG_MODE 02440 prModel->GetVertexTexture( n, &s, &t, &r ); 02441 std::cout << "Vertex Texture Coordinates #" << n << "\t" << s << ", " << t << ", " << r << std::endl;//"\n"; 02442 #endif//TAPs_DEBUG_MODE 02443 02444 fgets( line, 256, fileIn ); 02445 sscanf( line, "%s %d %g %g %g", node, &n, &s, &t, &r ); 02446 } 02447 } 02448 //------------------------------------------------------------------- 02449 02450 //------------------------------------------------------------------- 02451 template <typename T> 02452 void Read3dsMaxASE<T>::ProcessNodeMESH_NUMTVFACES( char *line ) 02453 { 02454 //----------------------------------------------------- 02455 // Example: 02456 // *MESH_NUMTVFACES 7 02457 char node[128]; 02458 sscanf( line, "%s %d", node, &m_iNumFaceVertexTextures ); 02459 02460 #ifdef TAPs_DEBUG_MODE 02461 std::cout << "Number of Face's Vertex Texture Coordinates is " << m_iNumFaceVertexTextures << ".\n"; 02462 #endif//TAPs_DEBUG_MODE 02463 } 02464 //--------------------------------------------------------- 02465 template <typename T> 02466 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST( char *line, OpenGL::PolygonalModel<T> * const prModel ) 02467 { 02468 #ifdef TAPs_DEBUG_MODE 02469 std::cout << "Processing Node MESH_TFACELIST\n"; 02470 #endif//TAPs_DEBUG_MODE 02471 02472 //----------------------------------------------------- 02473 // Example: 02474 // *MESH_TFACELIST { 02475 // *MESH_TFACE 0 12 1 2 02476 // *MESH_TFACE 1 13 2 3 02477 // *MESH_TFACE 2 14 15 4 02478 // ... 02479 // } 02480 //----------------------------------------------------- 02481 02482 char node[128]; 02483 int n; 02484 int vc0, vc1, vc2; 02485 fgets( line, 256, fileIn ); 02486 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02487 while ( node[0] != '}' ) { 02488 prModel->GetFaceList()[n].SetVertexTextureNo( 0, vc0 ); 02489 prModel->GetFaceList()[n].SetVertexTextureNo( 1, vc1 ); 02490 prModel->GetFaceList()[n].SetVertexTextureNo( 2, vc2 ); 02491 02492 #ifdef TAPs_DEBUG_MODE 02493 vc0 = prModel->GetFaceList()[n].GetVertexTextureNo( 0 ); 02494 vc1 = prModel->GetFaceList()[n].GetVertexTextureNo( 1 ); 02495 vc2 = prModel->GetFaceList()[n].GetVertexTextureNo( 2 ); 02496 std::cout << "Face's Vertex Texture Coordinates #" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02497 #endif//TAPs_DEBUG_MODE 02498 02499 fgets( line, 256, fileIn ); 02500 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02501 } 02502 } 02503 //------------------------------------------------------------------- 02504 template <typename T> 02505 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST( char *line, OpenGL::XPolygonalModel<T> * const prModel ) 02506 { 02507 #ifdef TAPs_DEBUG_MODE 02508 std::cout << "Processing Node MESH_TFACELIST\n"; 02509 #endif//TAPs_DEBUG_MODE 02510 02511 //----------------------------------------------------- 02512 // Example: 02513 // *MESH_TFACELIST { 02514 // *MESH_TFACE 0 12 1 2 02515 // *MESH_TFACE 1 13 2 3 02516 // *MESH_TFACE 2 14 15 4 02517 // ... 02518 // } 02519 //----------------------------------------------------- 02520 02521 char node[128]; 02522 int n; 02523 int vc0, vc1, vc2; 02524 fgets( line, 256, fileIn ); 02525 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02526 while ( node[0] != '}' ) { 02527 prModel->GetFaceList()[n].SetVertexTextureNo( 0, vc0 ); 02528 prModel->GetFaceList()[n].SetVertexTextureNo( 1, vc1 ); 02529 prModel->GetFaceList()[n].SetVertexTextureNo( 2, vc2 ); 02530 02531 #ifdef TAPs_DEBUG_MODE 02532 vc0 = prModel->GetFaceList()[n].GetVertexTextureNo( 0 ); 02533 vc1 = prModel->GetFaceList()[n].GetVertexTextureNo( 1 ); 02534 vc2 = prModel->GetFaceList()[n].GetVertexTextureNo( 2 ); 02535 std::cout << "Face's Vertex Color#" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02536 #endif//TAPs_DEBUG_MODE 02537 02538 fgets( line, 256, fileIn ); 02539 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02540 } 02541 } 02542 //------------------------------------------------------------------- 02543 template <typename T> 02544 void Read3dsMaxASE<T>::ProcessNodeMESH_TFACELIST( char *line, OpenGL::HalfEdgeModel<T> * const prModel ) 02545 { 02546 #ifdef TAPs_DEBUG_MODE 02547 std::cout << "Processing Node MESH_TFACELIST\n"; 02548 #endif//TAPs_DEBUG_MODE 02549 02550 //----------------------------------------------------- 02551 // Example: 02552 // *MESH_TFACELIST { 02553 // *MESH_TFACE 0 12 1 2 02554 // *MESH_TFACE 1 13 2 3 02555 // *MESH_TFACE 2 14 15 4 02556 // ... 02557 // } 02558 //----------------------------------------------------- 02559 02560 char node[128]; 02561 int n; 02562 int vc0, vc1, vc2; 02563 fgets( line, 256, fileIn ); 02564 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02565 HEFace<T> *facePtr = prModel->GetFaceList()->Head(); 02566 while ( node[0] != '}' && facePtr != NULL ) { 02567 facePtr->InitVertexTextureList( 3 ); // 3 vertices, since it is a triangle 02568 facePtr->SetVertexTextureNo( 0, vc0 ); 02569 facePtr->SetVertexTextureNo( 1, vc1 ); 02570 facePtr->SetVertexTextureNo( 2, vc2 ); 02571 02572 #ifdef TAPs_DEBUG_MODE 02573 vc0 = facePtr->GetVertexTextureNo( 0 ); 02574 vc1 = facePtr->GetVertexTextureNo( 1 ); 02575 vc2 = facePtr->GetVertexTextureNo( 2 ); 02576 std::cout << "Face's Vertex Texture Coordinates #" << n << "\t" << vc0 << ", " << vc1 << ", " << vc2 << "\n"; 02577 #endif//TAPs_DEBUG_MODE 02578 02579 fgets( line, 256, fileIn ); 02580 sscanf( line, "%s %d %d %d %d", node, &n, &vc0, &vc1, &vc2 ); 02581 facePtr = facePtr->Next(); 02582 } 02583 } 02584 //------------------------------------------------------------------- 02585 #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES 02586 //=================================================================== 02587 02588 //----------------------------------------------------------------------------- 02589 #endif//TAPs_SUPPORT_ASE_FORMAT 02590 //============================================================================= 02591 02592 //============================================================================= 02593 END_NAMESPACE_TAPs 02594 //----------------------------------------------------------------------------- 02595 //34567890123456789012345678901234567890123456789012345678901234567890123456789 02596 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
1.7.4 
