//---------------------------------------------------------------
void DocumentExporter::exportMaxScene()
{
mStreamWriter.startDocument();
createExporters();
exportAsset();
exportEffects();
exportMaterials();
exportGeometries();
exportControllers();
exportCameras();
exportLights();
exportImages();
exportVisualScenes();
if ( mOptions.getExportAnimations() )
exportAnimations();
exportScene();
deleteExporters();
mStreamWriter.endDocument();
const ExportSceneGraph::XRefSceneGraphList& sceneGraphList = mExportSceneGraph->getXRefSceneGraphList();
for ( ExportSceneGraph::XRefSceneGraphList::const_iterator it = sceneGraphList.begin(); it!=sceneGraphList.end(); ++it )
{
NativeString outputFileName(NativeString(getXRefOutputPath(*it)));
DocumentExporter document(mMaxInterface, it->exportSceneGraph, outputFileName, mOptions, mExportOnlySelected);
document.exportMaxScene();
}
}
//---------------------------------------------------------------
void LightExporter::exportLights ( )
{
if ( !ExportOptions::exportLights() ) return;
// Get the list with the transform nodes.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
SceneElementsList* exportNodesTree = sceneGraph->getExportNodesTree();
// Export all/selected DAG nodes
size_t length = exportNodesTree->size();
for ( uint i = 0; i < length; ++i )
{
SceneElement* sceneElement = ( *exportNodesTree ) [i];
exportLights ( sceneElement );
}
closeLibrary();
}
//---------------------------------------------------------------
void LightExporter::exportLights ( SceneElement* sceneElement )
{
// If we have a external reference, we don't need to export the data here.
if ( !sceneElement->getIsLocal() ) return;
if ( !sceneElement->getIsExportNode () ) return;
// Check if it is a light.
SceneElement::Type sceneElementType = sceneElement->getType();
if ( sceneElementType == SceneElement::LIGHT )
{
// Get the current dag path
MDagPath dagPath = sceneElement->getPath();
// Check if the current scene element isn't already exported.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
if ( sceneGraph->findExportedElement ( dagPath ) ) return;
// Check if the current element is an instance.
// We don't need to export instances, because we export the original instanced element.
bool isInstance = ( dagPath.isInstanced() && dagPath.instanceNumber() > 0 );
// If the original instanced element isn't already exported, we have to export it now.
if ( isInstance )
{
// Get the original instanced element.
MDagPath instancedPath;
dagPath.getPath ( instancedPath, 0 );
// Check if the original instanced element is already exported.
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
SceneElement* exportedElement = sceneGraph->findExportedElement ( instancedPath );
if (exportedElement == 0)
{
// Export the original instanced element and push it in the exported scene graph.
if (exportLight(instancedPath))
{
SceneElement* instancedSceneElement = sceneGraph->findElement(instancedPath);
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
sceneGraph->addExportedElement(instancedSceneElement);
}
}
}
else
{
// Export the element and push it in the exported scene graph.
if ( exportLight ( dagPath ) )
{
SceneGraph* sceneGraph = mDocumentExporter->getSceneGraph();
sceneGraph->addExportedElement( sceneElement );
}
}
}
// Recursive call for all the child elements
for ( uint i=0; i<sceneElement->getChildCount(); ++i )
{
SceneElement* childElement = sceneElement->getChild ( i );
exportLights ( childElement );
}
}
bool XMLModelDefinitionSerializer::exportScript(ModelDefinitionPtr modelDef, const std::string& directory, const std::string& filename)
{
if (filename == "") {
return false;
}
TiXmlDocument xmlDoc;
try
{
if (!oslink::directory(directory).isExisting()) {
S_LOG_INFO("Creating directory " << directory);
oslink::directory::mkdir(directory.c_str());
}
TiXmlElement elem("models");
TiXmlElement modelElem("model");
modelElem.SetAttribute("name", modelDef->getName().c_str());
std::string useScaleOf;
switch (modelDef->getUseScaleOf()) {
case ModelDefinition::MODEL_ALL:
useScaleOf = "all";
break;
case ModelDefinition::MODEL_DEPTH:
useScaleOf = "depth";
break;
case ModelDefinition::MODEL_HEIGHT:
useScaleOf = "height";
break;
case ModelDefinition::MODEL_NONE:
useScaleOf = "none";
break;
case ModelDefinition::MODEL_WIDTH:
useScaleOf = "width";
break;
}
modelElem.SetAttribute("usescaleof", useScaleOf.c_str());
if (modelDef->getRenderingDistance() != 0.0f) {
modelElem.SetDoubleAttribute("renderingdistance", modelDef->getRenderingDistance());
}
if (modelDef->getScale() != 0) {
modelElem.SetDoubleAttribute("scale", modelDef->getScale());
}
modelElem.SetAttribute("showcontained", modelDef->getShowContained() ? "true" : "false");
if (modelDef->getContentOffset() != Ogre::Vector3::ZERO) {
TiXmlElement contentOffset("contentoffset");
XMLHelper::fillElementFromVector3(contentOffset, modelDef->getContentOffset());
modelElem.InsertEndChild(contentOffset);
}
const RenderingDefinition* renderingDef = modelDef->getRenderingDefinition();
if (renderingDef) {
TiXmlElement rendering("rendering");
rendering.SetAttribute("scheme", renderingDef->getScheme().c_str());
for (StringParamStore::const_iterator I = renderingDef->getParameters().begin();
I != renderingDef->getParameters().end(); ++I)
{
TiXmlElement param("param");
param.SetAttribute("key", I->first.c_str());
param.SetValue(I->second.c_str());
rendering.InsertEndChild(param);
}
modelElem.InsertEndChild(rendering);
}
TiXmlElement translate("translate");
XMLHelper::fillElementFromVector3(translate, modelDef->getTranslate());
modelElem.InsertEndChild(translate);
TiXmlElement rotation("rotation");
XMLHelper::fillElementFromQuaternion(rotation, modelDef->getRotation());
modelElem.InsertEndChild(rotation);
modelElem.SetAttribute("icon", modelDef->getIconPath().c_str());
if (modelDef->getRenderingDefinition()) {
TiXmlElement rendering("rendering");
rendering.SetAttribute("scheme", modelDef->getRenderingDefinition()->getScheme().c_str());
for (StringParamStore::const_iterator I = modelDef->getRenderingDefinition()->getParameters().begin(); I != modelDef->getRenderingDefinition()->getParameters().end(); ++I) {
TiXmlElement param("param");
param.SetAttribute("key", I->first.c_str());
param.SetValue(I->second.c_str());
}
}
//start with submodels
exportSubModels(modelDef, modelElem);
//now do actions
exportActions(modelDef, modelElem);
exportAttachPoints(modelDef, modelElem);
exportViews(modelDef, modelElem);
exportLights(modelDef, modelElem);
exportParticleSystems(modelDef, modelElem);
exportBoneGroups(modelDef, modelElem);
exportPoses(modelDef, modelElem);
elem.InsertEndChild(modelElem);
xmlDoc.InsertEndChild(elem);
xmlDoc.SaveFile((directory + filename).c_str());
S_LOG_INFO("Saved file " << (directory + filename));
return true;
}
catch (...)
{
S_LOG_FAILURE("An error occurred saving the modeldefinition for "<< modelDef->getName() << "." );
return false;
}
}
