VRUT::STLParser Class Reference

Class for parsing STL files. More...

#include <stlparser.h>

List of all members.

Public Member Functions

 STLParser (wxInputStream *_inputStream, SCENE_ID _sceneID, const wxString _scenePath, Module *_module)
 ~STLParser ()
 Class destructor.
bool Parse (const wxString &rootUid, bool recomputeNormals)

Private Member Functions

bool parseASCII (GeometryNode *node, std::vector< VECTOR3 > *verts, std::vector< VECTOR3 > *normals, std::vector< GeometryTriangles::Indice > *indices, bool recomputeNormals)
 Parse from ASCII source.
bool parseBinary (GeometryNode *node, std::vector< VECTOR3 > *verts, std::vector< VECTOR3 > *normals, std::vector< GeometryTriangles::Indice > *indices, bool recomputeNormals)
 Parse from binary source.

Private Attributes

wxInputStream * inputStream
 Input stream.
SCENE_ID sceneID
 Scene container ID to be built.
wxString fileName
 Path to scene resources, can be archive filename.
Module * module
 Parent module's interface.

Detailed Description

Class for parsing STL files.

Definition at line 32 of file stlparser.h.

Constructor & Destructor Documentation

STLParser::STLParser ( wxInputStream *  _inputStream,
SCENE_ID  _sceneID,
const wxString  _scenePath,
Module *  _module 
)

Class constructor

Parameters:
[in] _inputStream Stream to read data from
[in] _sceneID Scene ID
[in] _scenePath Path to scene resources (can be an archive filename)
[in] _module Parent module with messaging interface

Definition at line 22 of file stlparser.cpp.

00023 : inputStream(_inputStream), sceneID(_sceneID), module(_module)
00024 {
00025        fileName = wxFileName(_scenePath).GetName();
00026 }

STLParser::~STLParser (  ) 

Class destructor.

Is called by wxWidgets itself on wxApp end but it doesn't work in dynamic library

Definition at line 29 of file stlparser.cpp.

00030 {
00032 }

Member Function Documentation

bool STLParser::parseASCII ( GeometryNode *  node,
std::vector< VECTOR3 > *  verts,
std::vector< VECTOR3 > *  normals,
std::vector< GeometryTriangles::Indice > *  indices,
bool  recomputeNormals 
) [private]

Parse from ASCII source.

set parsed name

parse

Definition at line 34 of file stlparser.cpp.

00036 {
00037        TextParser textParser(inputStream, 10000, 1000);
00038        wxString newName = textParser.GetWxString("\r\n");
00039 
00041        wxCommandEvent evName = Event::GET_EVT_SCENE_NODE_NAME_SET(sceneID, node->GetName(), newName);
00042        module->PostToKernel(evName);
00043 
00045        const char *keywords1[]={"facet normal", "endsolid", ""};
00046        const char *keywords2[]={"vertex", "endloop", ""};
00047        unsigned int index = 0;
00048        VECTOR3 vert;
00049        while (!textParser.IsEmpty())
00050        {
00051               switch (textParser.KeywordsSwitch(keywords1))
00052               {
00053               case 0://facet normal
00054                      {
00055                             VECTOR3 norm;
00056                             if (textParser.ParseVector(norm._v, 3, true) != 3)
00057                                    return false;
00058 
00059                             while (textParser.NextKeywordIs("outer loop"))
00060                             {
00061                                    bool cycle=true;
00062                                    while (cycle)
00063                                    {
00064                                           switch (textParser.KeywordsSwitch(keywords2))
00065                                           {
00066                                           case 0://vertex
00067                                                  if (textParser.ParseVector(vert._v, 3, true) != 3)
00068                                                         return false;
00069                                                  verts->push_back(vert);
00070 //                                               normals->push_back(norm);
00071                                                  indices->push_back(index++);
00072                                                  break;
00073                                           case 1://endloop
00074                                                  if (recomputeNormals)
00075                                                  {
00076                                                         size_t lastI = verts->size()-3;
00077                                                         norm = (verts->at(lastI+1) - verts->at(lastI)).Cross(verts->at(lastI+2) - verts->at(lastI)).Normalize();
00078                                                  }
00079                                                  normals->push_back(norm);
00080                                                  normals->push_back(norm);
00081                                                  normals->push_back(norm);
00082                                                  cycle = false;
00083                                                  break;
00084                                           default:
00085                                                  LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
00086                                                  return false;
00087                                           }
00088                                    }
00089                             }
00090 
00091                             if (!textParser.NextKeywordIs("endfacet"))
00092                             {
00093                                    LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
00094                                    return false;
00095                             }
00096                      }
00097                      break;
00098               case 1://endsolid
00099                      textParser.GetWxLine();//read name of solid
00100                      break;
00101               default:
00102                      LOGERROR(wxT("<STLParser>Unexpected token: '" + textParser.GetWxLine() + wxT("'")));
00103                      return false;
00104               }
00105        }
00106        return true;
00107 }

bool STLParser::parseBinary ( GeometryNode *  node,
std::vector< VECTOR3 > *  verts,
std::vector< VECTOR3 > *  normals,
std::vector< GeometryTriangles::Indice > *  indices,
bool  recomputeNormals 
) [private]

Parse from binary source.

parse

Definition at line 109 of file stlparser.cpp.

00111 {
00112        //skip head
00113        char buf[81];
00114        inputStream->Read(buf, 74);//6 bytes already read
00115        //read facesets count
00116        unsigned long count;
00117        inputStream->Read(&count, 4);
00118 
00120        STLBinary facet;
00121        unsigned int index = 0;
00122        while (!inputStream->Eof())
00123        {
00124               inputStream->Read(&facet, 50/*sizeof(STLBinary)*/);
00125               if (inputStream->LastRead()!=50)
00126                      break;
00127 
00128               if (recomputeNormals)
00129                      memcpy(facet.norm, (VECTOR3(facet.vert2) - VECTOR3(facet.vert1)).Cross(VECTOR3(facet.vert3) - VECTOR3(facet.vert1)).Normalize()._v, sizeof(float)*3);
00130 
00131               verts->push_back(facet.vert1);
00132               normals->push_back(facet.norm);
00133               indices->push_back(index++);
00134 
00135               verts->push_back(facet.vert2);
00136               normals->push_back(facet.norm);
00137               indices->push_back(index++);
00138 
00139               verts->push_back(facet.vert3);
00140               normals->push_back(facet.norm);
00141               indices->push_back(index++);
00142        }
00143        return true;
00144 }

bool STLParser::Parse ( const wxString &  rootUid,
bool  recomputeNormals 
)

Parse STL stream and build scene graph

Parameters:
[in] rootUid Uid of node that will be root of imported scene
[in] recomputeNormals Recompute normals from triangles
Returns:
true if successful

Add new geometry node

Create new mesh

prepare

Assign mesh

Definition at line 146 of file stlparser.cpp.

00147 {
00148        wxCommandEvent evName = Event::GET_EVT_SCENE_NODE_NAME_SET(sceneID, rootUid, fileName);
00149        module->PostToKernel(evName);
00150 
00151        //prepare material
00152        Material * material = new Material(wxT("STLDefault"));
00153        material->diffuse = VECTOR4(0.5, 0.5, 0.5, 1);
00154        material->specular = VECTOR4(0.5, 0.5, 0.5, 1);
00155        material->flags = Material::DOUBLE_SIDED;
00156        wxCommandEvent evMat = Event::GET_EVT_SCENE_MATERIAL_ADD(sceneID, material);
00157        module->PostToKernel(evMat);
00158 
00159        //prepare geometry
00161        wxString nodeName = fileName + wxT("_node");
00162        GeometryNode * node = new GeometryNode(nodeName, nodeName);
00163        wxCommandEvent evNode = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, rootUid);
00164        module->PostToKernel(evNode);
00165        wxCommandEvent evMatSet = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeName, material->name);
00166        module->PostToKernel(evMatSet);
00167 
00169        GeometryTriangles *geometry = new GeometryTriangles(nodeName);
00170 
00172        std::vector<VECTOR3> * verts = &(geometry->vertices);
00173        std::vector<VECTOR3> * normals = &(geometry->normals);
00174        std::vector<GeometryTriangles::Indice> * indices = &(geometry->indices);
00175        std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_LIST);
00176        geometry->triDescList.push_back(indType);
00177 
00178        //parse
00179        bool parsedOK = true;
00180        char buf[7];
00181        inputStream->Read(buf, 6);
00182        buf[6]=0;
00183        if (!_strnicmp(buf, "solid ", 6))
00184               parsedOK = parseASCII(node, verts, normals, indices, recomputeNormals);
00185        else
00186               parsedOK = parseBinary(node, verts, normals, indices, recomputeNormals);
00187 
00188        if (!parsedOK)
00189               LOGERROR(wxT("<STLParser>Scene not loaded properly"));
00190        else
00191        {
00193               wxCommandEvent evGeom = Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry);
00194               module->PostToKernel(evGeom);
00195               wxCommandEvent evGeomSet = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeName, geometry->GetName());
00196               module->PostToKernel(evGeomSet);
00197        }
00198        return parsedOK;
00199 }

Member Data Documentation

wxInputStream* VRUT::STLParser::inputStream [private]

Input stream.

Definition at line 36 of file stlparser.h.

SCENE_ID VRUT::STLParser::sceneID [private]

Scene container ID to be built.

Definition at line 38 of file stlparser.h.

wxString VRUT::STLParser::fileName [private]

Path to scene resources, can be archive filename.

Definition at line 40 of file stlparser.h.

Module* VRUT::STLParser::module [private]

Parent module's interface.

Definition at line 42 of file stlparser.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:41 2009 for VRUT by  doxygen 1.5.5