void IDefReader::processScriptItemNode( P_ITEM madeItem, QDomElement &Node ) { for( UI16 k = 0; k < Node.childNodes().count(); k++ ) { QDomElement currChild = Node.childNodes().item( k ).toElement(); if( currChild.nodeName() == "amount" ) { QString Value = QString(); UI16 i = 0; if( currChild.hasChildNodes() ) // <random> i.e. for( i = 0; i < currChild.childNodes().count(); i++ ) { if( currChild.childNodes().item( i ).isText() ) Value += currChild.childNodes().item( i ).toText().data(); else if( currChild.childNodes().item( i ).isElement() ) Value += processNode( currChild.childNodes().item( i ).toElement() ); } else Value = currChild.nodeValue(); if( Value.toInt() < 1 ) Value = QString("1"); if( madeItem->isPileable() ) madeItem->setAmount( Value.toInt() ); else for( i = 1; i < Value.toInt(); i++ ) //dupe it n-1 times Commands->DupeItem(-1, madeItem, 1); } else if( currChild.nodeName() == "color" ) //process <color> tags { QString Value = QString(); if( currChild.hasChildNodes() ) // colorlist or random i.e. for( UI16 i = 0; i < currChild.childNodes().count(); i++ ) { if( currChild.childNodes().item( i ).isText() ) Value += currChild.childNodes().item( i ).toText().data(); else if( currChild.childNodes().item( i ).isElement() ) Value += processNode( currChild.childNodes().item( i ).toElement() ); } else Value = currChild.nodeValue(); if( Value.toInt() < 0 ) Value = QString("0"); madeItem->setColor( Value.toInt() ); } else if( currChild.nodeName() == "inherit" && currChild.attributes().contains("id") ) { QDomElement* derivalSection = DefManager->getSection( WPDT_ITEM, currChild.attribute("id") ); if( !derivalSection->isNull() ) this->applyNodes( madeItem, derivalSection ); } } }
Path PathCreator::calculatePath(DebugNode* start, DebugNode* end) { startNode = start; endNode = end; PathingNode* currentParentNode; for(processNode(start, 0, NULL), currentParentNode=processedNodes[0]; !endNodeHasLowestTEC() && openNodesRemaining(); currentParentNode = getOpenNodeWithLowestTEC()) { currentParentNode->open=false; for(int i = 0; i<currentParentNode->node->numConnections; i++) { float connectionCostSquared = glm::pow(currentParentNode->node->connections[i]->cost, 2.0f); float costSoFar = connectionCostSquared + currentParentNode->costSoFar; processNode(currentParentNode->node->connections[i]->node, costSoFar, currentParentNode); } } Path p = Path(nullptr, 0); if(openNodesRemaining())//If the end node could actually be reached { QList <DebugNode*> reversePath; bool reachedStartNode = false; uint numNodesInPath = 0; PathingNode* currentNode = currentParentNode;//current parent node will be end node while(!reachedStartNode) { reversePath.prepend(currentNode->node); numNodesInPath++; if(currentNode->node == startNode) { reachedStartNode = true; } else { currentNode = currentNode->parentNode; } } DebugNode** path = new DebugNode*[numNodesInPath]; for(uint i = 0; i<numNodesInPath; i++) { path[i] = reversePath[i]; } reversePath.clear(); p = Path(path, numNodesInPath); } else { cout << "IMPOSSIBLE PATH" << endl; } processedNodes.clear(); return p; }
//----------------------------------------------------------------------- bool BspRaySceneQuery::processNode(const BspNode* node, const Ray& tracingRay, RaySceneQueryListener* listener, Real maxDistance, Real traceDistance) { if (node->isLeaf()) { return processLeaf(node, tracingRay, listener, maxDistance, traceDistance); } bool res = true; std::pair<bool, Real> result = tracingRay.intersects(node->getSplitPlane()); if (result.first && result.second < maxDistance) { // Crosses the split plane, need to perform 2 queries // Calculate split point ray Vector3 splitPoint = tracingRay.getOrigin() + tracingRay.getDirection() * result.second; Ray splitRay(splitPoint, tracingRay.getDirection()); if (node->getSide(tracingRay.getOrigin()) == Plane::NEGATIVE_SIDE) { // Intersects from -ve side, so do back then front res = processNode( node->getBack(), tracingRay, listener, result.second, traceDistance); if (!res) return res; res = processNode( node->getFront(), splitRay, listener, maxDistance - result.second, traceDistance + result.second); } else { // Intersects from +ve side, so do front then back res = processNode(node->getFront(), tracingRay, listener, result.second, traceDistance); if (!res) return res; res = processNode(node->getBack(), splitRay, listener, maxDistance - result.second, traceDistance + result.second); } } else { // Does not cross the splitting plane, just cascade down one side res = processNode(node->getNextNode(tracingRay.getOrigin()), tracingRay, listener, maxDistance, traceDistance); } return res; }
/** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. */ static void streamFile(const char *filename) { xmlTextReaderPtr reader; int ret; #define VALIDATEDTD #ifdef VALIDATEDTD /* * Pass some special parsing options to activate DTD attribute defaulting, * entities substitution and DTD validation */ reader = xmlReaderForFile(filename, NULL, XML_PARSE_DTDATTR | /* default DTD attributes */ XML_PARSE_NOENT | /* substitute entities */ XML_PARSE_DTDVALID); /* validate with the DTD */ #else reader = xmlReaderForFile(filename, NULL, 0); #endif if (reader != NULL) { ret = xmlTextReaderRead(reader); while (ret == 1) { processNode(reader); ret = xmlTextReaderRead(reader); } xmlFreeTextReader(reader); if (ret != 0) { fprintf(stderr, "%s : failed to parse\n", filename); } } else { fprintf(stderr, "Unable to open %s\n", filename); } }
int main(int argc, char *argv[]) { xmlTextReaderPtr reader; int ret; // Readerの作成 reader = xmlNewTextReaderFilename("./sample.xml"); if ( !reader ) { printf("Failed to open XML file.\n"); return 1; } printf("-----------------------\n"); // 次のノードに移動 ret = xmlTextReaderRead(reader); while (ret == 1) { // 現在のノードを処理 processNode(reader); // 次のノードに移動 ret = xmlTextReaderRead(reader); } // Reader のすべてのリソースを開放 xmlFreeTextReader(reader); // xmlTextReaderRead の戻り値が -1 だった場合はパースエラー if (ret == -1) { printf("Parse error.\n"); return 1; } return 0; }
void Editor_Html2Usfm::processNode (xml_node node) { switch (node.type ()) { case node_element: { openElementNode (node); for (xml_node child : node.children()) { processNode (child); } closeElementNode (node); break; } case node_pcdata: { // Add the text to the current USFM line. string text = node.text ().get (); currentLine += text; break; } default: { string nodename = node.name (); Database_Logs::log ("Unknown XML node " + nodename + " while saving editor text"); break; } } }
int streamFileXML2(char *filename, int sanitize, struct osmdata_t *osmdata) { xmlTextReaderPtr reader; int ret = 0; if (sanitize) reader = sanitizerOpen(filename); else reader = inputUTF8(filename); if (reader != NULL) { ret = xmlTextReaderRead(reader); while (ret == 1) { processNode(reader, osmdata); ret = xmlTextReaderRead(reader); } if (ret != 0) { fprintf(stderr, "%s : failed to parse\n", filename); return ret; } xmlFreeTextReader(reader); } else { fprintf(stderr, "Unable to open %s\n", filename); return 1; } return 0; }
void DotSceneLoader::processNodes(rapidxml::xml_node<>* XMLNode) { rapidxml::xml_node<>* pElement; // Process node (*) pElement = XMLNode->first_node("node"); while (pElement) { processNode(pElement); pElement = pElement->next_sibling("node"); } // Process position (?) pElement = XMLNode->first_node("position"); if (pElement) { mAttachNode->setPosition(parseVector3(pElement)); mAttachNode->setInitialState(); } // Process rotation (?) pElement = XMLNode->first_node("rotation"); if (pElement) { mAttachNode->setOrientation(parseQuaternion(pElement)); mAttachNode->setInitialState(); } // Process scale (?) pElement = XMLNode->first_node("scale"); if (pElement) { mAttachNode->setScale(parseVector3(pElement)); mAttachNode->setInitialState(); } }
int main(int argc, char *argv[]) { LIBXML_TEST_VERSION // xmlTextReaderPtr reader = xmlReaderForFile("/run/media/svartalf/storage/wikipedia/ruwiki-20140706-pages-meta-history1.xml", NULL, 0); xmlTextReaderPtr reader = xmlReaderForFile("/tmp/test.xml", NULL, 0); FILE *output = fopen("/tmp/output.bin", "w"); output_write_header(output); Revision *rev = revision_create(); int result = xmlTextReaderRead(reader); while (result == 1) { processNode(reader, rev); result = xmlTextReaderRead(reader); if (revision_filled(rev)) { output_write_row(output, rev); revision_clear(rev); } } output_close(output); xmlFreeTextReader(reader); if (result != 0) { fprintf(stderr, "failed to parse: %d\n", result); } xmlCleanupParser(); return 0; }
void processNode(FbxNode *node,GameObject *rootGo) { PrintTabs(); const char* nodeName = node->GetName(); FbxDouble3 translation = node->LclTranslation.Get(); FbxDouble3 rotation = node->LclRotation.Get(); FbxDouble3 scaling = node->LclScaling.Get(); std::cout << "Node " << nodeName << " Postion " << translation[0] << " " << translation[1] << " " << translation[2] << " " << " Rotation " << rotation[0] << " " << rotation[1] << " " << rotation[2] << " " << " Scale " << scaling[0] << " " << scaling[1] << " " << scaling[2] << std::endl; level++; GameObject * go = new GameObject(); go->setTransform(new Transform()); rootGo->addChild(go); // Print the node's attributes. for (int i = 0; i < node->GetNodeAttributeCount(); i++){ processAttribute(node->GetNodeAttributeByIndex(i), go); } // Recursively print the children. for (int j = 0; j < node->GetChildCount(); j++) processNode(node->GetChild(j), rootGo); level--; PrintTabs(); }
void fbxLoader2::processNode(FbxNode* node) { //FbxNodeAttribute::EType attributeType; if(node->GetNodeAttribute()) { switch(node->GetNodeAttribute()->GetAttributeType()) { case FbxNodeAttribute::eMesh: processMesh(node); break; case FbxNodeAttribute::eSkeleton: break; case FbxNodeAttribute::eLight: break; case FbxNodeAttribute::eCamera: break; } } for(int i = 0; i<node->GetChildCount(); i++) { processNode(node->GetChild(i)); } }
void DotSceneLoader::processNodes(TiXmlElement* xmlNode) { TiXmlElement *element; // Process node (*) element = xmlNode->FirstChildElement("node"); while(element) { processNode(element); element = element->NextSiblingElement("node"); } // Process position (?) element = xmlNode->FirstChildElement("position"); if(element) { rootNode->setPosition(parseVector3(element)); } // Process rotation (?) element = xmlNode->FirstChildElement("rotation"); if(element) { rootNode->setOrientation(parseQuaternion(element)); } // Process scale (?) element = xmlNode->FirstChildElement("scale"); if(element) { rootNode->setScale(parseVector3(element)); } }
void ParticleScriptCompiler::compileAffector(const ScriptNodePtr &node) { if(node->children.empty() || node->children.front()->type != SNT_WORD) return; // Create the emitter based on the first child ParticleAffector *affector = 0; String type = node->children.front()->token; try{ affector = mSystem->addAffector(type); }catch(...){ addError(CE_OBJECTALLOCATIONERROR, node->children.front()->file, node->children.front()->line, node->children.front()->column); return; } // Jump ahead now to the '{' as the emitter does not support other parameters in the header ScriptNodeList::iterator i = findNode(node->children.begin(), node->children.end(), SNT_LBRACE); if(i == node->children.end()) return; ScriptNodeList::iterator j = (*i)->children.begin(); while(j != (*i)->children.end()) { if(!processNode(j, (*i)->children.end())) { String name = (*j)->token, value = getParameterValue((*j)->children.begin(), (*j)->children.end()); if(!affector->setParameter(name, value)) addError(CE_INVALIDPROPERTY, (*j)->file, (*j)->line, (*j)->column); ++j; } } }
bool core::ModelLoader::loadModel(const char *fp, Model *m){ Assimp::Importer importer; const aiScene *scene = importer.ReadFile(fp, aiProcess_Triangulate | aiProcess_OptimizeMeshes | aiProcess_JoinIdenticalVertices | aiProcess_FlipUVs); if(!scene) return false; m->rootPath = (std::string)fp; for(int x = m->rootPath.size() - 1; x >= 0; x--){ if(m->rootPath[x] == '/' || m->rootPath[x] == '\\'){ m->rootPath = m->rootPath.substr(0, x + 1); x = -1; } } processAnimations(scene, m); processNode(scene, scene->mRootNode, m); if(scene->HasAnimations()) m->animations[m->currentAnim].buildBoneTree(scene, scene->mRootNode, &m->animations[m->currentAnim].root, m); m->modelTrans = glm::mat4(1.f); m->modelLoaded = true; return true; };
// If it's a leaf, update the lower bound. // Otherwise, process it. void tryProcessNode(Knapsack* ks, Heap* h, Node* n) { int i; pthread_rwlock_rdlock(&ks->_lblock); int lb = ks->_lowerBound; pthread_rwlock_unlock(&ks->_lblock); if (n->_depth >= (ks->_nbItems-1)) { if (n->_value > (double)lb) { pthread_rwlock_wrlock(&ks->_lblock); // Double checking the value of lowerbound; there's an edge case where // another thread could update it between these two locks if (n->_value > ks->_lowerBound) { printf("tighten LB to %d\n", n->_value); ks->_lowerBound = n->_value; pthread_rwlock_unlock(&ks->_lblock); for (i=0; i<n->_depth+1; i++) { ks->_bestX[i] = n->_x[i]; } for (i=n->_depth+1; i<ks->_nbItems; i++) { ks->_bestX[i] = 0; } } else { pthread_rwlock_unlock(&ks->_lblock); } } destroyNode(n); pthread_mutex_lock(&ks->_counterMutex); (ks->_nodesProcessed)++; pthread_mutex_unlock(&ks->_counterMutex); } else { processNode(ks, h, n); } }
bool LevelGeometryLoader::processNodes(TiXmlElement *XMLNode) { ASSERT(XMLNode); TiXmlElement *pElement; XMLNode = XMLNode->FirstChildElement("nodes"); if(!XMLNode){ debugWARNING("No entities found in the scene\n"); return false; } // Process node (*) pElement = XMLNode->FirstChildElement("node"); while(pElement) { Ogre::SceneNode *node = 0; if(!processNode(pElement, node)){ debugERROR("Error processing node\n"); ASSERT(false); return false; } pElement = pElement->NextSiblingElement("node"); ASSERT(node); ASSERT(node->getAttachedObject(0)); // we have something attached mEntities.push_back(node); } return true; }
static void handleFile(const char *filename) { xmlTextReaderPtr reader; int ret; if (count) { elem = 0; attrs = 0; } reader = xmlNewTextReaderFilename(filename); if (reader != NULL) { if (valid) xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE, 1); /* * Process all nodes in sequence */ ret = xmlTextReaderRead(reader); while (ret == 1) { processNode(reader); ret = xmlTextReaderRead(reader); } /* * Done, cleanup and status */ xmlFreeTextReader(reader); if (ret != 0) { printf("%s : failed to parse\n", filename); } else if (count) printf("%s : %d elements, %d attributes\n", filename, elem, attrs); } else { fprintf(stderr, "Unable to open %s\n", filename); } }
/** * streamFile: * @filename: the file name to parse * * Parse, validate and print information about an XML file. */ static void streamFile(const char *filename) { xmlTextReaderPtr reader; int ret; /* * Pass some special parsing options to activate DTD attribute defaulting, * entities substitution and DTD validation */ reader = xmlReaderForFile(filename, NULL, XML_PARSE_DTDATTR | /* default DTD attributes */ XML_PARSE_NOENT | /* substitute entities */ XML_PARSE_DTDVALID); /* validate with the DTD */ if (reader != NULL) { ret = xmlTextReaderRead(reader); while (ret == 1) { processNode(reader); ret = xmlTextReaderRead(reader); } /* * Once the document has been fully parsed check the validation results */ if (xmlTextReaderIsValid(reader) != 1) { fprintf(stderr, "Document %s does not validate\n", filename); } xmlFreeTextReader(reader); if (ret != 0) { fprintf(stderr, "%s : failed to parse\n", filename); } } else { fprintf(stderr, "Unable to open %s\n", filename); } }
void Model::loadModel(std::string path) { // initialize importer, transform model primitives to triangles and flip texCoords y axis Assimp::Importer importer; const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { Utils::exitMessage("Assimp Error", importer.GetErrorString()); } directory = path.substr(0, path.find_last_of('/')); processNode(scene->mRootNode, scene); //std::vector<Vertex> concVertices = meshes[5].vertices; //std::vector<GLuint> concIndices = meshes[5].indices; //std::vector<Texture> concTextures = meshes[5].textures; //concVertices.insert(concVertices.end(), meshes[6].vertices.begin(), meshes[6].vertices.end()); //concIndices.insert(concIndices.end(), meshes[6].indices.begin(), meshes[6].indices.end()); //concTextures.insert(concTextures.end(), meshes[6].textures.begin(), meshes[6].textures.end()); //int offset = meshes[5].indices.size(); //for (int i = offset; i < concIndices.size(); i++) //{ // concIndices[i] = concIndices[i] + offset; //} //Mesh(concVertices, concIndices, concTextures); ////meshes[5] = meshes[6]; //meshes.pop_back(); //meshes.pop_back(); //meshes.push_back(Mesh(concVertices, concIndices, concTextures)); }
// load model if not yet cached void Model::load(const std::string& path) { m_pMeshes = std::make_shared<std::vector<Mesh>>(); m_ShaderID = ShaderLoader::Instance().getProgram("Default"); m_MVPMatrixLocation = glGetUniformLocation(m_ShaderID, "mvpMatrix"); m_TextureFrontSamplerLocation = glGetUniformLocation(m_ShaderID, "textureFrontSampler"); m_TextureSideSamplerLocation = glGetUniformLocation(m_ShaderID, "textureSideSampler"); m_ChinVerticalPosLocation = glGetUniformLocation(m_ShaderID, "chinVerticalPos"); m_EyeVerticalPosLocation = glGetUniformLocation(m_ShaderID, "eyeVerticalPos"); m_LEyeTexVerticalPosLocation = glGetUniformLocation(m_ShaderID, "LEyeVerticalTexPos"); m_REyeTexVerticalPosLocation = glGetUniformLocation(m_ShaderID, "REyeVerticalTexPos"); m_ChinTexVerticalPosLocation = glGetUniformLocation(m_ShaderID, "ChinTexVerticalPos"); // Create an instance of the importer class Assimp::Importer importer; // Read in the given file into a scene and set some (example) postprocessing const aiScene *scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenNormals);// | aiProcess_FlipUVs); if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { std::string error = importer.GetErrorString(); throw std::exception("Failed to load model. ASSIMP-ERROR"); } // Start processing nodes processNode(scene->mRootNode, scene); }
bool Model::loadFBXFromFile(const string& fileName) { //initialize the sdk manager FbxManager *manager = FbxManager::Create(); //setting up the IO settings object FbxIOSettings *settings = FbxIOSettings::Create(manager, IOSROOT); manager->SetIOSettings(settings); //creating the importer FbxImporter *importer = FbxImporter::Create(manager, ""); //initializing the importer with contents of file if (!importer->Initialize(fileName.c_str(), -1, settings)) return false; //creating a scene to be filled with objects FbxScene *scene = FbxScene::Create(manager, "myScene"); importer->Import(scene); FbxGeometryConverter geomConverter(manager); geomConverter.Triangulate(scene, true); FbxNode *root = scene->GetRootNode(); if (root) { //printf("Root Node: %s\n", root->GetName()); int childCount = root->GetChildCount(); for (int i = 0; i < childCount; i++) processNode(root->GetChild(i), 1); } importer->Destroy(); return true; }
int Model::processNode(FbxNode *node, int level, Data &model) { const char* nodeName = node->GetName(); FbxDouble3 translation = node->LclTranslation.Get(); FbxDouble3 rotation = node->LclRotation.Get(); FbxDouble3 scaling = node->LclScaling.Get(); LOG(INFO) << "Node " << nodeName << " Postion " << translation[0] << " " << translation[1] << " " << translation[2] << " " << " Rotation " << rotation[0] << " " << rotation[1] << " " << rotation[2] << " " << " Scale " << scaling[0] << " " << scaling[1] << " " << scaling[2]; level++; model.model.push_back(new Data()); // Print the node's attributes. for (int i = 0; i < node->GetNodeAttributeCount(); i++) { processAttribute(node->GetNodeAttributeByIndex(i), level, model); } // Recursively print the children. for (int j = 0; j < node->GetChildCount(); j++) processNode(node->GetChild(j), level, model); level--; return level; }
void Editor_Export::processNodeChildren (xmlNodePtr node) { node = node->xmlChildrenNode; while (node != NULL) { processNode (node); node = node->next; } }
void Editor_Export::processNoteCitation (xmlNodePtr node) { // Remove the note citation from the text. xmlNodePtr child = node->xmlChildrenNode; while (child != NULL) { xmlNodePtr cache = child; child = child->next; xmlUnlinkNode (cache); xmlFree (cache); } // Get more information about the footnote to retrieve. string href; string id; xmlChar * property = xmlGetProp (node, BAD_CAST "href"); if (property) { href = (char *) property; xmlFree (property); id = href.substr (1); } // Sample footnote body. // <p class="x"><a href="#citation1" id="note1">x</a><span> </span><span>+ 2 Joh. 1.1</span></p> // Retrieve the <a> element from it. // At first this was done through an XPath expression: // http://www.grinninglizard.com/tinyxml2docs/index.html // But XPath crashes on Android. // Therefore now it iterates of all the nodes to find the required <a> element. xmlNodePtr aElement = get_note_pointer (xmlDocGetRootElement (document), id); if (aElement) { // It now has the 'a' element: Get its 'p' parent, and then remove that 'a' element. // So we remain with: // <p class="x"><span> </span><span>+ 2 Joh. 1.1</span></p> xmlNodePtr pElement = aElement->parent; xmlUnlinkNode (aElement); xmlFree (aElement); // Preserve active character styles in the main text, and reset them for the note. vector <string> preservedCharacterStyles = characterStyles; characterStyles.clear(); // Process this 'p' element. processingNote = true; processNode (pElement); processingNote = false; // Restore the active character styles for the main text. characterStyles = preservedCharacterStyles; // Remove this element so it can't be processed again. xmlUnlinkNode (pElement); xmlFree (pElement); } else { Database_Logs::log ("Discarding note with id " + id + " and href " + href); } }
void core::ModelLoader::processNode(const aiScene *scene, aiNode *node, Model *m){ if(node->mNumMeshes > 0) for(unsigned int x = 0; x < node->mNumMeshes; x++) processMesh(scene, node, scene->mMeshes[node->mMeshes[x]], m); if(node->mNumChildren > 0) for(unsigned int x = 0; x < node->mNumChildren; x++) processNode(scene, node->mChildren[x], m); };
void Model::loadModel(const std::string &path) { Assimp::Importer import; const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); if(not scene or scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE or not scene->mRootNode) { std::cerr << "ERROR::ASSIMP::" << import.GetErrorString() << std::endl; return; } directory = path.substr(0, path.find_last_of('/')); processNode(scene->mRootNode, scene); }
void parsePreorder(TreeNode *node) { if( node != nullptr ) { processNode( node ); parsePreorder(node->left); parsePreorder(node->right); } }
int LocalFileMng::readXmlInt( QDomNode node , const QString& nodeName, int defaultValue, bool bCanBeEmpty, bool bShouldExists, bool tinyXmlCompatMode) { QString text = processNode( node, nodeName, bCanBeEmpty, bShouldExists ); if ( text == NULL ) { _WARNINGLOG( QString( "\tusing default value : '%1' for node '%2'" ).arg( defaultValue ).arg( nodeName )); return defaultValue; } else { return QLocale::c().toInt( text ); } }
void ModelLoader::loadModel(std::string path) { const aiScene *scene = import.ReadFile(path, aiProcess_FlipUVs); if (!scene || (scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) || !scene->mRootNode) { std::cout << "ERROR::ASSIMP::" << import.GetErrorString() << std::endl; return; } processNode(scene->mRootNode, scene); }
//----------------------------------------------------------------------- void BspRaySceneQuery::execute(RaySceneQueryListener* listener) { clearTemporaries(); BspLevelPtr lvl = static_cast<BspSceneManager*>(mParentSceneMgr)->getLevel(); if (!lvl.isNull()) { processNode( lvl->getRootNode(), mRay, listener); } }