#include <fhsparser.h>
Public Member Functions | |
| FHSParser (wxInputStream *_inputStream, SCENE_ID _sceneID, const wxString _scenePath, Module *_module) | |
| ~FHSParser () | |
| Class destructor. | |
| bool | Parse (const wxString &rootUid) |
Private Types | |
| enum | ERROR_MSG { EXPECTED, UNEXPECTED, VECTOR, MATERIAL } |
| Error message enumeration. More... | |
Private Member Functions | |
| WX_DECLARE_STRING_HASH_MAP (bool, NodeUidsList) | |
| bool | logErrorMsg (ERROR_MSG msg, const wxString &line, const wxChar *expected=NULL) |
| const wxString | getUniqueUid (const wxString &uid) |
| Check if given uid is unique, generate new if not and add to list. | |
| bool | parseScale (const wxString &nodeUid) |
Parse SCALE command and apply to node on top of the stack. | |
| bool | parseRotate (const wxString &nodeUid) |
Parse ROTATE command and apply to node on top of the stack. | |
| bool | parseIndices (std::vector< GeometryTriangles::Indice > *indices, size_t maxInd) |
| Parse indices list, common function for parsePolygon, parseTriangles, parseTriangleStrip, parseTriangleFan. | |
| bool | parsePolyPool (GeometryTriangles *geometry) |
| Parse and add vertices to geometry node's geometry on top of the stack. | |
| bool | parsePolyBox (GeometryTriangles *geometry) |
| Parse box definition and modify geometry. | |
| bool | parseCommonAttribs (wxString &nodeUid) |
| Parse common optional attributes. | |
| bool | parseCommonBody (const wxString &nodeUid) |
| Parse common (assembly like) body. | |
| bool | parseMaterialAttribs (Material *material) |
| Parse material body with several attributes. | |
| bool | parseMaterial () |
| Parse new material definition. | |
| bool | parseEnvironmentBody (const wxString &nodeUid) |
| Parse environment body. | |
| bool | parseEnvironmentAttribs (wxString &nodeUid) |
| Parse optional environment attributes. | |
| bool | parseEnvironment (const wxString &parentUid) |
| Parse environment definition. | |
| bool | parseLightBody (Light *light) |
| Parse light body. | |
| bool | parseLightAttribs (wxString &nodeUid) |
| Parse optional light attributes. | |
| bool | parseLight (const wxString &parentUid) |
| Parse light definition. | |
| bool | parseGeometryBody (const wxString &nodeUid, GeometryTriangles *geometry, bool &valid) |
| Parse geometry body. | |
| bool | parseGeometryAttribs (wxString &nodeUid, GeometryTriangles *geometry) |
| Parse optional geometry attributes. | |
| bool | parseGeometry (const wxString &parentUid) |
| Parse geometry definition. | |
| bool | parseSwitchAttribs (wxString &nodeUid) |
| Parse optional SWITCH attributes. | |
| bool | parseSwitch (const wxString &parentUid) |
| Parse SWITCH definition. | |
| bool | parseBillboardAttribs (wxString &nodeUid) |
| Parse optional BILLBOARD attributes. | |
| bool | parseBillboard (const wxString &parentUid) |
| Parse BILLBOARD definition. | |
| bool | parseLOD (const wxString &parentUid, const bool active) |
| Parse LOD definition. | |
| bool | parseLODAssemblyBody (const wxString &nodeUid) |
| Parse LOD assembly body. | |
| bool | parseLODAssembly (const wxString &parentUid) |
| Parse LOD assembly definition. | |
| bool | parseAssemblyBody (const wxString &nodeUid) |
| Parse assembly body. | |
| bool | parseAssemblyAttribs (wxString &nodeUid) |
| Parse optional assembly attributes. | |
| bool | parseAssembly (const wxString &parentUid) |
| Parse assembly definition. | |
| bool | parseModelAttribs (const wxString &nodeUid) |
| Parse optional model attributes. | |
| bool | parseModel (const wxString &nodeUid) |
Private Attributes | |
| TextParser * | textParser |
| Input text parser. | |
| SCENE_ID | sceneID |
| ID of scene to be built. | |
| wxString | scenePath |
| Path to scene resources, can be archive filename. | |
| Module * | module |
| Parent module's interface. | |
| unsigned | nodesImported |
| Number of nodes imported. | |
| unsigned | nodesGeomImported |
| Number of geometry nodes imported. | |
| unsigned | materialsImported |
| Number of materials imported. | |
| unsigned | texturesImported |
| Number of textures imported. | |
| unsigned | lightsImported |
| Number of lights imported. | |
| NodeUidsList | nodeUidsList |
| List of nodes' uid used during import to assure they are unique. | |
Definition at line 26 of file fhsparser.h.
enum VRUT::FHSParser::ERROR_MSG [private] |
Error message enumeration.
| EXPECTED | Expected something else. |
| UNEXPECTED | Unexpected token. |
| VECTOR | Vector parsing error. |
| MATERIAL | Material not defined error. |
Definition at line 53 of file fhsparser.h.
00054 { 00055 EXPECTED, 00056 UNEXPECTED, 00057 VECTOR, 00058 MATERIAL 00059 };
| FHSParser::FHSParser | ( | wxInputStream * | _inputStream, | |
| SCENE_ID | _sceneID, | |||
| const wxString | _scenePath, | |||
| Module * | _module | |||
| ) |
Class constructor
| [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 23 of file fhsparser.cpp.
00024 : module(_module) 00025 { 00026 textParser = new TextParser(_inputStream, 10000, 1000); 00027 wxFileName filename(_scenePath); 00028 scenePath = filename.GetPath() + filename.GetPathSeparator(); 00029 sceneID = _sceneID; 00030 nodesImported = nodesGeomImported = materialsImported = texturesImported = lightsImported = 0; 00031 }
| FHSParser::~FHSParser | ( | ) |
Class destructor.
Definition at line 34 of file fhsparser.cpp.
00035 { 00036 delete textParser; 00037 }
| VRUT::FHSParser::WX_DECLARE_STRING_HASH_MAP | ( | bool | , | |
| NodeUidsList | ||||
| ) | [private] |
| bool FHSParser::logErrorMsg | ( | ERROR_MSG | msg, | |
| const wxString & | line, | |||
| const wxChar * | expected = NULL | |||
| ) | [private] |
Log error message
| [in] | msg | Error ID |
| [in] | line | Part of string parsed with error |
| [in] | expected | Expected token if applicable |
false Definition at line 40 of file fhsparser.cpp.
00041 { 00042 if (module->TestExit()) 00043 return false; 00044 00045 switch (msg) 00046 { 00047 case EXPECTED: 00048 if (expected) 00049 { 00050 LOGERROR(wxT("<FHSParser>Expected '") + wxString(expected) + wxT("' before '") + line + wxT("'")); 00051 break; 00052 } 00053 case UNEXPECTED: 00054 if (wxString(line).Trim().IsEmpty()) 00055 LOGERROR(wxT("<FHSParser>Unexpected end of file")); 00056 else 00057 LOGERROR(wxT("<FHSParser>Unexpected token: '" + line + wxT("'"))); 00058 break; 00059 case VECTOR: 00060 LOGERROR(wxT("<FHSParser>Vector parse error, invalid dimension or format: '" + line + wxT("'"))); 00061 break; 00062 case MATERIAL: 00063 LOGERROR(wxT("<FHSParser>Material not defined: '" + line + wxT("'"))); 00064 break; 00065 } 00066 return false; 00067 }
| const wxString FHSParser::getUniqueUid | ( | const wxString & | uid | ) | [private] |
Check if given uid is unique, generate new if not and add to list.
Definition at line 70 of file fhsparser.cpp.
00071 { 00072 00073 wxString unqUid = CloneWxString(uid); 00074 unsigned cnt = 0; 00075 while (nodeUidsList.find(unqUid) != nodeUidsList.end()) 00076 unqUid = wxString::Format(wxT("%s_%i"), uid.c_str(), cnt++); 00077 nodeUidsList.insert(NodeUidsList::value_type(unqUid, false)); 00078 return unqUid; 00079 }
| bool FHSParser::parseScale | ( | const wxString & | nodeUid | ) | [private] |
Parse SCALE command and apply to node on top of the stack.
Vector type
Single number type
Definition at line 82 of file fhsparser.cpp.
00083 { 00085 if (textParser->NextCharIs('(')) 00086 { 00087 VECTOR3 v; 00088 if (textParser->ParseVector(v._v, 3) != 3) 00089 return false; 00090 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::ScaleMat(v)); 00091 module->PostToKernel(ev); 00092 } 00094 else 00095 { 00096 float val = 0; 00097 if (textParser->ParseFloat(&val)) 00098 { 00099 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::ScaleMat(VECTOR3(val, val, val))); 00100 module->PostToKernel(ev); 00101 } 00102 else 00103 return logErrorMsg(EXPECTED, textParser->GetWxLine(), wxT("<number>")); 00104 } 00105 return true; 00106 }
| bool FHSParser::parseRotate | ( | const wxString & | nodeUid | ) | [private] |
Parse ROTATE command and apply to node on top of the stack.
Vector + angle type
XYZ axis + angle type
Definition at line 109 of file fhsparser.cpp.
00110 { 00111 float angle; 00113 if (textParser->NextCharIs('(')) 00114 { 00115 VECTOR3 axis; 00116 if ((textParser->ParseVector(axis._v, 3) != 3) || (!textParser->ParseFloat(&angle))) 00117 return false; 00118 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::RotationAxis(axis, angle / 180.0 * 3.14159)); 00119 module->PostToKernel(ev); 00120 } 00122 else 00123 { 00124 const char *keywords[] = {"XAXIS", "YAXIS", "ZAXIS", ""}; 00125 while (!textParser->NextCharIs('}')) 00126 { 00127 switch (textParser->KeywordsSwitch(keywords)) 00128 { 00129 case 0://XAXIS 00130 { 00131 if (!textParser->ParseFloat(&angle)) 00132 return false; 00133 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::RotationX(angle / 180.0 * 3.14159)); 00134 module->PostToKernel(ev); 00135 } 00136 break; 00137 case 1://YAXIS 00138 { 00139 if (!textParser->ParseFloat(&angle)) 00140 return false; 00141 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::RotationY(angle / 180.0 * 3.14159)); 00142 module->PostToKernel(ev); 00143 } 00144 break; 00145 case 2://ZAXIS 00146 { 00147 if (!textParser->ParseFloat(&angle)) 00148 return false; 00149 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::RotationZ(angle / 180.0 * 3.14159)); 00150 module->PostToKernel(ev); 00151 } 00152 break; 00153 default: 00154 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00155 } 00156 } 00157 } 00158 return true; 00159 }
| bool FHSParser::parseIndices | ( | std::vector< GeometryTriangles::Indice > * | indices, | |
| size_t | maxInd | |||
| ) | [private] |
Parse indices list, common function for parsePolygon, parseTriangles, parseTriangleStrip, parseTriangleFan.
Definition at line 162 of file fhsparser.cpp.
00163 { 00164 if (textParser->GetChar() != '{') 00165 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00166 00167 //read indices 00168 while (!textParser->NextCharIs('}', "TNIC= \t\n\r")) 00169 { 00170 long val; 00171 if (!textParser->ParseLong(&val, NULL, false) || (val < 0) || (val > long(maxInd))) 00172 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00173 indices->push_back((GeometryTriangles::Indice)val); 00174 } 00175 if (textParser->GetChar() != '}') 00176 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00177 return true; 00178 }
| bool FHSParser::parsePolyPool | ( | GeometryTriangles * | geometry | ) | [private] |
Parse and add vertices to geometry node's geometry on top of the stack.
Definition at line 180 of file fhsparser.cpp.
00181 { 00182 wxASSERT_MSG(geometry->type == Geometry::GEOMETRY_TRIANGLE, wxT("Cannot parse polygon pool for non-triangulated geometry")); 00183 if (textParser->GetChar() != '{') 00184 return logErrorMsg(EXPECTED, textParser->GetWxLine(), wxT("{")); 00185 std::vector<VECTOR3> * verts = &(geometry->vertices); 00186 std::vector<VECTOR3> * normals = &(geometry->normals); 00187 std::vector<GeometryTriangles::TexCoord> * texCoords = &(geometry->texCoords); 00188 bool cycle = true; 00189 while (cycle) 00190 { 00191 switch (textParser->CharsSwitch("PNTC}", " \t\n\r=")) 00192 { 00193 case 0://P 00194 { 00195 VECTOR3 vert; 00196 if (textParser->ParseVector(vert._v, 3, false, "= ") != 3) 00197 return false; 00198 verts->push_back(vert); 00199 } 00200 break; 00201 case 1://N 00202 { 00203 VECTOR3 norm; 00204 if (textParser->ParseVector(norm._v, 3, false, "= ") != 3) 00205 return false; 00206 for (size_t i=verts->size()-normals->size()-1; i>0; i--) 00207 normals->push_back(VECTOR3()); 00208 normals->push_back(norm); 00209 } 00210 break; 00211 case 2://T 00212 { 00213 GeometryTriangles::TexCoord texCoord; 00214 if (textParser->ParseVector(texCoord._v, 2, false, "= ") != 2) 00215 return false; 00216 for (size_t i=verts->size()-texCoords->size()-1; i>0; i--) 00217 texCoords->push_back(GeometryTriangles::TexCoord()); 00218 texCoords->push_back(texCoord); 00219 } 00220 break; 00221 case 3://C 00222 {//TODO 00223 VECTOR3 c; 00224 if (textParser->ParseVector(c._v, 3, false, "= ") != 3) 00225 return false; 00226 //normals->push_back(c); 00227 } 00228 break; 00229 case 4://} 00230 cycle = false; 00231 break; 00232 default: 00233 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00234 } 00235 } 00236 return true; 00237 }
| bool FHSParser::parsePolyBox | ( | GeometryTriangles * | geometry | ) | [private] |
Parse box definition and modify geometry.
Definition at line 240 of file fhsparser.cpp.
00241 { 00242 float box[6]; 00243 if (!textParser->ParseVector(box, 6)) 00244 return false; 00245 vector3 position(box), size(box + 3); 00246 geometry->AddBox(position, size - position); 00247 return true; 00248 }
| bool FHSParser::parseCommonAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse common optional attributes.
Definition at line 1007 of file fhsparser.cpp.
01008 { 01009 const char *keywords[] = {"DESCX", "MATRIX", "TRANSLATE", "SCALE", "ROTATE", ""}; 01010 while (!textParser->NextCharIs('{')) 01011 { 01012 if (module->TestExit()) 01013 textParser->ForceEmpty(); 01014 01015 switch (textParser->KeywordsSwitch(keywords)) 01016 { 01017 case 0://DESCX 01018 { 01019 //TODO 01020 TextParser tmpParser(textParser->GetString().c_str()); 01021 const char *envKeywords[] = {"UID", "SIZES", "TEXTURE_ATTRIBUTES", "LODTYPE", "UNUSED", "MIRROR", "OPENRTBINARY", ""}; 01022 switch (tmpParser.KeywordsSwitch(envKeywords)) 01023 { 01024 case 0://UID 01025 { 01026 wxString newUid(getUniqueUid(tmpParser.GetWxString())); 01027 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_UID_SET(sceneID, nodeUid, newUid); 01028 module->PostToKernel(ev); 01029 nodeUid = newUid; 01030 } 01031 break; 01032 case 1://SIZES 01033 { 01034 int sizes[3];//TODO, ex: "17045 5977 0", "1793 628 0", "<number of points> <number of primitives> <?>" 01035 if (!tmpParser.ParseInt(&sizes[0])) 01036 return false; 01037 if (!tmpParser.ParseInt(&sizes[1])) 01038 return false; 01039 if (!tmpParser.ParseInt(&sizes[2])) 01040 return false; 01041 } 01042 break; 01043 case 2://TEXTURE_ATTRIBUTES 01044 {//TODO, jsou to parametry pouzite pri mapovani textury ve VD 01045 const char *envKeywords[] = {"flip_textureS", "flip_textureT", "planar_scaleS", "planar_scaleT", "planar_translationS", "planar_translationT", ""}; 01046 int index; 01047 while ((index = tmpParser.KeywordsSwitch(envKeywords)) >= 0) 01048 { 01049 switch (index) 01050 { 01051 case 0://flip_textureS 01052 { 01053 int flip_textureS; 01054 if (!tmpParser.ParseInt(&flip_textureS)) 01055 return false; 01056 } 01057 break; 01058 case 1://flip_textureT 01059 { 01060 int flip_textureT; 01061 if (!tmpParser.ParseInt(&flip_textureT)) 01062 return false; 01063 } 01064 break; 01065 case 2://planar_scaleS 01066 { 01067 float planar_scaleS; 01068 if (!tmpParser.ParseFloat(&planar_scaleS)) 01069 return false; 01070 } 01071 break; 01072 case 3://planar_scaleT 01073 { 01074 float planar_scaleT; 01075 if (!tmpParser.ParseFloat(&planar_scaleT)) 01076 return false; 01077 } 01078 break; 01079 case 4://planar_translationS 01080 { 01081 float planar_translationS; 01082 if (!tmpParser.ParseFloat(&planar_translationS)) 01083 return false; 01084 } 01085 break; 01086 case 5://planar_translationT 01087 { 01088 float planar_translationT; 01089 if (!tmpParser.ParseFloat(&planar_translationT)) 01090 return false; 01091 } 01092 break; 01093 case 6://planar_translationS 01094 { 01095 float planar_translationS; 01096 if (!tmpParser.ParseFloat(&planar_translationS)) 01097 return false; 01098 } 01099 break; 01100 default: 01101 wxString textureattributes(tmpParser.GetWxLine()); 01102 //logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 01103 } 01104 } 01105 } 01106 break; 01107 case 3://LODTYPE 01108 {//TODO, ex: Distance 01109 wxString lodtype(tmpParser.GetWxString()); 01110 } 01111 break; 01112 case 4://UNUSED 01113 break; 01114 case 5://MIRROR 01115 break;//urcuje zrcadlo, ponekud podivne je to u geometrie a ne u materialu, mira odrazivosti je urcena asi pomoci TRANSPARENCY 01116 case 6://OPENRTBINARY 01117 {//TODO, patrne nastaveni materialu pro OpenRT RealTime RayTracing 01118 wxString openrtbinary(tmpParser.GetWxLine()); 01119 } 01120 break; 01121 default: 01122 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 01123 } 01124 } 01125 break; 01126 case 1://MATRIX 01127 { 01128 MATRIX mat; 01129 if (textParser->ParseVector(mat._m, 16) != 16) 01130 return false; 01131 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, mat); 01132 module->PostToKernel(ev); 01133 } 01134 break; 01135 case 2://TRANSLATE 01136 { 01137 VECTOR3 v; 01138 if (textParser->ParseVector(v._v, 3) != 3) 01139 return false; 01140 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, MATRIX::Translation(v)); 01141 module->PostToKernel(ev); 01142 } 01143 break; 01144 case 3://SCALE 01145 if (!parseScale(nodeUid)) 01146 return false; 01147 break; 01148 case 4://ROTATE 01149 if (!parseRotate(nodeUid)) 01150 return false; 01151 break; 01152 default: 01153 return false; 01154 } 01155 } 01156 return true; 01157 }
| bool FHSParser::parseCommonBody | ( | const wxString & | nodeUid | ) | [private] |
Parse common (assembly like) body.
Definition at line 1160 of file fhsparser.cpp.
01161 { 01162 const char *keywords[] = {"ASSEMBLY", "GEOMETRY", "LODASSEMBLY", "LOD", "LIGHT", "ENVIRONMENT", "BILLBOARD", "SWITCH", ""}; 01163 while (!textParser->NextCharIs('}')) 01164 { 01165 if (module->TestExit()) 01166 textParser->ForceEmpty(); 01167 01168 switch (textParser->KeywordsSwitch(keywords)) 01169 { 01170 case 0://ASSEMBLY 01171 if (!parseAssembly(nodeUid)) 01172 return false; 01173 break; 01174 case 1://GEOMETRY 01175 if (!parseGeometry(nodeUid)) 01176 return false; 01177 break; 01178 case 2://LODASSEMBLY 01179 if (!parseLODAssembly(nodeUid)) 01180 return false; 01181 break; 01182 case 3://LOD 01183 if (!parseAssembly(nodeUid))//on this place in FHS file should not be LOD, so read it as assembly 01184 return false; 01185 break; 01186 case 4://LIGHT 01187 if (!parseLight(nodeUid)) 01188 return false; 01189 break; 01190 case 5://ENVIRONMENT 01191 if (!parseEnvironment(nodeUid)) 01192 return false; 01193 break; 01194 case 6://BILLBOARD 01195 if (!parseBillboard(nodeUid)) 01196 return false; 01197 break; 01198 case 7://SWITCH 01199 if (!parseSwitch(nodeUid)) 01200 return false; 01201 break; 01202 default: 01203 return false; 01204 } 01205 } 01206 return true; 01207 }
| bool FHSParser::parseMaterialAttribs | ( | Material * | material | ) | [private] |
Parse material body with several attributes.
Definition at line 251 of file fhsparser.cpp.
00252 { 00253 if (textParser->GetChar() != '{') 00254 return logErrorMsg(EXPECTED, textParser->GetWxLine(), wxT("{")); 00255 const char *keywords[] = {"AMBIENT", "DIFFUSE", "SPECULAR", "EMISSION", "SHININESS", "TEXTURE", "TEXWRAP", "TEXFILTER", "TEXQUALITY", "TEXBLEND", "TRANSPARENCY", "MATX", "COLOR", "UNLIT", "}", ""}; 00256 vector3 color(1, 1, 1); 00257 bool cycle = true; 00258 while (cycle) 00259 { 00260 switch (textParser->KeywordsSwitch(keywords)) 00261 { 00262 case 0://AMBIENT 00263 if (textParser->ParseVector(material->ambient._v, 3) != 3) 00264 return false; 00265 break; 00266 case 1://DIFFUSE 00267 if (textParser->NextCharIs('(')) 00268 { 00269 if (textParser->ParseVector(material->diffuse._v, 3) != 3) 00270 return false; 00271 } 00272 else 00273 {//TODO check correctness 00274 float diffuse; 00275 if (!textParser->ParseFloat(&diffuse)) 00276 return false; 00277 material->diffuse = VECTOR4(color * diffuse, 1); 00278 } 00279 break; 00280 case 2://SPECULAR 00281 if (textParser->NextCharIs('(')) 00282 { 00283 if (textParser->ParseVector(material->specular._v, 3) != 3) 00284 return false; 00285 } 00286 else 00287 {//TODO check correctness 00288 float specular; 00289 if (!textParser->ParseFloat(&specular)) 00290 return false; 00291 material->specular = VECTOR4(color * specular, 1); 00292 } 00293 break; 00294 case 3://EMISSION 00295 if (textParser->ParseVector(material->emission._v, 3) != 3) 00296 return false; 00297 break; 00298 case 4://SHININESS 00299 if (!textParser->ParseFloat(&material->shininess)) 00300 return false; 00301 break; 00302 case 5://TEXTURE 00303 { 00304 wxString texPath = scenePath + textParser->GetWxString(); 00305 wxCommandEvent texEvt = Event::GET_EVT_SCENE_IMAGE_ADD(texPath); 00306 module->PostToKernel(texEvt); 00307 material->imageName = texPath; 00308 /* const Image * img = (((SceneModule*)module)->GetSceneMgr()->GetScene(sceneID))->GetImage(texPath); 00309 if (!img) 00310 module->WaitForEvent(Event::EVT_SCENE_IMAGE_ADDED, 1000, -1, -1, texPath); 00311 img = (((SceneModule*)module)->GetSceneMgr()->GetScene(sceneID))->GetImage(texPath); 00312 if (img && img->IsOk() && img->HasTransparency()) 00313 { 00314 material->flags |= Material::BLENDED; 00315 material->texBlendSrc = GL_SRC_ALPHA; 00316 material->texBlendDst = GL_ONE_MINUS_SRC_ALPHA; 00317 }*/ 00318 texturesImported++; 00319 } 00320 break; 00321 case 6://TEXWRAP 00322 { 00323 const char *texwraps[] = {"REPEAT", "CLAMP", ""}; 00324 material->texFlags |= ( textParser->KeywordsSwitch(texwraps) ? Material::TEX_UWRAP_CLAMP : Material::TEX_UWRAP_REPEAT ); 00325 material->texFlags |= ( textParser->KeywordsSwitch(texwraps) ? Material::TEX_VWRAP_CLAMP : Material::TEX_VWRAP_REPEAT ); 00326 } 00327 break; 00328 case 7://TEXFILTER 00329 { 00330 const char *texfilters[] = {"POINT", "LINEAR", "MIPMAP", ""}; 00331 int minFilter = textParser->KeywordsSwitch(texfilters); 00332 switch (minFilter) 00333 { 00334 case 0: 00335 material->texFlags |= Material::TEX_MIN_FILTER_POINT; 00336 break; 00337 case 1: 00338 material->texFlags |= Material::TEX_MIN_FILTER_LINEAR; 00339 break; 00340 default: 00341 material->texFlags |= Material::TEX_MIN_FILTER_MIPMAP; 00342 break; 00343 } 00344 int maxFilter = textParser->KeywordsSwitch(texfilters); 00345 switch (maxFilter) 00346 { 00347 case 0: 00348 material->texFlags |= Material::TEX_MAG_FILTER_POINT; 00349 break; 00350 default: 00351 material->texFlags |= Material::TEX_MAG_FILTER_LINEAR; 00352 break; 00353 } 00354 } 00355 break; 00356 case 8://TEXQUALITY 00357 { 00358 wxString texquality(textParser->GetWxString());//TODO 00359 //known values LOW 00360 } 00361 break; 00362 case 9://TEXBLEND 00363 { 00364 const char *texblend[] = {"MODULATE", "REPLACE", "DECAL", "BLEND", ""}; 00365 int texBlend = textParser->KeywordsSwitch(texblend); 00366 switch (texBlend) 00367 { 00368 case 0: 00369 material->texFlags |= Material::TEX_ENV_MODULATE; 00370 break; 00371 case 1: 00372 material->texFlags |= Material::TEX_ENV_REPLACE; 00373 break; 00374 case 2: 00375 material->texFlags |= Material::TEX_ENV_DECAL; 00376 break; 00377 case 3: 00378 material->texFlags |= Material::TEX_ENV_BLEND; 00379 break; 00380 } 00381 } 00382 break; 00383 case 10://TRANSPARENCY 00384 if (!textParser->ParseFloat(&material->diffuse.w)) 00385 return false; 00386 material->diffuse.w = 1.0 - material->diffuse.w; 00387 material->flags |= Material::BLENDED; 00388 break; 00389 case 11://MATX 00390 { 00391 TextParser tmpParser(textParser->GetString().c_str()); 00392 const char *envKeywords[] = {"DEPTHTEST", "DEPTHMASK", "DEPTHFUNC", "UID", "DSIDED", "GENFUNC", "INVERTALPHA", "IGNORECOLORS", "CLEARCOAT", 00393 "SHADERENABLE", "SHADERPROG", "SHADERPARAM", "MIXTEXTURE", "BLENDFUNC", "ACTIVATE", "DEACTIVATE", "CUBETEX", "LINEWIDTH", "" 00394 }; 00395 switch (tmpParser.KeywordsSwitch(envKeywords)) 00396 { 00397 case 0://DEPTHTEST 00398 { 00399 int depthtest; 00400 if (!tmpParser.ParseInt(&depthtest)) 00401 return false; 00402 if (depthtest == 0) 00403 material->flags |= Material::DEPTH_TEST_DISABLE; 00404 } 00405 break; 00406 case 1://DEPTHMASK 00407 { 00408 int depthmask; 00409 if (!tmpParser.ParseInt(&depthmask)) 00410 return false; 00411 if (depthmask == 0) 00412 material->flags |= Material::DEPTH_MASK_DISABLE; 00413 } 00414 break; 00415 case 2://DEPTHFUNC 00416 { 00417 int dfunc; 00418 if (!tmpParser.ParseInt(&dfunc)) 00419 return false; 00420 material->depthFunc = dfunc; 00421 } 00422 break; 00423 case 3://UID 00424 material->uid = tmpParser.GetWxString(); 00425 break; 00426 case 4://DSIDED 00427 { 00428 int dsided; 00429 if (!tmpParser.ParseInt(&dsided)) 00430 return false; 00431 if (dsided) 00432 material->flags |= Material::DOUBLE_SIDED; 00433 } 00434 break; 00435 case 5://GENFUNC 00436 { 00437 bool scoord = tmpParser.GetWxString().IsSameAs('s', false); 00438 wxString type(tmpParser.GetWxString()); 00439 if (type.Matches(wxT("*Eye*")))//TODO: exact name for GL_EYE_LINEAR 00440 { 00441 if (scoord) 00442 material->texFlags |= Material::TEX_GEN_FUNC_U_EYE; 00443 else 00444 material->texFlags |= Material::TEX_GEN_FUNC_V_EYE; 00445 } 00446 else if (type.Matches(wxT("*Object*")))//TODO: exact name for GL_OBJECT_LINEAR 00447 { 00448 if (scoord) 00449 material->texFlags |= Material::TEX_GEN_FUNC_U_OBJECT; 00450 else 00451 material->texFlags |= Material::TEX_GEN_FUNC_V_OBJECT; 00452 } 00453 else if (type.IsSameAs(wxT("Sphere"))) 00454 { 00455 if (scoord) 00456 material->texFlags |= Material::TEX_GEN_FUNC_U_SPHERE; 00457 else 00458 material->texFlags |= Material::TEX_GEN_FUNC_V_SPHERE; 00459 } 00460 } 00461 break; 00462 case 6://INVERTALPHA 00463 material->flags |= Material::INVERT_ALPHA; 00464 break; 00465 case 7://IGNORECOLORS 00466 material->texFlags |= Material::TEX_IGNORE_COLORS; 00467 break; 00468 case 8://CLEARCOAT 00469 {//TODO 00470 float clearcoat[3];//ex: "1.0 0.0 0.0", "2.66 0.97 0.24" 00471 if (tmpParser.ParseVector(clearcoat, 3, true) != 3) 00472 return false; 00473 } 00474 break; 00475 case 9://SHADERENABLE 00476 { 00477 int shaderenable; 00478 if (!tmpParser.ParseInt(&shaderenable)) 00479 return false; 00480 material->shader = new ShaderProgram; 00481 } 00482 break; 00483 case 10://SHADERPROG 00484 { 00485 if (!material->shader) 00486 { 00487 LOGERROR(wxT("<FHSParser>Shader defined but not enabled")); 00488 material->shader = new ShaderProgram; 00489 //return false; 00490 } 00491 const char *keywords[] = {"GLSL", "OPENRT", ""}; 00492 switch (tmpParser.KeywordsSwitch(keywords)) 00493 { 00494 case 0://GLSL 00495 { 00496 material->shader->type = ShaderProgram::LANG_GLSL; 00497 wxString * target = (wxString *)NULL; 00498 wxString * targetFileName = (wxString *)NULL; 00499 const char *envKeywords[] = {"FS", "VS", ""}; 00500 switch (tmpParser.KeywordsSwitch(envKeywords)) 00501 { 00502 case 0://FS 00503 target = &material->shader->fsSource; 00504 targetFileName = &material->shader->fsFileName; 00505 break; 00506 case 1://VS 00507 target = &material->shader->vsSource; 00508 targetFileName = &material->shader->vsFileName; 00509 break; 00510 default: 00511 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00512 } 00513 wxString shaderfilename(tmpParser.GetWxString().AfterFirst('\'').BeforeLast('\'')); 00514 if (target && wxFileName::FileExists(scenePath + shaderfilename)) 00515 { 00516 *targetFileName = scenePath + shaderfilename; 00517 wxFileInputStream fin(scenePath + shaderfilename); 00518 wxStringOutputStream ss(target); 00519 fin.Read(ss); 00520 } 00521 } 00522 break; 00523 case 1://OPENRT 00524 {//TODO 00525 material->shader->type = ShaderProgram::LANG_OPENRT; 00526 //const char *envKeywords[]={"RTXPhong", "RTXFresnelPhong1", ""}; 00527 } 00528 break; 00529 default: 00530 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00531 } 00532 } 00533 break; 00534 case 11://SHADERPARAM 00535 { 00536 if (!material->shader) 00537 { 00538 LOGERROR(wxT("<FHSParser>Shader not enabled")); 00539 return false; 00540 } 00541 ShaderParam param; 00542 const char *typeKeywords[] = {"GLSL", "OPENRT", ""}; 00543 if (tmpParser.KeywordsSwitch(typeKeywords) != 0) 00544 break; 00545 //wxString shadertype(tmpParser.GetWxString()); 00546 param.name = tmpParser.GetWxString(); 00547 const char *keywords[] = {"FLOAT", "FLOAT3", "FLOAT4", "COLOR", "BOOL", "SAMPLERCUBE", "SAMPLER2D", ""}; 00548 switch (tmpParser.KeywordsSwitch(keywords)) 00549 { 00550 case 0://FLOAT 00551 { 00552 size_t n = tmpParser.ParseVector(param.fVals, 0, true); 00553 if (n == 0) 00554 return false; 00555 param.type = ShaderParam::PARAM_TYPE(ShaderParam::FLOAT1); 00556 } 00557 break; 00558 case 1://FLOAT3 00559 case 2://FLOAT4 00560 case 3://COLOR 00561 case 4://BOOL 00562 { 00563 size_t n = tmpParser.ParseVector(param.fVals, 0, true); 00564 if (n == 0) 00565 return false; 00566 param.type = ShaderParam::PARAM_TYPE(ShaderParam::FLOAT1 + n - 1); 00567 } 00568 break; 00569 case 5://SAMPLERCUBE 00570 case 6://SAMPLER2D 00571 { 00572 param.type = ShaderParam::SAMPLER; 00573 wxString texPath = scenePath + tmpParser.GetWxLine().AfterFirst('\'').BeforeLast('\''); 00574 wxCommandEvent texEvt = Event::GET_EVT_SCENE_IMAGE_ADD(texPath); 00575 module->PostToKernel(texEvt); 00576 param.imageName = texPath; 00577 texturesImported++; 00578 } 00579 break; 00580 default: 00581 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00582 } 00583 material->shader->paramList.push_back(param); 00584 } 00585 break; 00586 case 12://MIXTEXTURE 00587 {//ve VD2 lze pouzit pouze je-li pouzito DECAL 00588 if (!tmpParser.ParseFloat(&material->textureMix)) 00589 return false; 00590 } 00591 break; 00592 case 13://BLENDFUNC 00593 { 00594 const char *envKeywords[] = {"None", "Zero", "One", "SrcColor", "OneMinusSrcColor", "DstColor", "OneMinusDstColor", "SrcAlpha", "OneMinusSrcAlpha", "DstAlpha", ""}; 00595 const GLuint values[] = {GL_ZERO, GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA}; 00596 GLuint * funcTgt = &material->texBlendSrc; 00597 for (int i = 0; i < 2; i++) 00598 { 00599 int index = tmpParser.KeywordsSwitch(envKeywords); 00600 if (i >= 0) 00601 *funcTgt = values[index]; 00602 else 00603 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00604 funcTgt = &material->texBlendDst; 00605 } 00606 material->flags |= Material::BLENDED; 00607 } 00608 break; 00609 case 14://ACTIVATE 00610 {//TODO, //ex: "ACTIVATE Shadow.so:poffset_on " 00611 wxString activate(tmpParser.GetWxLine()); 00612 } 00613 break; 00614 case 15://DEACTIVATE 00615 {//TODO, ex: "DEACTIVATE Shadow.so:poffset_off " 00616 wxString deactivate(tmpParser.GetWxLine()); 00617 } 00618 break; 00619 case 16://CUBETEX 00620 {//TODO 00621 int cubetexindex; 00622 if (!tmpParser.ParseInt(&cubetexindex)) 00623 return false; 00624 wxString cubetexname(tmpParser.GetWxLine()); 00625 } 00626 break; 00627 case 17://LINEWIDTH 00628 {//TODO 00629 float linewidth; 00630 if (!tmpParser.ParseFloat(&linewidth)) 00631 return false; 00632 } 00633 break; 00634 default: 00635 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00636 } 00637 } 00638 break; 00639 case 12://COLOR 00640 if (!textParser->ParseVector(color._v, 3)) 00641 return false; 00642 break; 00643 case 13://UNLIT 00644 material->flags |= Material::UNLIT; 00645 break; 00646 case 14://} 00647 cycle = false; 00648 break; 00649 default: 00650 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00651 } 00652 } 00653 return true; 00654 }
| bool FHSParser::parseMaterial | ( | ) | [private] |
Parse new material definition.
Definition at line 657 of file fhsparser.cpp.
00658 { 00659 wxString matName = textParser->GetWxString(); 00660 Material * material = new Material(matName); 00661 if (parseMaterialAttribs(material)) 00662 { 00663 wxCommandEvent ev = Event::GET_EVT_SCENE_MATERIAL_ADD(sceneID, material); 00664 module->PostToKernel(ev); 00665 materialsImported++; 00666 return true; 00667 } 00668 else 00669 { 00670 SAFE_DELETE(material); 00671 LOGERROR(wxT("<FHSParser>Failed parsing material '") + matName + wxT("'")); 00672 return false; 00673 } 00674 }
| bool FHSParser::parseEnvironmentBody | ( | const wxString & | nodeUid | ) | [private] |
Parse environment body.
Definition at line 677 of file fhsparser.cpp.
00678 { 00679 //TODO: real environment parameters must be assigned 00680 if (textParser->GetChar() != '{') 00681 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00682 const char *keywords[] = {"BACKGROUND", "AMBIENT", "ENVX", "}", ""}; 00683 bool cycle = true; 00684 while (cycle) 00685 { 00686 switch (textParser->KeywordsSwitch(keywords)) 00687 { 00688 case 0://BACKGROUND 00689 { 00690 VECTOR3 background; 00691 if (textParser->ParseVector(background._v, 3) != 3) 00692 return false; 00693 } 00694 break; 00695 case 1://AMBIENT 00696 { 00697 VECTOR3 ambient; 00698 if (textParser->ParseVector(ambient._v, 3) != 3) 00699 return false; 00700 } 00701 break; 00702 case 2://ENVX 00703 { 00704 //TODO 00705 TextParser tmpParser(textParser->GetString().c_str()); 00706 const char *envKeywords[] = {"FOGDENSITY", "FOGCOLOR", ""}; 00707 switch (tmpParser.KeywordsSwitch(envKeywords)) 00708 { 00709 case 0://FOGDENSITY 00710 { 00711 float fogdensity; 00712 if (!tmpParser.ParseFloat(&fogdensity)) 00713 return false; 00714 } 00715 break; 00716 case 1://FOGCOLOR 00717 { 00718 float fogcolor[4]; 00719 if (tmpParser.ParseVector(fogcolor, 4) != 4) 00720 return false; 00721 } 00722 break; 00723 default: 00724 logErrorMsg(UNEXPECTED, tmpParser.GetWxLine()); 00725 } 00726 } 00727 break; 00728 case 3://} 00729 cycle = false; 00730 break; 00731 default: 00732 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00733 } 00734 } 00735 return true; 00736 }
| bool FHSParser::parseEnvironmentAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse optional environment attributes.
Definition at line 739 of file fhsparser.cpp.
00740 { 00741 if (!parseCommonAttribs(nodeUid)) 00742 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00743 return true; 00744 }
| bool FHSParser::parseEnvironment | ( | const wxString & | parentUid | ) | [private] |
Parse environment definition.
Add new environment node
Definition at line 747 of file fhsparser.cpp.
00748 { 00749 //TODO: correct node type must be used 00751 wxString nodeName = textParser->GetWxString(); 00752 wxString nodeUid = getUniqueUid(nodeName); 00753 /* GeometryNode * node = new GeometryNode(nodeUid, nodeName); 00754 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 00755 module->PostToKernel(ev); 00756 nodesImported++;*/ 00757 00758 //parse attributes and body 00759 if (!parseEnvironmentAttribs(nodeUid) || !parseEnvironmentBody(nodeUid)) 00760 { 00761 LOGERROR(wxT("<FHSParser>Failed parsing environment '") + nodeUid + wxT("'")); 00762 return false; 00763 } 00764 LOGWARNING(wxT("Environment not implemented")); 00765 return true; 00766 }
| bool FHSParser::parseLightBody | ( | Light * | light | ) | [private] |
Parse light body.
Definition at line 769 of file fhsparser.cpp.
00770 { 00771 if (textParser->GetChar() != '{') 00772 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00773 const char *keywords[] = {"COLOR", "DIRECTION", "POSITION", "SPOTLIGHT", "LIGHTX", "}", ""}; 00774 bool cycle = true; 00775 while (cycle) 00776 { 00777 switch (textParser->KeywordsSwitch(keywords)) 00778 { 00779 case 0://COLOR 00780 if (textParser->ParseVector(light->diffuse._v, 3) != 3) 00781 return false; 00782 break; 00783 case 1://DIRECTION 00784 if (textParser->ParseVector(light->direction._v, 3) != 3) 00785 return false; 00786 switch (light->type) 00787 { 00788 case Light::UNKNOWN: 00789 case Light::DIRECTIONAL: 00790 light->type = Light::DIRECTIONAL; 00791 break; 00792 case Light::OMNI: 00793 case Light::SPOTLIGHT: 00794 light->type = Light::SPOTLIGHT; 00795 break; 00796 } 00797 break; 00798 case 2://POSITION 00799 if (textParser->ParseVector(light->position._v, 3) != 3) 00800 return false; 00801 switch (light->type) 00802 { 00803 case Light::UNKNOWN: 00804 case Light::OMNI: 00805 light->type = Light::OMNI; 00806 break; 00807 case Light::DIRECTIONAL: 00808 case Light::SPOTLIGHT: 00809 light->type = Light::SPOTLIGHT; 00810 break; 00811 } 00812 break; 00813 case 3://SPOTLIGHT 00814 { 00815 float spotlight[2]; 00816 if (textParser->ParseVector(spotlight, 2) != 2) 00817 return false; 00818 light->angle = spotlight[0]; 00819 light->exponent = spotlight[1]; 00820 light->type = Light::SPOTLIGHT; 00821 } 00822 break; 00823 case 4://LIGHTX 00824 textParser->GetWxString();//TODO 00825 break; 00826 case 5://} 00827 cycle = false; 00828 break; 00829 default: 00830 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00831 } 00832 } 00833 return true; 00834 }
| bool FHSParser::parseLightAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse optional light attributes.
Definition at line 837 of file fhsparser.cpp.
00838 { 00839 if (!parseCommonAttribs(nodeUid)) 00840 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00841 return true; 00842 }
| bool FHSParser::parseLight | ( | const wxString & | parentUid | ) | [private] |
Parse light definition.
Add new light node
Definition at line 845 of file fhsparser.cpp.
00846 { 00848 wxString nodeName = textParser->GetWxString(); 00849 wxString nodeUid = getUniqueUid(nodeName); 00850 LightNode * node = new LightNode(nodeUid, nodeName); 00851 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 00852 module->PostToKernel(ev); 00853 nodesImported++; 00854 00855 Light * light = new Light; 00856 //parse attributes and body 00857 if (!parseLightAttribs(nodeUid) || !parseLightBody(light)) 00858 { 00859 LOGERROR(wxT("<FHSParser>Failed parsing light '") + nodeUid + wxT("'")); 00860 SAFE_DELETE(light); 00861 return false; 00862 } 00863 00864 wxCommandEvent ev2 = Event::GET_EVT_SCENE_NODE_LIGHT_SET(sceneID, nodeUid, light); 00865 module->PostToKernel(ev2); 00866 lightsImported++; 00867 00868 return true; 00869 }
| bool FHSParser::parseGeometryBody | ( | const wxString & | nodeUid, | |
| GeometryTriangles * | geometry, | |||
| bool & | valid | |||
| ) | [private] |
Parse geometry body.
Definition at line 872 of file fhsparser.cpp.
00873 { 00874 valid = true; 00875 if (textParser->GetChar() != '{') 00876 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00877 std::vector<GeometryTriangles::Indice> * indices = &(geometry->indices); 00878 GeometryTriangles::TriDescList * triDescList = &geometry->triDescList; 00879 const char *keywords[] = {"TRIANGLES", "TRIANGLE_STRIP", "TRIFAN", "POLYGON", "LINES", "LINE_STRIP", "POINTS", "QUADS", "PRIMX", "USEMAT", "BOX", "}", ""}; 00880 bool cycle = true; 00881 while (cycle) 00882 { 00883 switch (textParser->KeywordsSwitch(keywords)) 00884 { 00885 case 0://TRIANGLES 00886 if (triDescList->empty() || triDescList->back().second != GeometryTriangles::TRI_LIST) 00887 { 00888 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_LIST); 00889 triDescList->push_back(indType); 00890 } 00891 if (!parseIndices(indices, geometry->vertices.size())) 00892 return false; 00893 break; 00894 case 1://TRIANGLE_STRIP 00895 { 00896 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_STRIP); 00897 triDescList->push_back(indType); 00898 if (!parseIndices(indices, geometry->vertices.size())) 00899 return false; 00900 } 00901 break; 00902 case 2://TRIFAN 00903 { 00904 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_FAN); 00905 triDescList->push_back(indType); 00906 } 00907 if (!parseIndices(indices, geometry->vertices.size())) 00908 return false; 00909 break; 00910 case 3://POLYGON 00911 { 00912 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::POLYGON); 00913 triDescList->push_back(indType); 00914 } 00915 if (!parseIndices(indices, geometry->vertices.size())) 00916 return false; 00917 break; 00918 case 4://LINES 00919 if (triDescList->empty() || triDescList->back().second != GeometryTriangles::LINES) 00920 { 00921 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::LINES); 00922 triDescList->push_back(indType); 00923 } 00924 if (!parseIndices(indices, geometry->vertices.size())) 00925 return false; 00926 break; 00927 case 5://LINE_STRIP 00928 { 00929 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::LINE_STRIP); 00930 triDescList->push_back(indType); 00931 } 00932 if (!parseIndices(indices, geometry->vertices.size())) 00933 return false; 00934 break; 00935 case 6://POINTS 00936 if (triDescList->empty() || triDescList->back().second != GeometryTriangles::POINTS) 00937 { 00938 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::POINTS); 00939 triDescList->push_back(indType); 00940 } 00941 if (!parseIndices(indices, geometry->vertices.size())) 00942 return false; 00943 break; 00944 case 7://QUADS 00945 if (triDescList->empty() || triDescList->back().second != GeometryTriangles::QUADS) 00946 { 00947 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::QUADS); 00948 triDescList->push_back(indType); 00949 } 00950 if (!parseIndices(indices, geometry->vertices.size())) 00951 return false; 00952 break; 00953 case 8://PRIMX 00954 { 00955 //wxString primx(textParser->GetWxString()); 00956 TextParser txtParser(textParser->GetWxString()); 00957 const char *keywords[] = {"FROM", ""}; 00958 switch (txtParser.KeywordsSwitch(keywords)) 00959 { 00960 case 0://FROM 00961 { 00962 wxCommandEvent ev3 = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeUid, txtParser.GetWxString()); 00963 module->PostToKernel(ev3); 00964 SAFE_DELETE(geometry); 00965 valid = false; 00966 size_t brackCount = 1; 00967 while (brackCount > 0) 00968 { 00969 switch (textParser->GetChar()) 00970 { 00971 case '{': 00972 brackCount++; 00973 break; 00974 case '}': 00975 brackCount--; 00976 break; 00977 } 00978 } 00979 return true; 00980 } 00981 default: 00982 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 00983 break; 00984 } 00985 } 00986 break; 00987 case 9://USEMAT 00988 { 00989 //TODO: solve USEMAT between TRIANGLES etc. 00990 wxString matName(textParser->GetWxString()); 00991 } 00992 break; 00993 case 10://BOX 00994 if (!parsePolyBox(geometry)) 00995 return false; 00996 break; 00997 case 11://} 00998 cycle = false; 00999 break; 01000 default: 01001 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01002 } 01003 } 01004 return true; 01005 }
| bool FHSParser::parseGeometryAttribs | ( | wxString & | nodeUid, | |
| GeometryTriangles * | geometry | |||
| ) | [private] |
Parse optional geometry attributes.
Definition at line 1210 of file fhsparser.cpp.
01211 { 01212 const char *keywords[] = {"USEMAT", "POLYPOOL", "RESOLUTION", ""};//geometry specific attributes 01213 while (!textParser->NextCharIs('{')) 01214 { 01215 if (!parseCommonAttribs(nodeUid)) 01216 { 01217 switch (textParser->KeywordsSwitch(keywords)) 01218 { 01219 case 0://USEMAT 01220 { 01221 //TODO: solve better missing materials 01222 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeUid, textParser->GetWxString()); 01223 module->PostToKernel(ev); 01224 } 01225 break; 01226 case 1://POLYPOOL 01227 if (!parsePolyPool(geometry)) 01228 return false; 01229 if (!geometry->texCoords.empty() && ( geometry->texCoords.size() != geometry->vertices.size() )) 01230 { 01231 LOGWARNING(wxT("<FHSParser>Texture coords count and vertices count mismatch")); 01232 for (size_t i=geometry->vertices.size()-geometry->texCoords.size(); i>0; i--) 01233 geometry->texCoords.push_back(GeometryTriangles::TexCoord()); 01234 } 01235 if (!geometry->normals.empty() && ( geometry->normals.size() != geometry->vertices.size() )) 01236 { 01237 LOGWARNING(wxT("<FHSParser>Normals count and vertices count mismatch")); 01238 for (size_t i=geometry->vertices.size()-geometry->normals.size(); i>0; i--) 01239 geometry->normals.push_back(VECTOR3()); 01240 } 01241 break; 01242 case 2://RESOLUTION 01243 { 01244 wxString resolution(textParser->GetWxString());//TODO 01245 } 01246 break; 01247 default: 01248 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01249 } 01250 } 01251 } 01252 return true; 01253 }
| bool FHSParser::parseGeometry | ( | const wxString & | parentUid | ) | [private] |
Parse geometry definition.
Add new geometry node
Create new mesh
Define mesh
Add geometry to scene
Assign geometry to node
Definition at line 1256 of file fhsparser.cpp.
01257 { 01259 wxString nodeName = textParser->GetWxString(); 01260 wxString nodeUid = getUniqueUid(nodeName); 01261 GeometryNode *node = new GeometryNode(nodeUid, nodeName); 01262 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01263 module->PostToKernel(ev); 01264 nodesImported++; 01265 nodesGeomImported++; 01267 //TODO: decide geometry type 01268 GeometryTriangles *geometry = new GeometryTriangles(nodeUid); 01269 01271 bool valid; 01272 if (!parseGeometryAttribs(nodeUid, geometry) || !parseGeometryBody(nodeUid, geometry, valid)) 01273 { 01274 SAFE_DELETE(geometry); 01275 LOGERROR(wxT("<FHSParser>Failed parsing geometry '") + nodeUid + wxT("'")); 01276 return false; 01277 } 01278 01279 //Do not do in the PRIMX case 01280 if (valid) 01281 { 01283 wxCommandEvent ev2 = Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry); 01284 module->PostToKernel(ev2); 01286 wxCommandEvent ev3 = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeUid, geometry->GetName()); 01287 module->PostToKernel(ev3); 01288 } 01289 return true; 01290 }
| bool FHSParser::parseSwitchAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse optional SWITCH attributes.
Definition at line 1293 of file fhsparser.cpp.
01294 { 01295 const char *keywords[] = {"USEMAT", "WHICHCHILD", ""};//assembly specific attributes 01296 while (!textParser->NextCharIs('{')) 01297 { 01298 if (!parseCommonAttribs(nodeUid)) 01299 { 01300 switch (textParser->KeywordsSwitch(keywords)) 01301 { 01302 case 0://USEMAT 01303 { 01304 //TODO: use it for childrens if they have not material 01305 wxString matName(textParser->GetWxString()); 01306 } 01307 break; 01308 case 1://WHICHCHILD 01309 { 01310 //TODO 01311 wxString whichchild(textParser->GetWxString()); 01312 } 01313 break; 01314 default: 01315 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01316 } 01317 } 01318 } 01319 return true; 01320 }
| bool FHSParser::parseSwitch | ( | const wxString & | parentUid | ) | [private] |
Parse SWITCH definition.
Add new node
Definition at line 1323 of file fhsparser.cpp.
01324 { 01326 wxString nodeName = textParser->GetWxString(); 01327 wxString nodeUid = getUniqueUid(nodeName); 01328 SceneNode * node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY);//TODO use correct node type 01329 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01330 module->PostToKernel(ev); 01331 nodesImported++; 01332 LOGWARNING(wxT("Swithch not implemented")); 01333 return parseSwitchAttribs(nodeUid) && parseAssemblyBody(nodeUid); 01334 }
| bool FHSParser::parseBillboardAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse optional BILLBOARD attributes.
Definition at line 1337 of file fhsparser.cpp.
01338 { 01339 const char *keywords[] = {"USEMAT", "AXIS", "XAXIS", "YAXIS", "ZAXIS", ""};//billboard specific attributes 01340 VECTOR3 axis; //TODO use axis from billboard node 01341 while (!textParser->NextCharIs('{')) 01342 { 01343 if (!parseCommonAttribs(nodeUid)) 01344 { 01345 switch (textParser->KeywordsSwitch(keywords)) 01346 { 01347 case 0://USEMAT 01348 { 01349 //TODO: use it for childrens if they have not material 01350 wxString matName(textParser->GetWxString()); 01351 } 01352 break; 01353 case 1://AXIS 01354 if (textParser->ParseVector(axis._v, 3) != 3) 01355 return false; 01356 break; 01357 case 2://XAXIS 01358 axis = vector3(1, 0, 0); 01359 break; 01360 case 3://YAXIS 01361 axis = vector3(0, 1, 0); 01362 break; 01363 case 4://ZAXIS 01364 axis = vector3(0, 0, 1); 01365 break; 01366 default: 01367 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01368 } 01369 } 01370 } 01371 return true; 01372 }
| bool FHSParser::parseBillboard | ( | const wxString & | parentUid | ) | [private] |
Parse BILLBOARD definition.
Add new node
Definition at line 1375 of file fhsparser.cpp.
01376 { 01378 wxString nodeName = textParser->GetWxString(); 01379 wxString nodeUid = getUniqueUid(nodeName); 01380 SceneNode * node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY);//TODO use correct node type 01381 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01382 module->PostToKernel(ev); 01383 nodesImported++; 01384 LOGWARNING(wxT("Billboard not implemented")); 01385 return parseBillboardAttribs(nodeUid) && parseAssemblyBody(nodeUid); 01386 }
| bool FHSParser::parseLOD | ( | const wxString & | parentUid, | |
| const bool | active | |||
| ) | [private] |
Parse LOD definition.
Add new node
Definition at line 1389 of file fhsparser.cpp.
01390 { 01392 wxString nodeName = textParser->GetWxString();//TODO use "name" as distance parameter 01393 wxString nodeUid = getUniqueUid(nodeName); 01394 SceneNode * node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY); 01395 node->SetActive(active); 01396 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01397 module->PostToKernel(ev); 01398 nodesImported++; 01399 01400 return parseAssemblyAttribs(nodeUid) && parseAssemblyBody(nodeUid); 01401 }
| bool FHSParser::parseLODAssemblyBody | ( | const wxString & | nodeUid | ) | [private] |
Parse LOD assembly body.
Definition at line 1404 of file fhsparser.cpp.
01405 { 01406 if (textParser->GetChar() != '{') 01407 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01408 const char *keywords[] = {"LOD", ""}; 01409 bool active=true; 01410 while (!textParser->NextCharIs('}')) 01411 { 01412 if (module->TestExit()) 01413 textParser->ForceEmpty(); 01414 01415 switch (textParser->KeywordsSwitch(keywords)) 01416 { 01417 case 0://LOD 01418 if (!parseLOD(nodeUid, active)) 01419 return false; 01420 active=false; 01421 break; 01422 default: 01423 return false; 01424 } 01425 } 01426 if (textParser->GetChar() != '}') 01427 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01428 return true; 01429 }
| bool FHSParser::parseLODAssembly | ( | const wxString & | parentUid | ) | [private] |
Parse LOD assembly definition.
Add new node
Definition at line 1432 of file fhsparser.cpp.
01433 { 01435 wxString nodeName = textParser->GetWxString(); 01436 wxString nodeUid = getUniqueUid(nodeName); 01437 SceneNode * node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY);//TODO use correct node type 01438 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01439 module->PostToKernel(ev); 01440 nodesImported++; 01441 LOGWARNING(wxT("LODAssembly not implemented")); 01442 return parseAssemblyAttribs(nodeUid) && parseLODAssemblyBody(nodeUid); 01443 }
| bool FHSParser::parseAssemblyBody | ( | const wxString & | nodeUid | ) | [private] |
Parse assembly body.
Definition at line 1446 of file fhsparser.cpp.
01447 { 01448 if (textParser->GetChar() != '{') 01449 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01450 if (!parseCommonBody(nodeUid)) 01451 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01452 if (textParser->GetChar() != '}') 01453 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01454 return true; 01455 }
| bool FHSParser::parseAssemblyAttribs | ( | wxString & | nodeUid | ) | [private] |
Parse optional assembly attributes.
Definition at line 1458 of file fhsparser.cpp.
01459 { 01460 const char *keywords[] = {"USEMAT", ""};//assembly specific attributes 01461 while (!textParser->NextCharIs('{')) 01462 { 01463 if (!parseCommonAttribs(nodeUid)) 01464 { 01465 switch (textParser->KeywordsSwitch(keywords)) 01466 { 01467 case 0://USEMAT 01468 { 01469 //TODO: use it for childrens if they have not material 01470 wxString matName(textParser->GetWxString()); 01471 } 01472 break; 01473 default: 01474 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01475 } 01476 } 01477 } 01478 return true; 01479 }
| bool FHSParser::parseAssembly | ( | const wxString & | parentUid | ) | [private] |
Parse assembly definition.
Add new node
Definition at line 1482 of file fhsparser.cpp.
01483 { 01485 wxString nodeName = textParser->GetWxString(); 01486 wxString nodeUid = getUniqueUid(nodeName); 01487 SceneNode * node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY); 01488 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid); 01489 module->PostToKernel(ev); 01490 nodesImported++; 01491 01492 return parseAssemblyAttribs(nodeUid) && parseAssemblyBody(nodeUid); 01493 }
| bool FHSParser::parseModelAttribs | ( | const wxString & | nodeUid | ) | [private] |
Parse optional model attributes.
Add geometry to scene
Assign geometry to node
Definition at line 1496 of file fhsparser.cpp.
01497 { 01498 const char *keywords[] = {"FHSVERSION", "POINTORDER", "DEFMAT", "CIRCLE", ""};//model specific attributes 01499 while (!textParser->IsEmpty()) 01500 { 01501 if (!parseCommonBody(nodeUid)) 01502 { 01503 switch (textParser->KeywordsSwitch(keywords)) 01504 { 01505 case 0://FHSVERSION 01506 if (!textParser->NextKeywordIs("1100")) 01507 LOGWARNING(wxT("<FHSParser>Unknown FHSVERSION") + textParser->GetWxLine()); 01508 break; 01509 case 1://POINTORDER 01510 if (!textParser->NextKeywordIs("COUNTERCLOCKWISE")) 01511 return logErrorMsg(UNEXPECTED, wxT("POINTORDER ") + textParser->GetWxLine()); 01512 break; 01513 case 2://DEFMAT 01514 if (!parseMaterial()) 01515 return false; 01516 break; 01517 case 3: 01518 { 01519 //create geometry 01520 GeometryNode *node = new GeometryNode(nodeUid+wxT("Geometry"), nodeUid+wxT("Geometry")); 01521 wxCommandEvent ev3(Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, nodeUid)); 01522 module->PostToKernel(ev3); 01523 01524 //add material to the geometry node 01525 wxCommandEvent ev4(Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeUid+wxT("Geometry"), wxT("CIRCLE"))); 01526 module->PostToKernel(ev4); 01527 01528 //Create new mesh 01529 GeometryTriangles *geometry = new GeometryTriangles(nodeUid+wxT("Geometry")); 01530 std::vector<VECTOR3> * verts = &(geometry->vertices); 01531 std::vector<VECTOR3> * normals = &(geometry->normals); 01532 std::vector<GeometryTriangles::TexCoord> * texCoords = &(geometry->texCoords); 01533 std::vector<GeometryTriangles::Indice> * indices = &(geometry->indices); 01534 GeometryTriangles::TriDescList * triDescList = &geometry->triDescList; 01535 01536 /* //smooth road 01537 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_STRIP); 01538 triDescList->push_back(indType); 01539 float anglestep=360.0f/3600.0f; 01540 for (float angle=0; angle<360.0f; angle+=anglestep) 01541 { 01542 verts->push_back(VECTOR3(170000*cos(angle/180*3.14159),170000*sin(angle/180*3.14159),0)); 01543 verts->push_back(VECTOR3(180000*cos(angle/180*3.14159),180000*sin(angle/180*3.14159),0)); 01544 normals->push_back(VECTOR3(0,0,1)); 01545 normals->push_back(VECTOR3(0,0,1)); 01546 texCoords->push_back(GeometryTriangles::TexCoord(0,angle/360.0f)); 01547 texCoords->push_back(GeometryTriangles::TexCoord(1,angle/360.0f)); 01548 indices->push_back((GeometryTriangles::Indice)indices->size()); 01549 indices->push_back((GeometryTriangles::Indice)indices->size()); 01550 } 01551 //Last segment 01552 verts->push_back(verts->at(0)); 01553 verts->push_back(verts->at(1)); 01554 normals->push_back(VECTOR3(0,0,1)); 01555 normals->push_back(VECTOR3(0,0,1)); 01556 texCoords->push_back(GeometryTriangles::TexCoord(0,1)); 01557 texCoords->push_back(GeometryTriangles::TexCoord(1,1)); 01558 indices->push_back((GeometryTriangles::Indice)indices->size()); 01559 indices->push_back((GeometryTriangles::Indice)indices->size()); 01560 */ 01561 01562 //bumpy road 01563 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_STRIP); 01564 triDescList->push_back(indType); 01565 float anglestep=360.0f/10800.0f; 01566 float ih=0.0f, oh=0.0f; 01567 for (float angle=0.0f; angle<360.0f; angle+=anglestep) 01568 { 01569 float ca=cos(angle/180*3.14159); 01570 float sa=sin(angle/180*3.14159); 01571 ih=(float)rand()/RAND_MAX*50; 01572 oh=(float)rand()/RAND_MAX*50; 01573 verts->push_back(VECTOR3(170000*sa, 170000*ca-175000,0)); 01574 verts->push_back(VECTOR3(174000*sa, 174000*ca-175000,ih)); 01575 LOG(wxString::Format(wxT("%g\t%g"), -175000*sa, 175000*ca-175000)); 01576 verts->push_back(VECTOR3(176000*sa, 176000*ca-175000,oh)); 01577 verts->push_back(VECTOR3(180000*sa, 180000*ca-175000,0)); 01578 normals->push_back(VECTOR3(0,0,1)); 01579 normals->push_back(VECTOR3(0,0,1)); 01580 normals->push_back(VECTOR3(0,0,1)); 01581 normals->push_back(VECTOR3(0,0,1)); 01582 texCoords->push_back(GeometryTriangles::TexCoord(angle/360.0f, 0)); 01583 texCoords->push_back(GeometryTriangles::TexCoord(angle/360.0f, 0.4)); 01584 texCoords->push_back(GeometryTriangles::TexCoord(angle/360.0f, 0.6)); 01585 texCoords->push_back(GeometryTriangles::TexCoord(angle/360.0f, 1)); 01586 //inner segment 01587 indices->push_back((GeometryTriangles::Indice)verts->size()-3); 01588 indices->push_back((GeometryTriangles::Indice)verts->size()-4); 01589 } 01590 //Last segment 01591 verts->push_back(verts->at(0)); 01592 verts->push_back(verts->at(1)); 01593 verts->push_back(verts->at(2)); 01594 verts->push_back(verts->at(3)); 01595 normals->push_back(VECTOR3(0,0,1)); 01596 normals->push_back(VECTOR3(0,0,1)); 01597 normals->push_back(VECTOR3(0,0,1)); 01598 normals->push_back(VECTOR3(0,0,1)); 01599 texCoords->push_back(GeometryTriangles::TexCoord(1, 0)); 01600 texCoords->push_back(GeometryTriangles::TexCoord(1, 0.4)); 01601 texCoords->push_back(GeometryTriangles::TexCoord(1, 0.6)); 01602 texCoords->push_back(GeometryTriangles::TexCoord(1, 1)); 01603 //inner segment 01604 indices->push_back((GeometryTriangles::Indice)verts->size()-3); 01605 indices->push_back((GeometryTriangles::Indice)verts->size()-4); 01606 //middle segment 01607 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType2((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_STRIP); 01608 triDescList->push_back(indType2); 01609 for (GeometryTriangles::Indice index=1; index<verts->size(); index+=4) 01610 { 01611 indices->push_back(index+1); 01612 indices->push_back(index); 01613 } 01614 //outer segment 01615 std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType3((GeometryTriangles::Indice)indices->size(), GeometryTriangles::TRI_STRIP); 01616 triDescList->push_back(indType3); 01617 for (GeometryTriangles::Indice index=2; index<verts->size(); index+=4) 01618 { 01619 indices->push_back(index+1); 01620 indices->push_back(index); 01621 } 01622 01624 wxCommandEvent ev5(Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry)); 01625 module->PostToKernel(ev5); 01627 wxCommandEvent ev6(Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeUid+wxT("Geometry"), geometry->GetName())); 01628 module->PostToKernel(ev6); 01629 } 01630 default: 01631 if (textParser->IsEmpty()) 01632 return true; 01633 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01634 } 01635 } 01636 else if (!textParser->IsEmpty()) 01637 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01638 } 01639 return true; 01640 }
| bool FHSParser::parseModel | ( | const wxString & | nodeUid | ) | [private] |
Parsing entry point
true if parsing ended up well Model name
Definition at line 1643 of file fhsparser.cpp.
01644 { 01645 if (textParser->NextKeywordIs("MODEL")) 01646 { 01648 wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_NAME_SET(sceneID, nodeUid, textParser->GetWxString()); 01649 module->PostToKernel(ev); 01650 return parseModelAttribs(nodeUid); 01651 } 01652 else 01653 return logErrorMsg(UNEXPECTED, textParser->GetWxLine()); 01654 }
| bool FHSParser::Parse | ( | const wxString & | rootUid | ) |
Parse FHS stream and build scene graph
| [in] | rootUid | Uid of node that will be root of imported scene |
true if successful Definition at line 1657 of file fhsparser.cpp.
01658 { 01659 if (!parseModel(rootUid)) 01660 { 01661 LOGERROR(wxT("<FHSParser>Scene not parsed properly")); 01662 return false; 01663 } 01664 LOG(wxString::Format( 01665 wxT("<FHSParser>Nodes parsed: %i (%i geometry nodes, %i light nodes)"), 01666 nodesImported, nodesGeomImported, lightsImported)); 01667 LOG(wxString::Format( 01668 wxT("<FHSParser>Materials parsed: %i\tTextures parsed: %i "), 01669 materialsImported, texturesImported)); 01670 01671 return true; 01672 }
TextParser* VRUT::FHSParser::textParser [private] |
SCENE_ID VRUT::FHSParser::sceneID [private] |
wxString VRUT::FHSParser::scenePath [private] |
Module* VRUT::FHSParser::module [private] |
unsigned VRUT::FHSParser::nodesImported [private] |
unsigned VRUT::FHSParser::nodesGeomImported [private] |
unsigned VRUT::FHSParser::materialsImported [private] |
unsigned VRUT::FHSParser::texturesImported [private] |
unsigned VRUT::FHSParser::lightsImported [private] |
NodeUidsList VRUT::FHSParser::nodeUidsList [private] |
List of nodes' uid used during import to assure they are unique.
Definition at line 50 of file fhsparser.h.
1.5.5