void DotSceneLoader::processScene(rapidxml::xml_node<>* XMLRoot)
{
// Process the scene parameters
Ogre::String version = getAttrib(XMLRoot, "formatVersion", "unknown");
Ogre::String message = "[DotSceneLoader] Parsing dotScene file with version " + version;
if (XMLRoot->first_attribute("ID"))
message += ", id " + Ogre::String(XMLRoot->first_attribute("ID")->value());
if (XMLRoot->first_attribute("sceneManager"))
message += ", scene manager " + Ogre::String(XMLRoot->first_attribute("sceneManager")->value());
if (XMLRoot->first_attribute("minOgreVersion"))
message += ", min. Ogre version " + Ogre::String(XMLRoot->first_attribute("minOgreVersion")->value());
if (XMLRoot->first_attribute("author"))
message += ", author " + Ogre::String(XMLRoot->first_attribute("author")->value());
Ogre::LogManager::getSingleton().logMessage(message);
rapidxml::xml_node<>* pElement;
// Process environment (?)
pElement = XMLRoot->first_node("environment");
if (pElement)
processEnvironment(pElement);
// Process nodes (?)
pElement = XMLRoot->first_node("nodes");
if (pElement)
processNodes(pElement);
// Process externals (?)
pElement = XMLRoot->first_node("externals");
if (pElement)
processExternals(pElement);
// Process userDataReference (?)
pElement = XMLRoot->first_node("userDataReference");
if (pElement)
processUserDataReference(pElement);
// Process octree (?)
pElement = XMLRoot->first_node("octree");
if (pElement)
processOctree(pElement);
// Process light (?)
//pElement = XMLRoot->first_node("light");
//if(pElement)
// processLight(pElement);
// Process camera (?)
pElement = XMLRoot->first_node("camera");
if (pElement)
processCamera(pElement);
// Process terrain (?)
pElement = XMLRoot->first_node("terrain");
if (pElement)
processTerrain(pElement);
}
void DotSceneLoader::processScene(TiXmlElement* xmlRoot) {
std::string version = getAttrib(xmlRoot, "formatVersion", "unknown");
std::string message = "[DotSceneLoader] Parsing dotScene file with version " + version;
if(xmlRoot->Attribute("ID"))
message += ", id " + std::string(xmlRoot->Attribute("ID"));
if(xmlRoot->Attribute("sceneManager"))
message += ", scene manager " + std::string(xmlRoot->Attribute("sceneManager"));
if(xmlRoot->Attribute("minOgreVersion"))
message += ", min. Ogre version " + std::string(xmlRoot->Attribute("minOgreVersion"));
if(xmlRoot->Attribute("author"))
message += ", author " + std::string(xmlRoot->Attribute("author"));
TiXmlElement *element;
// Process nodes (?)
element = xmlRoot->FirstChildElement("nodes");
if(element)
processNodes(element);
// Process externals (?)
element = xmlRoot->FirstChildElement("externals");
if(element)
processExternals(element);
// Process environment (?)
element = xmlRoot->FirstChildElement("environment");
if(element)
processEnvironment(element);
// Process terrain (?)
element = xmlRoot->FirstChildElement("terrain");
if(element)
processTerrain(element);
// Process userDataReference (?)
element = xmlRoot->FirstChildElement("userDataReference");
if(element)
processUserDataReference(element);
// Process octree (?)
element = xmlRoot->FirstChildElement("octree");
if(element)
processOctree(element);
// Process light (?)
element = xmlRoot->FirstChildElement("light");
if(element)
processLight(element);
// Process camera (?)
element = xmlRoot->FirstChildElement("camera");
if(element)
processCamera(element);
}
void DotSceneLoader::processEntity(rapidxml::xml_node<>* XMLNode, Ogre::SceneNode *pParent)
{
// Process attributes
Ogre::String name = getAttrib(XMLNode, "name");
Ogre::String id = getAttrib(XMLNode, "id");
Ogre::String meshFile = getAttrib(XMLNode, "meshFile");
Ogre::String materialFile = getAttrib(XMLNode, "materialFile");
bool isStatic = getAttribBool(XMLNode, "static", false);;
bool castShadows = getAttribBool(XMLNode, "castShadows", true);
// TEMP: Maintain a list of static and dynamic objects
if (isStatic)
staticObjects.push_back(name);
else
dynamicObjects.push_back(name);
rapidxml::xml_node<>* pElement;
// Process vertexBuffer (?)
pElement = XMLNode->first_node("vertexBuffer");
if (pElement)
;//processVertexBuffer(pElement);
// Process indexBuffer (?)
pElement = XMLNode->first_node("indexBuffer");
if (pElement)
;//processIndexBuffer(pElement);
// Create the entity
Ogre::Entity *pEntity = 0;
try
{
Ogre::MeshManager::getSingleton().load(meshFile, m_sGroupName);
pEntity = mSceneMgr->createEntity(name, meshFile);
pEntity->setCastShadows(castShadows);
pParent->attachObject(pEntity);
if (!materialFile.empty())
pEntity->setMaterialName(materialFile);
}
catch (Ogre::Exception &/*e*/)
{
Ogre::LogManager::getSingleton().logMessage("[DotSceneLoader] Error loading an entity!");
}
// Process userDataReference (?)
pElement = XMLNode->first_node("userDataReference");
if (pElement)
processUserDataReference(pElement, pEntity);
}
void DotSceneLoader::processEnvironment(rapidxml::xml_node<>* XMLNode)
{
rapidxml::xml_node<>* pElement;
// Process camera (?)
pElement = XMLNode->first_node("camera");
if (pElement)
processCamera(pElement);
// Process fog (?)
pElement = XMLNode->first_node("fog");
if (pElement)
processFog(pElement);
// Process skyBox (?)
pElement = XMLNode->first_node("skyBox");
if (pElement)
processSkyBox(pElement);
// Process skyDome (?)
pElement = XMLNode->first_node("skyDome");
if (pElement)
processSkyDome(pElement);
// Process skyPlane (?)
pElement = XMLNode->first_node("skyPlane");
if (pElement)
processSkyPlane(pElement);
// Process clipping (?)
pElement = XMLNode->first_node("clipping");
if (pElement)
processClipping(pElement);
// Process colourAmbient (?)
pElement = XMLNode->first_node("colourAmbient");
if (pElement)
mSceneMgr->setAmbientLight(parseColour(pElement));
// Process colourBackground (?)
//! @todo Set the background colour of all viewports (RenderWindow has to be provided then)
pElement = XMLNode->first_node("colourBackground");
if (pElement)
;//mSceneMgr->set(parseColour(pElement));
// Process userDataReference (?)
pElement = XMLNode->first_node("userDataReference");
if (pElement)
processUserDataReference(pElement);
}
void DotSceneLoader::processEntity(TiXmlElement *xmlNode, Node *parent) {
// Process attributes
std::string name = getAttrib(xmlNode, "name");
std::string id = getAttrib(xmlNode, "id");
std::string meshFile = getAttrib(xmlNode, "meshFile");
std::string materialFile = getAttrib(xmlNode, "materialFile");
bool isStatic = getAttribBool(xmlNode, "static", false);
bool castShadows = getAttribBool(xmlNode, "castShadows", true);
// TEMP: Maintain a list of static and dynamic objects
if(isStatic)
staticObjects.push_back(name);
else
dynamicObjects.push_back(name);
TiXmlElement *element;
// Process vertexBuffer (?)
element = xmlNode->FirstChildElement("vertexBuffer");
if(element)
; //processVertexBuffer(pElement);
// Process indexBuffer (?)
element = xmlNode->FirstChildElement("indexBuffer");
if(element)
; //processIndexBuffer(pElement);
// Create the entity
ModelInstance *modelInstance = 0;
try {
std::map<std::string, std::string> options;
options["only-geometry"] = "true";
options["geometry-name"] = file::getFilename(meshFile);
compiler->compile(meshFile.c_str(), options);
Model* model = (Model*)manager->loadResource(ModelKey(file::getFilename(meshFile)));
ModelInstance* entity = scene->createModelInstance(model, model->getBoundingBox(), parent);
} catch(Exception &/*e*/) {
}
// Process userDataReference (?)
element = xmlNode->FirstChildElement("userDataReference");
if(element)
processUserDataReference(element, modelInstance);
}
void DotSceneLoader::processEnvironment(TiXmlElement *xmlNode) {
TiXmlElement *element;
// Process fog (?)
element = xmlNode->FirstChildElement("fog");
if(element)
processFog(element);
// Process skyBox (?)
element = xmlNode->FirstChildElement("skyBox");
if(element)
processSkyBox(element);
// Process skyDome (?)
element = xmlNode->FirstChildElement("skyDome");
if(element)
processSkyDome(element);
// Process skyPlane (?)
element = xmlNode->FirstChildElement("skyPlane");
if(element)
processSkyPlane(element);
// Process clipping (?)
element = xmlNode->FirstChildElement("clipping");
if(element)
processClipping(element);
// Process colourAmbient (?)
element = xmlNode->FirstChildElement("colourAmbient");
// if(pElement) //TODO
// mSceneMgr->setAmbientLight(parseColour(pElement));
// Process colourBackground (?)
element = xmlNode->FirstChildElement("colourBackground");
if(element)
; //mSceneMgr->set(parseColour(pElement));
// Process userDataReference (?)
element = xmlNode->FirstChildElement("userDataReference");
if(element)
processUserDataReference(element);
}
void DotSceneLoader::processNode(rapidxml::xml_node<>* XMLNode, Ogre::SceneNode *pParent)
{
// Construct the node's name
Ogre::String name = m_sPrependNode + getAttrib(XMLNode, "name");
// Create the scene node
Ogre::SceneNode *pNode;
if (name.empty())
{
// Let Ogre choose the name
if (pParent)
pNode = pParent->createChildSceneNode();
else
pNode = mAttachNode->createChildSceneNode();
}
else
{
// Provide the name
if (pParent)
pNode = pParent->createChildSceneNode(name);
else
pNode = mAttachNode->createChildSceneNode(name);
}
// Process other attributes
Ogre::String id = getAttrib(XMLNode, "id");
bool isTarget = getAttribBool(XMLNode, "isTarget");
rapidxml::xml_node<>* pElement;
// Process position (?)
pElement = XMLNode->first_node("position");
if (pElement)
{
pNode->setPosition(parseVector3(pElement));
pNode->setInitialState();
}
// Process rotation (?)
pElement = XMLNode->first_node("rotation");
if (pElement)
{
pNode->setOrientation(parseQuaternion(pElement));
pNode->setInitialState();
}
// Process scale (?)
pElement = XMLNode->first_node("scale");
if (pElement)
{
pNode->setScale(parseVector3(pElement));
pNode->setInitialState();
}
// Process lookTarget (?)
pElement = XMLNode->first_node("lookTarget");
if (pElement)
processLookTarget(pElement, pNode);
// Process trackTarget (?)
pElement = XMLNode->first_node("trackTarget");
if (pElement)
processTrackTarget(pElement, pNode);
// Process node (*)
pElement = XMLNode->first_node("node");
while (pElement)
{
processNode(pElement, pNode);
pElement = pElement->next_sibling("node");
}
// Process entity (*)
pElement = XMLNode->first_node("entity");
while (pElement)
{
processEntity(pElement, pNode);
pElement = pElement->next_sibling("entity");
}
// Process light (*)
//pElement = XMLNode->first_node("light");
//while(pElement)
//{
// processLight(pElement, pNode);
// pElement = pElement->next_sibling("light");
//}
// Process camera (*)
pElement = XMLNode->first_node("camera");
while (pElement)
{
processCamera(pElement, pNode);
pElement = pElement->next_sibling("camera");
}
// Process particleSystem (*)
pElement = XMLNode->first_node("particleSystem");
while (pElement)
{
processParticleSystem(pElement, pNode);
pElement = pElement->next_sibling("particleSystem");
}
// Process billboardSet (*)
pElement = XMLNode->first_node("billboardSet");
while (pElement)
{
processBillboardSet(pElement, pNode);
pElement = pElement->next_sibling("billboardSet");
}
// Process plane (*)
pElement = XMLNode->first_node("plane");
while (pElement)
{
processPlane(pElement, pNode);
pElement = pElement->next_sibling("plane");
}
// Process userDataReference (?)
pElement = XMLNode->first_node("userDataReference");
if (pElement)
processUserDataReference(pElement, pNode);
}
void DotSceneLoader::processNode(TiXmlElement *xmlNode, Node *pParent) {
// Construct the node's name
std::string name = getAttrib(xmlNode, "name");
// Create the scene node
Node *node;
if(name.empty()) {
// Let Ogre choose the name
if(pParent) {
node = scene->createNode();
pParent->addChild(node);
} else {
node = scene->createNode();
rootNode->addChild(node);
}
} else {
// Provide the name
if(pParent) {
node = scene->createNode(/*name*/);
pParent->addChild(node);
} else {
node = scene->createNode(/*name*/);
rootNode->addChild(node);
}
}
// Process other attributes
std::string id = getAttrib(xmlNode, "id");
bool isTarget = getAttribBool(xmlNode, "isTarget");
TiXmlElement *element;
// Process position (?)
element = xmlNode->FirstChildElement("position");
if(element) {
node->setPosition(parseVector3(element));
}
// Process rotation (?)
element = xmlNode->FirstChildElement("rotation");
if(element) {
node->setOrientation(parseQuaternion(element));
}
// Process scale (?)
element = xmlNode->FirstChildElement("scale");
if(element) {
node->setScale(parseVector3(element));
}
// Process lookTarget (?)
element = xmlNode->FirstChildElement("lookTarget");
if(element)
processLookTarget(element, node);
// Process trackTarget (?)
element = xmlNode->FirstChildElement("trackTarget");
if(element)
processTrackTarget(element, node);
// Process node (*)
element = xmlNode->FirstChildElement("node");
while(element) {
processNode(element, node);
element = element->NextSiblingElement("node");
}
// Process entity (*)
element = xmlNode->FirstChildElement("entity");
while(element) {
processEntity(element, node);
element = element->NextSiblingElement("entity");
}
// Process light (*)
element = xmlNode->FirstChildElement("light");
while(element) {
processLight(element, node);
element = element->NextSiblingElement("light");
}
// Process camera (*)
element = xmlNode->FirstChildElement("camera");
while(element) {
processCamera(element, node);
element = element->NextSiblingElement("camera");
}
// Process particleSystem (*)
element = xmlNode->FirstChildElement("particleSystem");
while(element) {
processParticleSystem(element, node);
element = element->NextSiblingElement("particleSystem");
}
// Process billboardSet (*)
element = xmlNode->FirstChildElement("billboardSet");
while(element) {
processBillboardSet(element, node);
element = element->NextSiblingElement("billboardSet");
}
// Process plane (*)
element = xmlNode->FirstChildElement("plane");
while(element) {
processPlane(element, node);
element = element->NextSiblingElement("plane");
}
// Process userDataReference (?)
element = xmlNode->FirstChildElement("userDataReference");
if(element)
processUserDataReference(element, node);
}
