Category

Development Platform
Home > SourceCode/Document > Graph program > OpenGL program > View Code
ParserVrml.cpp
Package: display_list.zip　[view]
Upload User: hcfgz168
Upload Date: 2011-09-11
Package Size: 116k
Code Size: 22k
Category:

OpenGL program

Development Platform:

WINDOWS

ParserVrml.cpp：Code Content
  1. //********************************************
  2. // ParserVrml.cpp
  3. // class CParserVrml
  4. //********************************************
  5. // pierre.alliez@cnet.francetelecom.fr
  6. // Created : 02/04/98
  7. // Modified : 02/04/98
  8. //********************************************
  10. #include "stdafx.h"
  11. #include "Base3d.h"
  12. #include "ParserVrml.h"
  14. //********************************************
  15. // Constructor
  16. //********************************************
  17. CParserVrml::CParserVrml()
  18. {
  19. m_pBuffer = NULL;
  20. m_pBufferWord[0] = '';
  21. m_pBufferLine[0] = '';
  22. m_IndexBuffer = 0;
  23. }
  25. //********************************************
  26. // Destructor
  27. //********************************************
  28. CParserVrml::~CParserVrml()
  29. {
  30. Free();
  31. }
  33. //********************************************
  34. // Destructor
  35. //********************************************
  36. void CParserVrml::Free(void)
  37. {
  38. if(m_pBuffer != NULL)
  39. delete [] m_pBuffer;
  40. m_IndexBuffer = 0;
  41. }
  43. //********************************************
  44. // Run
  45. //********************************************
  46. int CParserVrml::Run(char *filename,
  47.  CSceneGraph3d *pSceneGraph)
  48. {
  49. TRACE("n");
  50. TRACE("Start vrml parsern");
  51. TRACE("  file : %sn",filename);
  53. // Free
  54. TRACE("  free...");
  55. Free();
  56. TRACE("okn");
  58. // ReadFile
  59. if(!ReadFile(filename))
  60. return 0;
  62. // CheckVersion
  63. if(!CheckVersion())
  64. return 0;
  66. CountDef();
  67. CountMesh();
  69. while(OffsetToStringBeginLine("DEF"))
  70. ReadMesh(pSceneGraph);
  72. TRACE("End vrml parsern");
  73. TRACE("n");
  74. return 1;
  75. }
  78. //********************************************
  79. // ReadFile
  80. //********************************************
  81. int CParserVrml::ReadFile(char *filename)
  82. {
  83. m_FileName = filename;
  85. CFile file;
  86. CFileException ex;
  88. // Opening
  89. TRACE("  opening...");
  90. if(!file.Open(filename, CFile::modeRead | CFile::typeBinary,&ex))
  91. {
  92. #ifdef _DEBUG
  93.   afxDump << "File could not be opened " << ex.m_cause << "n";
  94. #endif
  95. TRACE("unable to open file for readingn");
  96. return 0;
  97. }
  98. TRACE("okn");
  100. // Size file
  101. m_SizeFile = file.GetLength();
  102. TRACE("  length : %d bytesn",m_SizeFile);
  104. // Alloc
  105. TRACE("  alloc...");
  106. m_pBuffer = new char[m_SizeFile];
  107. if(m_pBuffer == NULL)
  108. {
  109. TRACE("insuffisant memoryn");
  110. return 0;
  111. }
  112. TRACE("okn");
  114. // Reading
  115. TRACE("  reading...");
  116. TRY
  117. {
  118. file.Read(m_pBuffer,m_SizeFile);
  119. }
  120. CATCH(CFileException, e)
  121. {
  122. #ifdef _DEBUG
  123. afxDump << "Error during reading " << e->m_cause << "n";
  124. #endif
  125. TRACE("error during readingn");
  126. file.Close();
  127. return 0;
  128. }
  129. END_CATCH
  130. TRACE("okn");
  132. // Closing
  133. file.Close();
  135. return 1;
  136. }
  138. //********************************************
  139. // ReadLine
  140. // eol : 'n'
  141. // eos : ''
  142. //********************************************
  143. int CParserVrml::ReadLine()
  144. {
  145. m_pBufferLine[0] = '';
  146. int i=0;
  147. do
  148. m_pBufferLine[i++] = m_pBuffer[m_IndexBuffer++];
  149. while(m_pBuffer[m_IndexBuffer-1] != 'n' && 
  150.     i < MAX_LINE_VRML &&
  151. m_IndexBuffer < m_SizeFile);
  153. m_pBufferLine[i-1] = '';
  155. //TRACE("  line : %sn",m_pBufferLine);
  157. return 1;
  158. }
  161. //********************************************
  162. // ReadLine
  163. // eol : 'n'
  164. // eos : ''
  165. //********************************************
  166. int CParserVrml::ReadWord()
  167. {
  168. m_pBufferWord[0] = '';
  169. int i=0;
  171. // Jump to next valid character
  172. while((m_pBuffer[m_IndexBuffer] == 'n' || 
  173.      m_pBuffer[m_IndexBuffer] == 't' || 
  174.      m_pBuffer[m_IndexBuffer] == 'r' || 
  175.      m_pBuffer[m_IndexBuffer] == ' ') &&
  176.  m_IndexBuffer < m_SizeFile)
  177. m_IndexBuffer++;
  179. // Check eof
  180. if(m_IndexBuffer >= m_SizeFile)
  181. return 0;
  183. do
  184. m_pBufferWord[i++] = m_pBuffer[m_IndexBuffer++];
  185. while(m_pBuffer[m_IndexBuffer-1] != 'n' && 
  186.     m_pBuffer[m_IndexBuffer-1] != 't' && 
  187.     m_pBuffer[m_IndexBuffer-1] != 'r' && 
  188.     m_pBuffer[m_IndexBuffer-1] != ' ' && 
  189.     i < MAX_WORD_VRML &&
  190. m_IndexBuffer < m_SizeFile);
  192. m_pBufferWord[i-1] = '';
  194. //TRACE("  word : %sn",m_pBufferWord);
  196. return 1;
  197. }
  202. //********************************************
  203. // CheckVersion
  204. //********************************************
  205. int CParserVrml::CheckVersion()
  206. {
  207. ReadLine();
  208. TRACE("  check version (vrml 2.0)...");
  209. if(strstr(m_pBufferLine,"#VRML V2.0") != NULL)
  210. {
  211. TRACE("okn");
  212. return 1;
  213. }
  214. TRACE("invalidn");
  215. return 0;
  216. }
  220. //********************************************
  221. // CountDef
  222. //********************************************
  223. void CParserVrml::CountDef(void)
  224. {
  225. int tmp = m_IndexBuffer;
  226. int nb = 0;
  227. while(m_IndexBuffer < m_SizeFile)
  228. {
  229. ReadLine();
  230. if(strncmp(m_pBufferLine,"DEF",3) == 0)
  231. nb++;
  232. }
  233. TRACE("  %d objectsn",nb);
  234. m_IndexBuffer = tmp;
  235. }
  237. //********************************************
  238. // CountMesh
  239. //********************************************
  240. int CParserVrml::CountMesh(void)
  241. {
  242. int tmp = m_IndexBuffer;
  243. int nb = 0;
  244. while(m_IndexBuffer < m_SizeFile)
  245. {
  246. ReadLine();
  247. if(strstr(m_pBufferLine,"IndexedFaceSet") != NULL)
  248. nb++;
  249. }
  250. TRACE("  %d meshesn",nb);
  251. m_IndexBuffer = tmp;
  252. return nb;
  253. }
  255. //********************************************
  256. // OffsetToStringBeginLine
  257. //********************************************
  258. int CParserVrml::OffsetToStringBeginLine(char *string)
  259. {
  260. while(m_IndexBuffer < m_SizeFile)
  261. {
  262. ReadLine();
  263. if(strncmp(m_pBufferLine,string,strlen(string)) == 0)
  264. {
  265. m_IndexBuffer -= strlen(m_pBufferLine)+1;
  266. /*
  267. TRACE("  begin line : %c%c%c%c%c...n",m_pBuffer[m_IndexBuffer],
  268.                                      m_pBuffer[m_IndexBuffer+1],
  269.                                      m_pBuffer[m_IndexBuffer+2],
  270.                                      m_pBuffer[m_IndexBuffer+3],
  271.      m_pBuffer[m_IndexBuffer+4]);*/
  272. return 1;
  273. }
  274. }
  275. return 0;
  276. }
  278. //********************************************
  279. // OffsetToString
  280. //********************************************
  281. int CParserVrml::OffsetToString(char *string)
  282. {
  283. while(m_IndexBuffer < m_SizeFile)
  284. {
  285. ReadLine();
  286. char *adr = strstr(m_pBufferLine,string);
  287. if(strstr(m_pBufferLine,string) != NULL)
  288. {
  289. m_IndexBuffer = m_IndexBuffer - strlen(m_pBufferLine) - 1 + (adr-m_pBufferLine);
  290. ASSERT(m_IndexBuffer >= 0);
  291. /*
  292. TRACE("  offset to string : %c%c%c%c%c... IndexBuffer : %dn",m_pBuffer[m_IndexBuffer],
  293.                                              m_pBuffer[m_IndexBuffer+1], 
  294.                                            m_pBuffer[m_IndexBuffer+2],
  295.                                            m_pBuffer[m_IndexBuffer+3],
  296.            m_pBuffer[m_IndexBuffer+4],m_IndexBuffer);*/
  298. return 1;
  299. }
  300. }
  301. return 0;
  302. }
  304. //********************************************
  305. // OffsetToString
  306. //********************************************
  307. int CParserVrml::OffsetToStringBefore(char *string,
  308. char *before)
  309. {
  310. while(m_IndexBuffer < m_SizeFile)
  311. {
  312. ReadLine();
  313. char *adr = strstr(m_pBufferLine,string);
  314. if(strstr(m_pBufferLine,before) != NULL)
  315. return 0;
  316. if(strstr(m_pBufferLine,string) != NULL)
  317. {
  318. m_IndexBuffer = m_IndexBuffer - strlen(m_pBufferLine) - 1 + (adr-m_pBufferLine);
  319. ASSERT(m_IndexBuffer >= 0);
  320. /*
  321. TRACE("  offset to string : %c%c%c%c%c... IndexBuffer : %dn",m_pBuffer[m_IndexBuffer],
  322.                                              m_pBuffer[m_IndexBuffer+1], 
  323.                                            m_pBuffer[m_IndexBuffer+2],
  324.                                            m_pBuffer[m_IndexBuffer+3],
  325.            m_pBuffer[m_IndexBuffer+4],m_IndexBuffer);*/
  327. return 1;
  328. }
  329. }
  330. return 0;
  331. }
  333. //********************************************
  334. // CheckMesh
  335. //********************************************
  336. int CParserVrml::CheckMesh()
  337. {
  338. // Find a possible mesh
  339. TRACE("  check mesh...");
  340. OffsetToStringBeginLine("DEF");
  341. int tmp = m_IndexBuffer;
  342. ReadLine();
  343. if(strstr(m_pBufferLine,"DEF") != NULL && 
  344.    strstr(m_pBufferLine,"Transform") != NULL)
  345. {
  346. m_IndexBuffer = tmp;
  347. if(OffsetToString("Transform") &&
  348.    OffsetToString("Material") &&
  349.    OffsetToString("IndexedFaceSet"))
  350. {
  351. m_IndexBuffer = tmp;
  352. TRACE("okn");
  353. return 1;
  354. }
  355. }
  356. //m_IndexBuffer = tmp;
  357. TRACE("not a meshn");
  358. return 0;
  359. }
  361. //********************************************
  362. // ReadMesh
  363. //********************************************
  364. int CParserVrml::ReadMesh(CSceneGraph3d *pSceneGraph)
  365. {
  366. // Check
  367. if(!CheckMesh())
  368. return 0;
  370. int tmp = m_IndexBuffer;
  371. ReadLine();
  372. ASSERT(strstr(m_pBufferLine,"DEF") != NULL);
  373. ASSERT(strstr(m_pBufferLine,"Transform") != NULL);
  374. // DEF [name] Transform {
  375. if(sscanf(m_pBufferLine,"DEF %s Transform",m_pBufferWord) != 1)
  376. {
  377. TRACE("  invalid syntax (BufferLine : %s BufferWord : %sn",m_pBufferLine,m_pBufferWord);
  378. return 0;
  379. }
  381. TRACE("  start reading mesh %sn",m_pBufferWord);
  383. m_IndexBuffer = tmp;
  385. int IndexTexture = -1;
  387. // Transform
  388. //********************************************
  389. // Syntax :
  390. // Transform {
  391.   // translation -360.7 1370 3471
  392.   // rotation 0.3236 -0.3236 -0.8891 -1.688
  393.   // scale -49.36 -49.36 -49.36
  394.   // scaleOrientation -0.689 0.4766 -0.546 -0.6007
  396. OffsetToString("Transform");
  397. ReadLine(); // Transform
  398. CTransform transform;
  399. transform.Clear();
  401. // Translation
  402. tmp = m_IndexBuffer;
  403. ReadLine();
  404. if(strstr(m_pBufferLine,"translation") != NULL)
  405. {
  406. // Come back
  407. m_IndexBuffer = tmp;
  408. // Jump after "translation"
  409. ReadWord(); 
  411. float x,y,z;
  412. ReadWord();
  413. int success = sscanf(m_pBufferWord,"%f",&x);
  414. ReadWord();
  415. success &= sscanf(m_pBufferWord,"%f",&y);
  416. ReadWord();
  417. success &= sscanf(m_pBufferWord,"%f",&z);
  418. if(success)
  419. {
  420. transform.SetTranslation(CVector3d(x,y,z));
  421. TRACE("    translation : %g %g %gn",x,y,z);
  422. }
  423. ReadLine();
  424. tmp = m_IndexBuffer;
  425. ReadLine();
  426. }
  428. // Rotation
  429. if(strstr(m_pBufferLine,"rotation") != NULL)
  430. {
  431. // Come back
  432. m_IndexBuffer = tmp;
  433. // Jump after "rotation"
  434. ReadWord(); 
  436. float x,y,z,value;
  437. ReadWord();
  438. int success = sscanf(m_pBufferWord,"%f",&x);
  439. ReadWord();
  440. success &= sscanf(m_pBufferWord,"%f",&y);
  441. ReadWord();
  442. success &= sscanf(m_pBufferWord,"%f",&z);
  443. ReadWord();
  444. success &= sscanf(m_pBufferWord,"%f",&value);
  445. if(success)
  446. {
  447. transform.SetRotation(CVector3d(x,y,z));
  448. transform.SetValueRotation(value/3.1415926f*180.0f);
  449. TRACE("    rotation : %g %g %g %gn",x,y,z,value);
  450. }
  451. ReadLine();
  452. tmp = m_IndexBuffer;
  453. ReadLine();
  454. }
  456. // Scale
  457. if(strstr(m_pBufferLine,"scale") != NULL)
  458. {
  459. // Come back
  460. m_IndexBuffer = tmp;
  461. // Jump after "scale"
  462. ReadWord(); 
  464. float x,y,z;
  465. ReadWord();
  466. int success = sscanf(m_pBufferWord,"%f",&x);
  467. ReadWord();
  468. success &= sscanf(m_pBufferWord,"%f",&y);
  469. ReadWord();
  470. success &= sscanf(m_pBufferWord,"%f",&z);
  471. if(success)
  472. {
  473. transform.SetScale(CVector3d(x,y,z));
  474. TRACE("    scale : %g %g %gn",x,y,z);
  475. }
  476. ReadLine();
  477. tmp = m_IndexBuffer;
  478. ReadLine();
  479. }
  481. // ScaleOrientation
  482. if(strstr(m_pBufferLine,"scaleOrientation") != NULL)
  483. {
  484. // Come back
  485. m_IndexBuffer = tmp;
  486. // Jump after "scaleOrientation"
  487. ReadWord(); 
  489. float x,y,z,value;
  490. ReadWord();
  491. int success = sscanf(m_pBufferWord,"%f",&x);
  492. ReadWord();
  493. success &= sscanf(m_pBufferWord,"%f",&y);
  494. ReadWord();
  495. success &= sscanf(m_pBufferWord,"%f",&z);
  496. ReadWord();
  497. success &= sscanf(m_pBufferWord,"%f",&value);
  498. if(success)
  499. {
  500. //transform.SetScale(CVector3d(x,y,z));
  501. TRACE("    scaleOrientation : %g %g %g %gn",x,y,z,value);
  502. }
  503. ReadLine();
  504. }
  506. // Material
  507. //********************************************
  508. // appearance Appearance {
  509.   // material Material {
  510.   // diffuseColor 0.5686 0.1098 0.6941
  511. CMaterial material;
  512. if(OffsetToString("Material"))
  513. {
  514. ReadLine();
  516. tmp = m_IndexBuffer;
  518. // Diffuse color
  519. ReadLine(); 
  520. if(strstr(m_pBufferLine,"diffuseColor") != NULL)
  521. {
  522. // Come back
  523. m_IndexBuffer = tmp;
  525. // Jump
  526. ReadWord();
  528. float r,g,b;
  529. ReadWord();
  530. int success = sscanf(m_pBufferWord,"%f",&r);
  531. ReadWord();
  532. success &= sscanf(m_pBufferWord,"%f",&g);
  533. ReadWord();
  534. success &= sscanf(m_pBufferWord,"%f",&b);
  535. if(success)
  536. {
  537. material.SetDiffuse(r,g,b,1.0f);
  538. TRACE("    diffuseColor : %g %g %gn",r,g,b);
  539. }
  540. }
  541. }
  543. // Texture
  544. //********************************************
  545. int texture = 0;
  546. if(OffsetToStringBefore("texture ImageTexture","geometry"))
  547. {
  548. texture = 1;
  549. ReadLine();
  550. tmp = m_IndexBuffer;
  552. ReadLine(); 
  553. if(strstr(m_pBufferLine,"url") != NULL)
  554. {
  555. // Come back
  556. m_IndexBuffer = tmp;
  558. // Jump
  559. ReadWord();
  560. char string[MAX_PATH];
  561. ReadWord();
  562. int success = sscanf(m_pBufferWord,"%s",string);
  564. // Remove ""
  565. CString TextureName = string;
  566. TextureName = TextureName.Mid(1,TextureName.GetLength()-2);
  567. TRACE("    texture : %sn",TextureName);
  569. // Ask SceneGraph to add texture, if needed
  570. char *name = TextureName.GetBuffer(MAX_PATH);
  571. if(!pSceneGraph->HasTexture(name,&IndexTexture))
  572. {
  573. CTexture *pTexture = new CTexture;
  574. pTexture->ReadFile(name);
  575. IndexTexture = pSceneGraph->AddTexture(pTexture);
  576. }
  577. TextureName.ReleaseBuffer();
  578. }
  579. }
  580. else // come back
  581. m_IndexBuffer = tmp;
  583. // Mesh
  584. //********************************************
  585. int NbVertex,NbFace,NbTextureCoordinate;
  586. // Count size (do not offset in file)
  587. if(!SizeMesh(&NbVertex,&NbFace,texture,&NbTextureCoordinate))
  588. return 0;
  590. // Add mesh
  591. CMesh3d *pMesh = new CMesh3d;
  592. pSceneGraph->Add(pMesh);
  593. // Set Size (faster)
  594. pMesh->m_ArrayVertex.SetSize(NbVertex);
  595. pMesh->m_ArrayFace.SetSize(NbFace);
  596. if(texture)
  597. {
  598. pMesh->m_pTextureCoordinate = new float[NbTextureCoordinate*2]; // x y 
  599. pMesh->m_pTextureCoordinateIndex = new int[NbFace*3];           // triangular faces
  600. pMesh->m_IndexTexture = IndexTexture;
  601. }
  602. // Store mesh (offset in file)
  603. StoreMesh(&pMesh->m_ArrayVertex,&pMesh->m_ArrayFace,texture,
  604. pMesh->m_pTextureCoordinate,pMesh->m_pTextureCoordinateIndex);
  606. // Transform & material
  607. pMesh->SetTransform(transform);
  608. pMesh->SetMaterial(&material);
  610. TRACE("  end reading meshn");
  612. return 1;
  613. }
  615. //********************************************
  616. // SizeMesh
  617. //********************************************
  618. int CParserVrml::SizeMesh(int *pNbVertex,
  619. int *pNbFace,
  620. int HasTexture,
  621. int *pNbTextureCoordinate /* = NULL */)
  622. {
  623. TRACE("    size mesh...");
  624. int tmp = m_IndexBuffer;
  626. ASSERT(pNbVertex != NULL);
  627. ASSERT(pNbFace != NULL);
  629. if(!OffsetToString("IndexedFaceSet"))
  630. {
  631. TRACE("invalid meshn");
  632. return 0;
  633. }
  635. // Count points
  636. //***********************************************
  637. if(!OffsetToString("Coordinate { point ["))
  638. {
  639. TRACE("invalid meshn");
  640. return 0;
  641. }
  643. m_IndexBuffer += strlen("Coordinate { point [") + 1;
  645. // Cur : x y z,
  646. // End : x y z]
  647. int NbVertex = 0;
  648. int success;
  649. do
  650. {
  651. float x,y,z;
  652. ReadWord();
  653. success = sscanf(m_pBufferWord,"%f",&x);
  654. ReadWord();
  655. success &= sscanf(m_pBufferWord,"%f",&y);
  656. ReadWord();
  657. success &= sscanf(m_pBufferWord,"%f",&z);
  658. NbVertex += success;
  659. //TRACE("n (%g %g %g) ",x,y,z);
  660. }
  661. while(success);
  662. TRACE(" %d points,",NbVertex);
  664. if(NbVertex <= 0)
  665. return 0;
  668. // Count texture coordinates, if needed 
  669. //***********************************************
  670. int NbTextureCoordinate = 0;
  671. if(HasTexture)
  672. {
  673. if(!OffsetToString("TextureCoordinate { point ["))
  674. {
  675. TRACE("invalid texture coordinatesn");
  676. return 0;
  677. }
  679. m_IndexBuffer += strlen("TextureCoordinate { point [") + 1;
  681. // Cur : x y,
  682. // End : x y]
  683. int success;
  684. do
  685. {
  686. float x,y;
  687. ReadWord();
  688. success = sscanf(m_pBufferWord,"%f",&x);
  689. ReadWord();
  690. success &= sscanf(m_pBufferWord,"%f",&y);
  691. NbTextureCoordinate += success;
  692. //TRACE("n (%g %g %g) ",x,y,z);
  693. }
  694. while(success);
  695. TRACE(" %d texture coordinates,",NbTextureCoordinate);
  697. if(NbTextureCoordinate <= 0)
  698. return 0;
  699. }
  702. // Count faces, accept only triangles
  703. //***********************************************
  704. m_IndexBuffer = tmp;
  705. if(!OffsetToString("coordIndex ["))
  706. {
  707. TRACE("invalid meshn");
  708. return 0;
  709. }
  710. m_IndexBuffer += strlen("coordIndex [") + 1;
  712. // Cur : int, int, int, -1,
  713. // End : int, int, int, -1]
  714. int NbFace = 0;
  715. do
  716. {
  717. int v1,v2,v3;
  718. ReadWord();
  719. success  = sscanf(m_pBufferWord,"%d,",&v1);
  720. ReadWord();
  721. success &= sscanf(m_pBufferWord,"%d,",&v2);
  722. ReadWord();
  723. success &= sscanf(m_pBufferWord,"%d,",&v3);
  724. NbFace += success;
  726. ASSERT(v1 >= 0);
  727. ASSERT(v2 >= 0);
  728. ASSERT(v3 >= 0);
  730. int test;
  731. ReadWord();
  732. sscanf(m_pBufferWord,"%d",&test);
  733. if(strstr(m_pBufferWord,"]") != NULL)
  734. success = 0;
  735. }
  736. while(success);
  737. TRACE(" %d faces,",NbFace);
  739. if(NbFace <= 0)
  740. return 0;
  742. // Count texture coordinate index 
  743. //***********************************************
  744. if(HasTexture)
  745. {
  746. m_IndexBuffer = tmp;
  747. if(!OffsetToString("texCoordIndex ["))
  748. {
  749. TRACE("invalid texture coordinate indexn");
  750. return 0;
  751. }
  752. m_IndexBuffer += strlen("texCoordIndex [") + 1;
  754. // Cur : int, int, int, -1,
  755. // End : int, int, int, -1]
  756. int NbCoordIndex = 0;
  757. do
  758. {
  759. int v1,v2,v3;
  760. ReadWord();
  761. success  = sscanf(m_pBufferWord,"%d,",&v1);
  762. ReadWord();
  763. success &= sscanf(m_pBufferWord,"%d,",&v2);
  764. ReadWord();
  765. success &= sscanf(m_pBufferWord,"%d,",&v3);
  766. NbCoordIndex += success;
  768. ASSERT(v1 >= 0);
  769. ASSERT(v2 >= 0);
  770. ASSERT(v3 >= 0);
  772. int test;
  773. ReadWord();
  774. sscanf(m_pBufferWord,"%d",&test);
  775. if(strstr(m_pBufferWord,"]") != NULL)
  776. success = 0;
  777. }
  778. while(success);
  779. TRACE(" %d coordinate indexn",NbCoordIndex);
  781. if(NbFace != NbCoordIndex)
  782. {
  783. TRACE(" different values for coord index and facesn");
  784. return 0;
  785. }
  786. }
  788. // Store result
  789. *pNbVertex = NbVertex;
  790. *pNbFace = NbFace;
  791. if(HasTexture)
  792. *pNbTextureCoordinate = NbTextureCoordinate;
  794. m_IndexBuffer = tmp;
  796. return 1;
  797. }
  800. //********************************************
  801. // StoreMesh
  802. //********************************************
  803. int CParserVrml::StoreMesh(CArray3d<CVertex3d> *pArrayVertex,
  804.  CArray3d<CFace3d> *pArrayFace,
  805.  int HasTexture,
  806.  float *pTextureCoordinate,
  807.  int *pTextureCoordinateIndex)
  808. {
  809. TRACE("    store mesh...");
  810. int tmp = m_IndexBuffer;
  812. if(!OffsetToString("IndexedFaceSet"))
  813. {
  814. TRACE("invalid meshn");
  815. return 0;
  816. }
  818. // Store vertices
  819. //***********************************************
  820. if(!OffsetToString("Coordinate { point ["))
  821. {
  822. TRACE("invalid meshn");
  823. return 0;
  824. }
  825. m_IndexBuffer += strlen("Coordinate { point [") + 1;
  826. // Cur : x y z,
  827. // End : x y z]
  828. int success;
  829. int NbVertex = 0;
  830. do
  831. {
  832. float x,y,z;
  833. ReadWord();
  834. success = sscanf(m_pBufferWord,"%f",&x);
  835. ReadWord();
  836. success &= sscanf(m_pBufferWord,"%f",&y);
  837. ReadWord();
  838. success &= sscanf(m_pBufferWord,"%f",&z);
  839. if(success)
  840. pArrayVertex->SetAt(NbVertex++,new CVertex3d(x,y,z));
  841. //TRACE("n (%g %g %g) ",x,y,z);
  842. }
  843. while(success);
  844. TRACE(" added %d vertices,",NbVertex);
  846. // Store texture coordinates (if needed)
  847. //***********************************************
  848. if(HasTexture)
  849. {
  850. if(!OffsetToString("TextureCoordinate { point ["))
  851. {
  852. TRACE("invalid texture coordinaten");
  853. return 0;
  854. }
  855. m_IndexBuffer += strlen("TextureCoordinate { point [") + 1;
  856. // Cur : x y,
  857. // End : x y
  858. int success;
  859. int NbTextureCoordinate = 0;
  860. do
  861. {
  862. float x,y;
  863. ReadWord();
  864. success = sscanf(m_pBufferWord,"%f",&x);
  865. ReadWord();
  866. success &= sscanf(m_pBufferWord,"%f",&y);
  867. if(success)
  868. {
  869. pTextureCoordinate[2*NbTextureCoordinate] = x;
  870. pTextureCoordinate[2*NbTextureCoordinate+1] = y;
  871. NbTextureCoordinate++;
  872. }
  873. //TRACE("n (%g %g) ",x,y);
  874. }
  875. while(success);
  876. TRACE(" added %d texture coordinates,",NbTextureCoordinate);
  877. }
  881. // Store faces, accept only triangles
  882. //***********************************************
  883. m_IndexBuffer = tmp;
  884. if(!OffsetToString("coordIndex ["))
  885. {
  886. TRACE("invalid meshn");
  887. return 0;
  888. }
  889. m_IndexBuffer += strlen("coordIndex [") + 1;
  891. // Cur : int, int, int, -1,
  892. // End : int, int, int, -1]
  893. int NbFace = 0;
  894. do
  895. {
  896. int v1,v2,v3;
  897. ReadWord();
  898. success  = sscanf(m_pBufferWord,"%d,",&v1);
  899. ReadWord();
  900. success &= sscanf(m_pBufferWord,"%d,",&v2);
  901. ReadWord();
  902. success &= sscanf(m_pBufferWord,"%d,",&v3);
  904. ASSERT(v1 >= 0);
  905. ASSERT(v2 >= 0);
  906. ASSERT(v3 >= 0);
  909. if(success && v1 >= 0 && v2 >= 0 && v3 >= 0)
  910. {
  911. CFace3d *pFace = new CFace3d(pArrayVertex->GetAt(v1),
  912.                            pArrayVertex->GetAt(v2),
  913.  pArrayVertex->GetAt(v3));
  914. pArrayFace->SetAt(NbFace++,pFace);
  915. }
  917. int test;
  918. ReadWord();
  919. sscanf(m_pBufferWord,"%d",&test);
  920. if(strstr(m_pBufferWord,"]") != NULL)
  921. success = 0;
  923. }
  924. while(success);
  925. TRACE(" added %d facesn",NbFace);
  927. // Store texture coord index
  928. //***********************************************
  929. if(HasTexture)
  930. {
  931. m_IndexBuffer = tmp;
  932. if(!OffsetToString("texCoordIndex ["))
  933. {
  934. TRACE("invalid meshn");
  935. return 0;
  936. }
  937. m_IndexBuffer += strlen("texCoordIndex [") + 1;
  939. // Cur : int, int, int, -1,
  940. // End : int, int, int, -1]
  941. int NbTexCoordIndex = 0;
  942. do
  943. {
  944. int v1,v2,v3;
  945. ReadWord();
  946. success  = sscanf(m_pBufferWord,"%d,",&v1);
  947. ReadWord();
  948. success &= sscanf(m_pBufferWord,"%d,",&v2);
  949. ReadWord();
  950. success &= sscanf(m_pBufferWord,"%d,",&v3);
  952. ASSERT(v1 >= 0);
  953. ASSERT(v2 >= 0);
  954. ASSERT(v3 >= 0);
  956. if(success && v1 >= 0 && v2 >= 0 && v3 >= 0)
  957. {
  958. pTextureCoordinateIndex[3*NbTexCoordIndex] = v1;
  959. pTextureCoordinateIndex[3*NbTexCoordIndex+1] = v2;
  960. pTextureCoordinateIndex[3*NbTexCoordIndex+2] = v3;
  961. NbTexCoordIndex++;
  962. }
  964. int test;
  965. ReadWord();
  966. sscanf(m_pBufferWord,"%d",&test);
  967. if(strstr(m_pBufferWord,"]") != NULL)
  968. success = 0;
  970. }
  971. while(success);
  972. TRACE(" added %d texture coordinate indexn",NbTexCoordIndex);
  973. }
  975. return 1;
  976. }
  978. // ** EOF **