/cygdrive/d/src/svn/vrut/trunk/core/src/base_modules/iostl/stlparser.cpp

Go to the documentation of this file.

/*
 * $Id: stlparser.cpp,v 1.56 2008-06-25 22:50:29 kybav1 Exp $
 *
 * Description  : One line description of file.
 * Author       : Antonin Misek <antonin.misek@skoda-auto.cz>
 *
 * Purpose      :
 *     Long description of what the file is for.
 */


#include <wx/filename.h>
#include <wx/event.h>
#include "stlparser.h"
#include "../../textparser.h"
#include "../../module.h"
#include "../../geometrynode.h"

using namespace VRUT;


STLParser::STLParser(wxInputStream * _inputStream, SCENE_ID _sceneID, const wxString _scenePath, Module * _module)
: inputStream(_inputStream), sceneID(_sceneID), module(_module)
{
       fileName = wxFileName(_scenePath).GetName();
}


STLParser::~STLParser()
{
}

bool STLParser::parseASCII(GeometryNode *node, std::vector<VECTOR3> * verts, std::vector<VECTOR3> * normals,
       std::vector<GeometryTriangles::Indice> * indices, bool recomputeNormals)
{
       TextParser textParser(inputStream, 10000, 1000);
       wxString newName = textParser.GetWxString("\r\n");

       wxCommandEvent evName = Event::GET_EVT_SCENE_NODE_NAME_SET(sceneID, node->GetName(), newName);
       module->PostToKernel(evName);

       const char *keywords1[]={"facet normal", "endsolid", ""};
       const char *keywords2[]={"vertex", "endloop", ""};
       unsigned int index = 0;
       VECTOR3 vert;
       while (!textParser.IsEmpty())
       {
              switch (textParser.KeywordsSwitch(keywords1))
              {
              case 0://facet normal
                     {
                            VECTOR3 norm;
                            if (textParser.ParseVector(norm._v, 3, true) != 3)
                                   return false;

                            while (textParser.NextKeywordIs("outer loop"))
                            {
                                   bool cycle=true;
                                   while (cycle)
                                   {
                                          switch (textParser.KeywordsSwitch(keywords2))
                                          {
                                          case 0://vertex
                                                 if (textParser.ParseVector(vert._v, 3, true) != 3)
                                                        return false;
                                                 verts->push_back(vert);
//                                               normals->push_back(norm);
                                                 indices->push_back(index++);
                                                 break;
                                          case 1://endloop
                                                 if (recomputeNormals)
                                                 {
                                                        size_t lastI = verts->size()-3;
                                                        norm = (verts->at(lastI+1) - verts->at(lastI)).Cross(verts->at(lastI+2) - verts->at(lastI)).Normalize();
                                                 }
                                                 normals->push_back(norm);
                                                 normals->push_back(norm);
                                                 normals->push_back(norm);
                                                 cycle = false;
                                                 break;
                                          default:
                                                 LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
                                                 return false;
                                          }
                                   }
                            }

                            if (!textParser.NextKeywordIs("endfacet"))
                            {
                                   LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
                                   return false;
                            }
                     }
                     break;
              case 1://endsolid
                     textParser.GetWxLine();//read name of solid
                     break;
              default:
                     LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
                     return false;
              }
       }
       return true;
}

bool STLParser::parseBinary(GeometryNode *node, std::vector<VECTOR3> * verts, std::vector<VECTOR3> * normals,
       std::vector<GeometryTriangles::Indice> * indices, bool recomputeNormals)
{
       //skip head
       char buf[81];
       inputStream->Read(buf, 74);//6 bytes already read
       //read facesets count
       unsigned long count;
       inputStream->Read(&count, 4);

       STLBinary facet;
       unsigned int index = 0;
       while (!inputStream->Eof())
       {
              inputStream->Read(&facet, 50/*sizeof(STLBinary)*/);
              if (inputStream->LastRead()!=50)
                     break;

              if (recomputeNormals)
                     memcpy(facet.norm, (VECTOR3(facet.vert2) - VECTOR3(facet.vert1)).Cross(VECTOR3(facet.vert3) - VECTOR3(facet.vert1)).Normalize()._v, sizeof(float)*3);

              verts->push_back(facet.vert1);
              normals->push_back(facet.norm);
              indices->push_back(index++);

              verts->push_back(facet.vert2);
              normals->push_back(facet.norm);
              indices->push_back(index++);

              verts->push_back(facet.vert3);
              normals->push_back(facet.norm);
              indices->push_back(index++);
       }
       return true;
}

bool STLParser::Parse(const wxString & rootUid, bool recomputeNormals)
{
       wxCommandEvent evName = Event::GET_EVT_SCENE_NODE_NAME_SET(sceneID, rootUid, fileName);
       module->PostToKernel(evName);

       //prepare material
       Material * material = new Material(wxT("STLDefault"));
       material->diffuse = VECTOR4(0.5, 0.5, 0.5, 1);
       material->specular = VECTOR4(0.5, 0.5, 0.5, 1);
       material->flags = Material::DOUBLE_SIDED;
       wxCommandEvent evMat = Event::GET_EVT_SCENE_MATERIAL_ADD(sceneID, material);
       module->PostToKernel(evMat);

       //prepare geometry
       wxString nodeName = fileName + wxT("_node");
       GeometryNode * node = new GeometryNode(nodeName, nodeName);
       wxCommandEvent evNode = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, rootUid);
       module->PostToKernel(evNode);
       wxCommandEvent evMatSet = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeName, material->name);
       module->PostToKernel(evMatSet);

       GeometryTriangles *geometry = new GeometryTriangles(nodeName);

       std::vector<VECTOR3> * verts = &(geometry->vertices);
       std::vector<VECTOR3> * normals = &(geometry->normals);
       std::vector<GeometryTriangles::Indice> * indices = &(geometry->indices);
       std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_LIST);
       geometry->triDescList.push_back(indType);

       //parse
       bool parsedOK = true;
       char buf[7];
       inputStream->Read(buf, 6);
       buf[6]=0;
       if (!_strnicmp(buf, "solid ", 6))
              parsedOK = parseASCII(node, verts, normals, indices, recomputeNormals);
       else
              parsedOK = parseBinary(node, verts, normals, indices, recomputeNormals);

       if (!parsedOK)
              LOGERROR(wxT("<STLParser>Scene not loaded properly"));
       else
       {
              wxCommandEvent evGeom = Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry);
              module->PostToKernel(evGeom);
              wxCommandEvent evGeomSet = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeName, geometry->GetName());
              module->PostToKernel(evGeomSet);
       }
       return parsedOK;
}

---