void rigidBodyNode::clearContactInfo()
{
MObject thisObject(thisMObject());
// contactCount
m_contactCount = 0;
MPlug plugContactCount(thisObject, rigidBodyNode::oa_contactCount);
plugContactCount.setValue(m_contactCount);
// contactName
MStringArray stringArray;
stringArray.clear();
MFnStringArrayData stringArrayData;
MObject strArrObject = stringArrayData.create(stringArray);
MPlug plugContactName(thisObject, rigidBodyNode::oa_contactName);
if ( !plugContactName.isNull() )
plugContactName.setValue(strArrObject);
// contactPosition
MPlug plugContactPosition(thisObject, rigidBodyNode::oa_contactPosition);
bool isArray = plugContactPosition.isArray();
MVectorArray vectorArray;
vectorArray.clear();
MFnVectorArrayData vectorArrayData;
MObject arrObject = vectorArrayData.create(vectorArray);
if ( !plugContactPosition.isNull() )
plugContactPosition.setValue(arrObject);
}
void maTranslator::getSetAttrCmds(const MObject& node, MStringArray& cmds)
{
//
// Get rid of any garbage already in the array.
//
cmds.clear();
//
// Run through the node's attributes.
//
MFnDependencyNode nodeFn(node);
unsigned int numAttrs = nodeFn.attributeCount();
unsigned int i;
for (i = 0; i < numAttrs; i++)
{
//
// Use the attribute ordering which Maya uses when doing I/O.
//
MObject attr = nodeFn.reorderedAttribute(i);
MFnAttribute attrFn(attr);
MStatus status;
attrFn.parent(&status);
bool isChild = (status != MS::kNotFound);
//
// We don't want attributes which are children of other attributes
// because they will be processed when we process the parent.
//
// And we only want storable attributes which accept inputs.
//
if (!isChild && attrFn.isStorable() && attrFn.isWritable())
{
//
// Get a plug for the attribute.
//
MPlug plug(node, attr);
//
// Get setAttr commands for this attribute, and any of its
// children, which have had their values changed by the scene.
//
MStringArray newCmds;
plug.getSetAttrCmds(newCmds, MPlug::kChanged, false);
unsigned int numCommands = newCmds.length();
unsigned int c;
for (c = 0; c < numCommands; c++)
{
if (newCmds[c] != "")
cmds.append(newCmds[c]);
}
}
}
}
//-----------------------------------------------------------------------------
// Changes any \'s to /'s in place and then splits on /
//-----------------------------------------------------------------------------
uint SplitPath(
const MString &path,
MStringArray &splitPath )
{
char *pC( const_cast< char *>( path.asChar() ) );
for ( const char *const pEnd( pC + path.length() ); pC != pEnd; ++pC )
{
if ( *pC == '\\' )
{
*pC = '/';
}
}
splitPath.clear();
path.split( '/', splitPath );
return splitPath.length();
}
bool XmlCacheFormat::readXmlTagValue( string tag, MStringArray& values )
{
string endTag = XMLENDTAG(tag);
bool status = true;
values.clear();
// Yes this could be much much smarter
if( findXmlStartTag(tag) )
{
string token;
fFile >> token;
while ( !fFile.eof() && token != endTag )
{
values.append( token.data() );
fFile >> token;
}
}
else
{
MStatus uninitializePlugin( MObject obj)
{
MStatus status;
MFnPlugin plugin( obj );
// Loop through all the ids and remove the callbacks
//
int i;
int len = eventNames.length();
for (i = 0; i < len; ++i)
{
if (callbackId[i] != 0)
{
MGlobal::displayWarning("Removing callback for " +
eventNames[i] +
"\n");
MMessage::removeCallback(callbackId[i]);
callbackId[i] = 0;
}
}
eventNames.clear();
delete [] callbackId;
// Deregister the command
//
status = plugin.deregisterCommand("eventTest");
if (!status)
{
status.perror("deregisterCommand");
}
return status;
}
MStatus MayaFileTranslator::writer( const MFileObject& file,
const MString& options,
FileAccessMode mode){
//-------------------détection des options transmises par le script MEL---------------
// this will store our option strings
MStringArray optionList;
// seperate the option string
options.split(' ', optionList);
// check all of the options
int len = optionList.length();
for( int i = 0; i < len; ++i ){
MString Option = optionList[i];
// if we recognised option 1
if( Option == "vertexcolorFlag" ) {
// check for true or false
if(optionList[++i]=="0")
Flags.vertex_colors=0;
else
Flags.vertex_colors=1;
}
// if we recognised our second option
if( Option == "vertexnormalFlag" ) {
// check for true or false
if(optionList[++i]=="0")
Flags.Normals=0;
else
Flags.Normals=1;
}
// if we recognised our third option
if( Option == "brushFX" ) {
// check for true or false
if(optionList[++i]=="0")
Flags.use_vertex_colors=1;
else
Flags.use_vertex_colors=0;
}
}
//----------------------------------fin------------------------
//export Selected Objects
if(mode == kExportActiveAccessMode)
{
//liste des objets sélectionnés
MSelectionList selection;
MGlobal::getActiveSelectionList( selection );
//MStringArray strings;
//MDagPath dagPath;
MObject components;
MDagPath path;
//-----
// int temp;
//MGlobal::displayInfo("Début exportation des objets sélectionnés");
// ouverture du fichier [BB3D]
MString output_filename = file.fullName();
::output.open(output_filename.asChar(),ios::out |ios::binary);
// ecriture header fichier
::output << "BB3D"; // mise en place du Header fichier B3D
StartChunck();
// sauv garde de la position du début de fichier
//write_int(1);// mise en place d'une valeur entière quelconque pour mise en place ultérieure de la longeur du fichier
write_int(1);//écriture de la version BB3D
#ifdef OLD_TEXS
// écriture des textures si présentent [TEXS]|detection des textures à enregistrer| + fermeture texs
::output << "TEXS";//header Brush
StartChunck();
OutputTextures(selection);
EndChunck();
// écriture des matériaux [BRUS]|detection des materiaux à enregistrer| +fermeture brus
//Matid.clear();
OutputMaterials(selection);
#else
//nouvelles textures
#endif
//------------------------------------fin materials----------------------------------
#ifdef SCENE_ROOT
// algo des nodes [NODE] réplication de la hierarchie,
::output << "NODE"; // mise en place du Header fichier B3D
StartChunck();
//write_int(1);// mise en place d'une valeur quelconque
::output << "Scene Root";//nom du Node
::output << char(0x00);//fin de chaîne
//écriture des coordonnées spatiales
//transaltion
write_float(0);// translation x
write_float(0);// translation y
write_float(0);// translation z
write_float(1);//scale x
write_float(1);//scale y
write_float(1);//scale z
write_float(0);// rotation x
write_float(0);// rotation y
write_float(0);// rotation z
write_float(0);// rotation w
#else
#endif
int pos_objet=0,pos_nouvel_objet;
MString nom_objet_precedent;
// create an iterator to go through all transforms
//MItDag it(MItDag::depth, MFn::kTransform);
MItDag it(MItDag::kDepthFirst, MFn::kTransform);
// keep looping until done
int position_hierarchie=0;
int pos=0;
while(!it.isDone())
{
MString temp;
MDagPath path;
it.getPath(path);
MFnTransform trans(path);
MObject obj=it.item();
MStringArray chemin_split;
MString chemin=path.fullPathName();
chemin.split((char)'|',chemin_split);
pos=chemin_split.length();
//temp=pos;
//MGlobal::displayInfo(temp);
if(obj.apiType()== MFn::kTransform && path.child(0).apiType()== MFn::kMesh){
//MGlobal::displayInfo("Transform trouvé avec child Kmesh");
//écriture du node avec transform
//incrément de la hierarchie
if(pos<position_hierarchie || pos==position_hierarchie){
//MGlobal::displayInfo("fermeture des nodes précédents");
for(int i=position_hierarchie;i>pos-1;i--){
//temp = i;
//MGlobal::displayInfo(temp);
EndChunck();
}//fin for
}//fin if
//MGlobal::displayInfo("Ouverture node");
::output << "NODE"; // mise en place du Header node
StartChunck();
MString nom_objet;
nom_objet=chemin_split[chemin_split.length()-1];
::output << nom_objet.substring(0,nom_objet.length());//nom du Node
::output << char(0x00);//caractêre de fin de chaîne
MVector Translation;
// get the transforms local translation
Translation = trans.getTranslation(MSpace::kTransform);
float temp=(float)Translation.x;
//écriture des coordonnées spaciales
//transaltion
write_float(temp);// translation x
temp=(float)Translation.y;
write_float(temp);// translation y
temp=-(float)Translation.z;
write_float(temp);// translation z
double scale[3];
trans.getScale(scale);
temp=(float)scale[0];
write_float(temp);
temp=(float)scale[1];
write_float(temp);
temp=(float)scale[2];
write_float(temp);
MQuaternion Rotation;
trans.getRotation(Rotation,MSpace::kTransform);
temp=(float)Rotation.w;
write_float(temp);
temp=(float)Rotation.x;
write_float(temp);
temp=(float)Rotation.y;
write_float(temp);
temp=(float)Rotation.z;
write_float(temp);
path.getPath(path);
if(selection.hasItem(path)!=MStatus::kSuccess){
//MGlobal::displayInfo("présent dans la liste de selection");
//---------exportation du mesh
//mais avec des nodes vides, pour les mesh non sélectionnés
//----------------------------ecriture mesh si objet polygonal présent
::output << "MESH"; // mise en place du Header mesh
StartChunck();
MPointArray vertexArray;// coordonnées des point format double x,y,z;
MIntArray vertexList;// stockage des indexs des points pour les triangles
MVector Normal;//stockage d'une normal d'un vertex
//----------------------coordonnées Vertexs (normal & color si présent et demandés)
//master brush
//write_int(0xffffffff);
write_int(-1);//-1 master brush
MFnMesh meshFn(path.child(0)); // crée une fonction pour le mesh
MItMeshVertex polyperVertex(path, MObject::kNullObj);// crée une fonction pour le mesh , mais avec les fonctions de itmesh
//récupération des coordonnées des points
//obtient les coordonnées des vertex en mode global
//meshFn.getPoints(vertexArray,MSpace::kObject);
meshFn.getPoints(vertexArray,MSpace::kTransform);
//MFloatArray uArray;
//MFloatArray vArray;
//meshFn.getUVs(uArray,vArray);//getUVs( MFloatArray& uArray, MFloatArray& vArray,const MString * uvSet = NULL )
MIntArray uvCounts,uvIds;
meshFn.getAssignedUVs(uvCounts,uvIds,0);
//ecriture VRTS
::output<<"VRTS";
StartChunck();
//flags 0=none just vertices coords 1=normal values present, 2=rgba values present
//The way the flags work, is that you combine them.
//1 = Vertex Normal
//2 = Vertex Color
//3 = Vertex Normal + Color
int flag_normal_colors=0;
//info = "Normals ";
//info += Flags.Normals;
//Affich(info);
//info = "vertex colors ";
//info += Flags.vertex_colors;
//Affich(info);
flag_normal_colors = Flags.Normals+((Flags.use_vertex_colors && Flags.vertex_colors)*2);
//info = flag_normal_colors;
//Affich(info);
write_int(flag_normal_colors);//présence normale
//int tex_coord_sets ;texture coords per vertex (eg: 1 for simple U/V) max=8
write_int(1);//uv simple
// int tex_coord_set_size ;components per set (eg: 2 for simple U/V) max=4
write_int(2);//2 coordonées textures
float x,y,z,normx,normy,normz;//,normx,normy,normz;
for (unsigned int i=0;i<vertexArray.length();i++){
x =float(vertexArray[i].x); // - pour replacer l'axe X dans le sens de celui de blitz
y =float(vertexArray[i].y);
z =-float(vertexArray[i].z);// -
//vertices coords
write_float(x);
write_float(y);
write_float(z);
//récupère la normale du point
if(flag_normal_colors==1 || flag_normal_colors==3){
meshFn.getVertexNormal(i, Normal ,MSpace::kObject);
normx=float(Normal.x);
normy=float(Normal.y);
normz=float(Normal.z);
write_float(normx);
write_float(normy);
write_float(normz);
}
//-----------------------------------------
//vertex_colors_present=1;
if (flag_normal_colors == 2 || flag_normal_colors==3){
MStringArray colorsets;
MColorArray color;
//status = meshFn.getColorSetNames(colorsets);
meshFn.getColorSetNames(colorsets);
MColor couleur;
MString colorset = colorsets[0];
//récupère la couleur moyenne des faces connectés au point
meshFn.getVertexColors(color,&colorset);
//polyperVertex.getColor
//int a;
//meshFn.getColor(a,couleur);
//meshFn.getColors(color);
couleur=color[i];
float col=float(couleur.r);
//R
::output.write((char*)&couleur.r,sizeof(couleur.r));
//write_float(col);
col=float(couleur.g);
//G
::output.write((char*)&couleur.g,sizeof(couleur.g));
//write_float(col);
col=float(couleur.b);
//B
::output.write((char*)&couleur.b,sizeof(couleur.b));
//write_float(col);
col=float(couleur.a);
//Alpha
::output.write((char*)&couleur.a,sizeof(couleur.a));
//write_float(col);
}
//-----------------------------------------
//float tempo;
float u,v;
MFloatArray uArray;
MFloatArray vArray;
MIntArray FaceIds;
polyperVertex.getUVs(uArray,vArray,FaceIds);
//meshFn.getUV(i*2,u,v);
u=uArray[0];
v=vArray[0];
//tempo = uArray[0];
//write_float(tempo);
//tempo = vArray[0];
//write_float(tempo);
write_float(u);
write_float(-v);
polyperVertex.next();
}//fin for
//-----------------fermeture coordonées Vertex
EndChunck();
// ----------------------------------export des triangles
#ifdef OLD_TRIS
//ecriture TRIS
::output<<"TRIS";
StartChunck();
//brush ID
write_int(-1);//write_int(0);
//MItMeshPolygon itPolygon( path, MObject::kNullObj );
MItMeshPolygon itPolygon(path.child(0));
for ( /* nothing */; !itPolygon.isDone(); itPolygon.next() )
{
// Get triangulation of this poly.
int numTriangles;
itPolygon.numTriangles(numTriangles);
while ( numTriangles-- )
{
//MGlobal::displayInfo(" triangle");
MStatus status;
MIntArray polygonVertices;
itPolygon.getVertices( polygonVertices );
MPointArray nonTweaked;
// object-relative vertex indices for each triangle
MIntArray triangleVertices;
// face-relative vertex indices for each triangle
MIntArray localIndex;
status = itPolygon.getTriangle( numTriangles,
nonTweaked,
triangleVertices,
MSpace::kObject );
if ( status == MS::kSuccess )
{
//traitement du triangle
// Get face-relative vertex indices for this triangle
//int temp=triangleVertices[0];
write_int(triangleVertices[0]);
write_int(triangleVertices[2]);
write_int(triangleVertices[1]);
//::output.write((char*)&triangleVertices[0],sizeof(triangleVertices[0]));
//::output.write((char*)&triangleVertices[2],sizeof(triangleVertices[2]));
//::output.write((char*)&triangleVertices[1],sizeof(triangleVertices[1]));
} // fin if
};// fin while
}; //fin for
EndChunck();
#else
unsigned int instancenumbers;
MObjectArray shaders;
MIntArray indices;
//MFnMesh Fn(path.instanceNumber);
meshFn.getConnectedShaders(instancenumbers,shaders,indices);
MString info="shaders.lenght ";
info += shaders.length();
Affich(info);
for (int i=-1;i<shaders.length();i++){//création de tris en fonction du nombre de brush appliqué
//___________ouput tris________
info = "shader ";
info += i;
Affich(info);
//ecriture TRIS
::output<<"TRIS";
StartChunck();
//trouver le brush id par rapport à matid
//recup nom shader et compare à matid
MString nameshader;
nameshader=GetShaderName(shaders[i]);
info = "Matid id lenght";
info += Matid.length();
Affich(info);
int BrushId=0;
for (int b=0;b<Matid.length();b++){
if (nameshader==Matid[b]){
BrushId=b;
}
}
//brush ID
write_int(BrushId);
//write_int(-1);//default
info= "BrushId ";
info += BrushId;
Affich(info);
info = Matid[BrushId];
Affich(info);
MItMeshPolygon itPolygon(path.child(0));
int d=0;
for ( /* nothing */; !itPolygon.isDone(); itPolygon.next() )
{
nameshader=GetShaderName(shaders[indices[d]]);
if(nameshader==Matid[BrushId]){
// Get triangulation of this poly.
int numTriangles;
itPolygon.numTriangles(numTriangles);
while ( numTriangles-- )
{
//MGlobal::displayInfo(" triangle");
MStatus status;
MIntArray polygonVertices;
itPolygon.getVertices( polygonVertices );
MPointArray nonTweaked;
// object-relative vertex indices for each triangle
MIntArray triangleVertices;
// face-relative vertex indices for each triangle
MIntArray localIndex;
status = itPolygon.getTriangle( numTriangles,
nonTweaked,
triangleVertices,
MSpace::kObject );
if ( status == MS::kSuccess )
{
write_int(triangleVertices[0]);
write_int(triangleVertices[2]);
write_int(triangleVertices[1]);
} // fin if
};// fin while
}
d++;
}
for (int i=0;i<indices.length();i++){
//info = " indice ";
//info += indices[i];
//Affich(info);
nameshader=GetShaderName(shaders[indices[i]]);
if(nameshader==Matid[BrushId]){
//info=nameshader;
//Affich(info);
//*********************ecrire triangle*******
}
}
EndChunck();
}
//for (int i=0;i<Matid.length();i++){
// info = Matid[i];
// Affich(info);
//}
//Affich("fin objet");
#endif
//---------------------fermeture mesh
EndChunck();
//------------------------------------------------------------
}
position_hierarchie=pos;
}
// move on to next node
it.next();
}//fin while
//fermeture du node
//fermeture fichier
//fermeture de tous les nodes ouverts
//for (int i=posfichier.length();i>0;i--){
#ifdef SCENE_ROOT
EndChunck();
#else
#endif
//}
//écriture de la longueur du fichier
output.close();
Matid.clear();
Texid.clear();
nb_Tex_by_Brush.clear();
Texids_by_brush.clear();
}
else
//export all polygonal scene objects
{
}
return MS::kSuccess;
}
void OutputTextures(MSelectionList selected){
MString temp;
MString affich;
int MatExists=0;
for(int i=0;i<selected.length();i++){
MDagPath path;
MObject obj;
selected.getDagPath(i,path);
obj=path.child(0);
MFnMesh fn(path);
obj=fn.parent(0);
path.getAPathTo(fn.parent(0));
MFnMesh fna(path);
unsigned int instancenumbers;
MObjectArray shaders;
MIntArray indices;
fna.getConnectedShaders(instancenumbers,shaders,indices);
switch(shaders.length()) {
// if no shader applied to the mesh instance
case 0:
{
//***************Affich("pas de matériaux");
}
break;
// if all faces use the same material
// if more than one material is used, write out the face indices the materials
// are applied to.
default:
{
//************************Affich("trouvé plusieurs matériaux");
//write_int(shaders.length());
// now write each material and the face indices that use them
for(int j=0;j < shaders.length();++j)
{
for(int matest=0;matest<Matid.length();matest++){
//**************************Affich(Matid[matest].asChar());
//*****************************Affich(GetShaderName( shaders[j] ).asChar());
if(Matid[matest]== GetShaderName( shaders[j] )){
MatExists = 1;
}//fin if matid
}// fin for matest
if(MatExists != 1){
//*****************************Affich("matériau absent de la liste, enregistrement");
Matid.append(GetShaderName( shaders[j] ).asChar());
nb_Tex_by_Brush.append(0);
writeTexture(shaders[j],"color");
//Affich(temp);
}else {
//************************************* Affich("matériau existe dans la liste");
}// fin if matexists
MatExists = 0;
}//fin for j shaders
}// fin case default
break;
}//fin switches
}//fin for selected
Matid.clear();
}// fin output textures
// Write method of the GE2.0 translator / file exporter
MStatus ge2Translator::writer ( const MFileObject & fileObject,
const MString & options,
MPxFileTranslator::FileAccessMode mode)
{
char LTmpStr[MAXPATHLEN];
unsigned int i,
LN;
// const MString fname = fileObject.fullName ();
MString extension;
MString baseFileName;
// Lets strip off the known extension of .grp if it is there.
extension.set (".grp");
int extLocation = fileObject.name ().rindex ('.');
if ( (extLocation != -1) && // no '.' in name
(extLocation != 0) && // name was ".grp" -- that's ok??
(fileObject.name ().substring (extLocation, fileObject.name ().length () - 1) == extension) )
{
baseFileName = fileObject.name ().substring (0, extLocation - 1);
} else
{
baseFileName = fileObject.name ();
extension.clear ();
}
geWrapper.setBaseFileName( baseFileName );
geWrapper.setPathName( fileObject.fullName() );
geWrapper.pluginVersion = version;
// Set the directory at the Dt level
strncpy( LTmpStr, geWrapper.getPathName().asChar(), MAXPATHLEN );
LN = (int)strlen( LTmpStr );
if ( LTmpStr[LN - 1] == '/' )
LTmpStr[LN - 1] = '\0';
DtSetDirectory( LTmpStr );
// in an ideal world, everything in setDefaults() should be overridden
// with the option parsing. If the mel script doesn't get run for whatever
// reason, or neglects to return some values, hopefully setDefaults will
// enable the export to go through anyway
geWrapper.setDefaults();
// Turn off this pesky warning on NT - performance warning
// for int -> bool conversion.
#ifdef WIN32
#pragma warning ( disable : 4800 )
#endif
// Lets now do all of the option processing
if ( options.length () > 0 )
{
//Start parsing.
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList);
//break out all the options.
for ( i = 0; i < optionList.length (); ++i )
{
theOption.clear ();
optionList[i].split( '=', theOption );
if ( theOption.length () > 1 )
{
if ( theOption[0] == MString( "enableAnim" ) )
{
geWrapper.enableAnim = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animStart" ) )
{
geWrapper.frameStart = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animEnd" ) )
{
geWrapper.frameEnd = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animStep" ) )
{
geWrapper.frameStep = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animVertices" ) )
{
geWrapper.animVertices = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animDisplacement" ) )
{
if ( theOption[1].asInt() == 1 )
geWrapper.vertexDisplacement = ge2Wrapper::kVDRelative;
else
geWrapper.vertexDisplacement = ge2Wrapper::kVDAbsolute;
} else if ( theOption[0] == MString( "animTransforms" ) )
{
geWrapper.animTransforms = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animShaders" ) )
{
geWrapper.animShaders = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animLights" ) )
{
geWrapper.animLights = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "animCamera" ) )
{
geWrapper.animCamera = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "keyCurves" ) )
{
geWrapper.keyCurves = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "keySample" ) )
{
geWrapper.keySample = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "sampRate" ) )
{
geWrapper.sampleRate = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "sampTol" ) )
{
geWrapper.sampleTolerance = (float) ( theOption[1].asFloat() );
} else if ( theOption[0] == MString( "useGL" ) )
{
geWrapper.useDomainGL = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "usePSX" ) )
{
geWrapper.useDomainPSX = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "useN64" ) )
{
geWrapper.useDomainN64 = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "useCustom" ) )
{
geWrapper.useDomainCustom = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "hrcType" ) )
{
geWrapper.hrcMode = static_cast <ge2Wrapper::GEHrcMode> ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportSel" ) )
{
geWrapper.selType = static_cast <ge2Wrapper::GESelType> ( theOption[1].asInt() );
if ( (mode == MPxFileTranslator::kExportActiveAccessMode) &&
(geWrapper.selType == ge2Wrapper::kSelAll) )
{
geWrapper.selType = ge2Wrapper::kSelActive;
}
} else if ( theOption[0] == MString( "exportLights" ) )
{
geWrapper.outputLights = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportCamera" ) )
{
geWrapper.outputCamera = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportJoints" ) )
{
geWrapper.outputJoints = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportNormals" ) )
{
geWrapper.outputNormals = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "opposite" ) )
{
geWrapper.oppositeNormals = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportGeometry" ) )
{
geWrapper.outputGeometry = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "reverse" ) )
{
geWrapper.reverseWinding = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "exportTextures" ) )
{
geWrapper.outputTextures = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "tesselation" ) )
{
if ( theOption[1].asInt() == 2 )
DtExt_setTesselate( kTESSQUAD );
else
DtExt_setTesselate( kTESSTRI );
} else if ( theOption[0] == MString( "texsample" ) )
{
geWrapper.sampleTextures = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "texevaluate" ) )
{
geWrapper.evalTextures = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "texOriginal" ) )
{
geWrapper.useOriginalFileTextures = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "Xtexres" ) )
{
geWrapper.xTexRes = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "Ytexres" ) )
{
geWrapper.yTexRes = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "MaxXtexres" ) )
{
geWrapper.xMaxTexRes = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "MaxYtexres" ) )
{
geWrapper.yMaxTexRes = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "texType" ) )
{
geWrapper.texType = theOption[1];
} else if ( theOption[0] == MString( "precision" ) )
{
geWrapper.precision = (int) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "format" ) )
{
geWrapper.useTabs = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "comments" ) )
{
geWrapper.writeComments = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "verboseGeom" ) )
{
geWrapper.verboseGeom = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "verboseLgt" ) )
{
geWrapper.verboseLgt = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "verboseCam" ) )
{
geWrapper.verboseCam = (bool) ( theOption[1].asInt() );
} else if ( theOption[0] == MString( "script" ) )
{
geWrapper.userScript = theOption[1];
} else if ( theOption[0] == MString( "scriptAppend" ) )
{
geWrapper.scriptAppendFileName = (int) ( theOption[1].asInt() );
}
}
}
}
#ifdef WIN32
#pragma warning ( default : 4800 )
#endif
geWrapper.initScene(); // do some initialization
geWrapper.writeScene(); // write it to the appropriate files
geWrapper.killScene(); // clean-up
return MS::kSuccess;
}
MStatus
usdTranslatorExport::writer(const MFileObject &file,
const MString &optionsString,
MPxFileTranslator::FileAccessMode mode ) {
std::string fileName(file.fullName().asChar());
JobExportArgs jobArgs;
double startTime=1, endTime=1;
bool append=false;
// Get the options
if ( optionsString.length() > 0 ) {
MStringArray optionList;
MStringArray theOption;
optionsString.split(';', optionList);
for(int i=0; i<(int)optionList.length(); ++i) {
theOption.clear();
optionList[i].split('=', theOption);
if (theOption[0] == MString("exportReferencesAsInstanceable")) {
jobArgs.exportRefsAsInstanceable = theOption[1].asInt();
}
if (theOption[0] == MString("shadingMode")) {
// Set default (most common) options
jobArgs.exportDisplayColor = true;
jobArgs.shadingMode = PxrUsdMayaShadingModeTokens->none;
if (theOption[1]=="None") {
jobArgs.exportDisplayColor = false;
}else if (theOption[1]=="Look Colors") {
jobArgs.shadingMode = PxrUsdMayaShadingModeTokens->displayColor;
} else if (theOption[1]=="RfM Shaders") {
TfToken shadingMode("pxrRis");
if (PxrUsdMayaShadingModeRegistry::GetInstance().GetExporter(shadingMode)) {
jobArgs.shadingMode = shadingMode;
}
}
}
if (theOption[0] == MString("exportUVs")) {
jobArgs.exportMeshUVs = theOption[1].asInt();
jobArgs.exportNurbsExplicitUV = theOption[1].asInt();
}
if (theOption[0] == MString("normalizeUVs")) {
jobArgs.normalizeMeshUVs = theOption[1].asInt();
jobArgs.nurbsExplicitUVType = PxUsdExportJobArgsTokens->Uniform;
}
if (theOption[0] == MString("exportColorSets")) {
jobArgs.exportColorSets = theOption[1].asInt();
}
if (theOption[0] == MString("renderableOnly")) {
jobArgs.excludeInvisible = theOption[1].asInt();
}
if (theOption[0] == MString("allCameras")) {
jobArgs.exportDefaultCameras = theOption[1].asInt();
}
if (theOption[0] == MString("renderLayerMode")) {
jobArgs.renderLayerMode = PxUsdExportJobArgsTokens->defaultLayer;
if (theOption[1]=="Use Current Layer") {
jobArgs.renderLayerMode = PxUsdExportJobArgsTokens->currentLayer;
} else if (theOption[1]=="Modeling Variant Per Layer") {
jobArgs.renderLayerMode = PxUsdExportJobArgsTokens->modelingVariant;
}
}
if (theOption[0] == MString("mergeXForm")) {
jobArgs.mergeTransformAndShape = theOption[1].asInt();
}
if (theOption[0] == MString("defaultMeshScheme")) {
if (theOption[1]=="Polygonal Mesh") {
jobArgs.defaultMeshScheme = UsdGeomTokens->none;
} else if (theOption[1]=="Bilinear SubDiv") {
jobArgs.defaultMeshScheme = UsdGeomTokens->bilinear;
} else if (theOption[1]=="CatmullClark SDiv") {
jobArgs.defaultMeshScheme = UsdGeomTokens->catmullClark;
} else if (theOption[1]=="Loop SDiv") {
jobArgs.defaultMeshScheme = UsdGeomTokens->loop;
}
}
if (theOption[0] == MString("exportVisibility")) {
jobArgs.exportVisibility = theOption[1].asInt();
}
if (theOption[0] == MString("animation")) {
jobArgs.exportAnimation = theOption[1].asInt();
}
if (theOption[0] == MString("startTime")) {
startTime = theOption[1].asDouble();
}
if (theOption[0] == MString("endTime")) {
endTime = theOption[1].asDouble();
}
}
// Now resync start and end frame based on animation mode
if (jobArgs.exportAnimation) {
if (endTime<startTime) endTime=startTime;
} else {
startTime=MAnimControl::currentTime().value();
endTime=startTime;
}
}
MSelectionList objSelList;
if(mode == MPxFileTranslator::kExportActiveAccessMode) {
// Get selected objects
MGlobal::getActiveSelectionList(objSelList);
} else if(mode == MPxFileTranslator::kExportAccessMode) {
// Get all objects at DAG root
objSelList.add("|*", true);
}
// Convert selection list to jobArgs dagPaths
for (unsigned int i=0; i < objSelList.length(); i++) {
MDagPath dagPath;
if (objSelList.getDagPath(i, dagPath) == MS::kSuccess) {
jobArgs.dagPaths.insert(dagPath);
}
}
if (jobArgs.dagPaths.size()) {
MTime oldCurTime = MAnimControl::currentTime();
usdWriteJob writeJob(jobArgs);
if (writeJob.beginJob(fileName, append, startTime, endTime)) {
for (double i=startTime;i<(endTime+1);i++) {
MGlobal::viewFrame(i);
writeJob.evalJob(i);
}
writeJob.endJob();
MGlobal::viewFrame(oldCurTime);
}
} else {
MGlobal::displayWarning("No DAG nodes to export. Skipping");
}
return MS::kSuccess;
}
MStatus animExport::writer( const MFileObject& file,
const MString& options,
FileAccessMode mode)
{
MStatus status = MS::kFailure;
MString fileName = file.fullName();
#if defined (OSMac_)
char fname[MAXPATHLEN];
strcpy (fname, fileName.asChar());
ofstream animFile(fname);
#else
ofstream animFile(fileName.asChar());
#endif
// Defaults.
//
MString copyFlags("copyKey -cb api -fea 1 ");
int precision = kDefaultPrecision;
bool nodeNames = true;
bool verboseUnits = false;
// Parse the options. The options syntax is in the form of
// "flag=val;flag1=val;flag2=val"
//
MString exportFlags;
if (options.length() > 0) {
const MString flagPrecision("precision");
const MString flagNodeNames("nodeNames");
const MString flagVerboseUnits("verboseUnits");
const MString flagCopyKeyCmd("copyKeyCmd");
// Start parsing.
//
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList);
unsigned nOptions = optionList.length();
for (unsigned i = 0; i < nOptions; i++) {
theOption.clear();
optionList[i].split('=', theOption);
if (theOption.length() < 1) {
continue;
}
if (theOption[0] == flagPrecision && theOption.length() > 1) {
if (theOption[1].isInt()) {
precision = theOption[1].asInt();
}
} else if ( theOption[0] ==
flagNodeNames && theOption.length() > 1) {
if (theOption[1].isInt()) {
nodeNames = (theOption[1].asInt()) ? true : false;
}
}
else if ( theOption[0] ==
flagVerboseUnits && theOption.length() > 1) {
if (theOption[1].isInt()) {
verboseUnits = (theOption[1].asInt()) ? true : false;
}
} else if ( theOption[0] ==
flagCopyKeyCmd && theOption.length() > 1) {
// Replace any '>' characters with '"'. This is needed
// since the file translator option boxes do not handle
// escaped quotation marks.
//
const char *optStr = theOption[1].asChar();
size_t nChars = strlen(optStr);
char *copyStr = new char[nChars+1];
copyStr = strcpy(copyStr, optStr);
for (size_t j = 0; j < nChars; j++) {
if (copyStr[j] == '>') {
copyStr[j] = '"';
}
}
copyFlags += copyStr;
delete [] copyStr;
}
}
}
// Set the precision of the ofstream.
//
animFile.precision(precision);
status = exportSelected(animFile, copyFlags, nodeNames, verboseUnits);
animFile.flush();
animFile.close();
return status;
}
//The writer simply goes gathers all objects from the scene.
//We will check if the object has a transform, if so, we will check
//if it's either a nurbsSphere, nurbsCone or nurbsCylinder. If so,
//we will write it out.
MStatus LepTranslator::writer ( const MFileObject& file,
const MString& options,
MPxFileTranslator::FileAccessMode mode)
{
MStatus status;
bool showPositions = false;
unsigned int i;
const MString fname = file.fullName();
ofstream newf(fname.asChar(), ios::out);
if (!newf) {
// open failed
cerr << fname << ": could not be opened for reading\n";
return MS::kFailure;
}
newf.setf(ios::unitbuf);
if (options.length() > 0) {
// Start parsing.
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList); // break out all the options.
for( i = 0; i < optionList.length(); ++i ){
theOption.clear();
optionList[i].split( '=', theOption );
if( theOption[0] == MString("showPositions") &&
theOption.length() > 1 ) {
if( theOption[1].asInt() > 0 ){
showPositions = true;
}else{
showPositions = false;
}
}
}
}
// output our magic number
newf << "<LEP>\n";
MItDag dagIterator( MItDag::kBreadthFirst, MFn::kInvalid, &status);
if ( !status) {
status.perror ("Failure in DAG iterator setup");
return MS::kFailure;
}
MSelectionList selection;
MGlobal::getActiveSelectionList (selection);
MItSelectionList selIterator (selection, MFn::kDagNode);
bool done = false;
while (true)
{
MObject currentNode;
switch (mode)
{
case MPxFileTranslator::kSaveAccessMode:
case MPxFileTranslator::kExportAccessMode:
if (dagIterator.isDone ())
done = true;
else {
currentNode = dagIterator.item ();
dagIterator.next ();
}
break;
case MPxFileTranslator::kExportActiveAccessMode:
if (selIterator.isDone ())
done = true;
else {
selIterator.getDependNode (currentNode);
selIterator.next ();
}
break;
default:
cerr << "Unrecognized write mode: " << mode << endl;
break;
}
if (done)
break;
//We only care about nodes that are transforms
MFnTransform dagNode(currentNode, &status);
if ( status == MS::kSuccess )
{
MString nodeNameNoNamespace=MNamespace::stripNamespaceFromName(dagNode.name());
for (i = 0; i < numPrimitives; ++i) {
if(nodeNameNoNamespace.indexW(primitiveStrings[i]) >= 0){
// This is a node we support
newf << primitiveCommands[i] << " -n " << nodeNameNoNamespace << endl;
if (showPositions) {
MVector pos;
pos = dagNode.getTranslation(MSpace::kObject);
newf << "move " << pos.x << " " << pos.y << " " << pos.z << endl;
}
}
}
}//if (status == MS::kSuccess)
}//while loop
newf.close();
return MS::kSuccess;
}
// Get shading engine
//
void CScriptedShapeTranslator::GetShapeInstanceShader(MDagPath& dagPath, MFnDependencyNode &shadingEngineNode)
{
// Get instance shadingEngine
shadingEngineNode.setObject(MObject::kNullObj);
// First try the usual way
MPlug shadingGroupPlug = GetNodeShadingGroup(dagPath.node(), (dagPath.isInstanced() ? dagPath.instanceNumber() : 0));
if (!shadingGroupPlug.isNull())
{
shadingEngineNode.setObject(shadingGroupPlug.node());
return;
}
char buffer[64];
// Check connection from any shadingEngine on shape
MStringArray connections;
MGlobal::executeCommand("listConnections -s 1 -d 0 -c 1 -type shadingEngine "+dagPath.fullPathName(), connections);
MSelectionList sl;
if (connections.length() == 0)
{
// Check for direct surface shader connection
MGlobal::executeCommand("listConnections -s 1 -d 0 -c 1 "+dagPath.fullPathName(), connections);
for (unsigned int cidx=0; cidx<connections.length(); cidx+=2)
{
MString srcNode = connections[cidx+1];
// Get node classification, if can find arnold/shader/surface -> got it
MStringArray rv;
MGlobal::executeCommand("getClassification `nodeType "+srcNode+"`", rv);
if (rv.length() > 0 && rv[0].indexW("arnold/shader/surface") != -1)
{
connections.clear();
MGlobal::executeCommand("listConnections -s 0 -d 1 -c 1 -type shadingEngine "+srcNode, connections);
if (connections.length() == 2)
{
sl.add(connections[1]);
}
break;
}
}
}
else if (connections.length() == 2)
{
// Single connection, use same shader for all instances
sl.add(connections[1]);
}
else if (connections.length() > 2)
{
// Many connections, expects the destination plug in shape to be an array
// Use instance number as logical index, if this fails, use first shadingEngine in list
bool found = false;
sprintf(buffer, "[%d]", dagPath.instanceNumber());
MString iidx = buffer;
for (unsigned int cidx = 0; cidx < connections.length(); cidx += 2)
{
MString conn = connections[cidx];
if (conn.length() < iidx.length())
{
continue;
}
if (conn.substring(conn.length() - iidx.length(), conn.length() - 1) != iidx)
{
continue;
}
sl.add(connections[cidx+1]);
found = true;
break;
}
if (!found)
{
MGlobal::displayWarning("[mtoaScriptedTranslators] Instance shader plug not found, use first found shadingEngine \"" + connections[1] + "\"");
sl.add(connections[1]);
}
}
if (sl.length() == 1)
{
MObject shadingEngineObj;
if (sl.getDependNode(0, shadingEngineObj) == MS::kSuccess && shadingEngineObj.apiType() == MFn::kShadingEngine)
{
shadingEngineNode.setObject(shadingEngineObj);
}
else
{
if (shadingEngineObj != MObject::kNullObj)
{
MFnDependencyNode dn(shadingEngineObj);
MGlobal::displayWarning("[mtoaScriptedTranslators] Not a shading engine \"" + dn.name() + "\"");
}
}
}
}
void ShaderValidConnection::setValidConnection()
{
MStringArray validConnection;
//null (dummy shader)
validConnection.clear();
validConnection.append("");
validConnectionMap.insert(std::make_pair("null", validConnection));
// MATERIAL -----------------------------------
/// surface ///
//anisotropic
//hairTubeShader
//lambert
validConnection.clear();
validConnection.append("color");
validConnection.append("transparency");
validConnection.append("ambientColor");
validConnection.append("incandescence");
validConnection.append("diffuse");
validConnection.append("outColor");
validConnection.append("outTransparency");
validConnectionMap.insert(std::make_pair("lambert", validConnection));
//layered shader
//blinn
validConnection.clear();
validConnection.append("color");
validConnection.append("transparency");
validConnection.append("ambientColor");
validConnection.append("incandescence");
validConnection.append("diffuse");
validConnection.append("eccentricity");
validConnection.append("specularRollOff");
validConnection.append("specularColor");
validConnection.append("reflectivity");
validConnection.append("reflectedColor");
validConnection.append("outColor");
validConnectionMap.insert(std::make_pair("blinn", validConnection));
//oceanShader
//phong
validConnection.clear();
validConnection.append("color");
validConnection.append("transparency");
validConnection.append("ambientColor");
validConnection.append("incandescence");
validConnection.append("normalCamera");
validConnection.append("diffuse");
validConnection.append("translucence");
validConnection.append("translucenceDepth");
validConnection.append("translucenceFocus");
validConnection.append("cosinePower");
validConnection.append("specularColor");
validConnection.append("reflectivity");
validConnection.append("reflectedColor");
validConnection.append("matteOpacityMode");
validConnection.append("matteOpacity");
validConnection.append("reflectionLimit");
validConnection.append("outColor");
validConnection.append("outTransparency");
validConnectionMap.insert(std::make_pair("phong", validConnection));
//phongE
//rampShader
//shadingMap
//surfaceShader
//useBackground
/// Volumetric ///
//envFog
//fluidShape
//lightFog
//particleCloud
//volumeFog
//volumeShader
/// DISPLACEMENT ///
//displacement
/// 2D Texture (normal)///
//bulge
//checker
validConnection.clear();
validConnection.append("alphaGain");
validConnection.append("alphaIsLuminance");
validConnection.append("alphaOffset");
validConnection.append("color1");//color1
validConnection.append("color1R");
validConnection.append("color1G");
validConnection.append("color1B");
validConnection.append("color2");//color2
validConnection.append("color2R");
validConnection.append("color2G");
validConnection.append("color2B");
validConnection.append("colorGain");
validConnection.append("colorOffset");
validConnection.append("contrast");
validConnection.append("defaultColor");
validConnection.append("filter");
validConnection.append("filterOffset");
validConnection.append("invert");
validConnection.append("uvCoord");//uvCoord
validConnection.append("uCoord");
validConnection.append("vCoord");
validConnection.append("outAlpha");
validConnection.append("outColor");//outColor
validConnection.append("outColorR");
validConnection.append("outColorG");
validConnection.append("outColorB");
validConnectionMap.insert(std::make_pair("checker", validConnection));
//cloth
// file
validConnection.clear();
validConnection.append("alphaGain");
validConnection.append("alphaIsLuminance");
validConnection.append("alphaOffset");
validConnection.append("colorGain");
validConnection.append("colorOffset");
validConnection.append("defaultColor");
validConnection.append("fileTextureName");
validConnection.append("filterType");
validConnection.append("filter");
validConnection.append("filterOffset");
validConnection.append("invert");
validConnection.append("uvCoord");
validConnection.append("fileHasAlpha");
validConnection.append("outAlpha");
validConnection.append("outColor");
validConnection.append("outTransparency");
validConnectionMap.insert(std::make_pair("file", validConnection));
//fluidTexture2D
//fractal
//grid
//mountain
//movie
//noise
//ocean
//psdFileTex
//ramp
//water
/// 3D Textures ///
//brownian
//cloud
//crater
//fluidTexture3D
//granite
//leather
//marble
//rock
//snow
//solidFractal
//stucco
//volumeNoise
//wood
/// Env Textures ///
//envBall
//envChrome
//envCube
//envSky
//envSphere
/// other textures ///
//layeredTexture
/// Lights ///
//ambientLight
//areaLight
//directionalLight
//pointLight
//spotLight
//volumeLight
/// General utilities ///
//arrayMapper
//bump2d
validConnection.clear();
validConnection.append("bumpValue");
validConnection.append("bumpDepth");
validConnection.append("bumpInterp");
validConnection.append("bumpFilter");
validConnection.append("bumpFilterOffset");
validConnection.append("normalCamera");
validConnection.append("bumpNormal");
validConnection.append("outNormal");
validConnectionMap.insert(std::make_pair("bump2d", validConnection));
//bump3d
validConnection.clear();
validConnection.append("bumpValue");
validConnection.append("bumpDepth");
validConnection.append("bumpFilter");
validConnection.append("bumpFilterOffset");
validConnection.append("normalCamera");
validConnection.append("outNormal");
validConnectionMap.insert(std::make_pair("bump3d", validConnection));
//condition
//distanceBetween
//heightField
//lightInfo
//multiplyDivide
//place2dTexture
validConnection.clear();
validConnection.append("uvCoord");
validConnection.append("coverageU");
validConnection.append("coverageV");
validConnection.append("coverage");
validConnection.append("mirrorU");
validConnection.append("mirrorV");
validConnection.append("noiseU");
validConnection.append("noiseV");
validConnection.append("noiseUV");
validConnection.append("offsetU");
validConnection.append("offsetV");
validConnection.append("offset");
validConnection.append("repeatU");
validConnection.append("repeatV");
validConnection.append("repeatUV");
validConnection.append("rotateFrame");
validConnection.append("rotateUV");
validConnection.append("stagger");
validConnection.append("translateFrameU");
validConnection.append("translateFrameV");
validConnection.append("translateFrame");
validConnection.append("wrapU");
validConnection.append("wrapV");
validConnection.append("outUV");
validConnectionMap.insert(std::make_pair("place2dTexture", validConnection));
//place3dTexture
//plusMinusAverage
//projection
//reverse
//samplerInfo
//setRange
//stencil
//studioClearCoat
//uvChooser
//vectorProduct
/// color utilities ///
//blendColors
//clamp
//contrast
//gammaCorrect
//hsvToRgb
//luminance
//remapColor
//remapHsv
//remapValue
//rgbToHsv
//smear
//surfaceLuminance
/// switch utilities ///
//doubleShadingSwitch
//quadShadingSwitch
//singleShadingSwitch
//tripleShadingSwitch
/// particle utilities ///
//particleSamplerInfo
/// image planes ///
//imagePlane
/// glow ///
//opticalFX
setValidConnection_mi();
}
MStatus atomImport::reader( const MFileObject& file,
const MString& options,
FileAccessMode mode)
{
MStatus status = MS::kFailure;
MString fileName = file.fullName();
#if defined (OSMac_)
char fname[MAXPATHLEN];
strcpy (fname, fileName.asChar());
ifstream animFile(fname);
#else
ifstream animFile(fileName.asChar());
#endif
// Parse the options. The options syntax is in the form of
// "flag=val;flag1=val;flag2=val"
//
if(animFile.good()==false)
return status;
MString pasteFlags;
MString prefix;
MString suffix;
MString search;
MString replace;
MString mapFile;
bool replaceLayers = false;
MString exportEditsFile;
bool includeChildren = false;
atomNodeNameReplacer::ReplaceType type = atomNodeNameReplacer::eHierarchy;
MString templateName;
MString viewName;
bool useTemplate = false;
if (options.length() > 0) {
// Set up the flags for the paste command.
//
const MString flagSrcTime("srcTime");
const MString flagDstTime("dstTime");
const MString flagOldDstTime("time");
const MString flagCopies("copies");
const MString flagOption("option");
const MString flagConnect("connect");
const MString flagMatch("match");
const MString flagSearch("search");
const MString flagReplace("replace");
const MString flagPrefix("prefix");
const MString flagSuffix("suffix");
const MString flagMapFile("mapFile");
const MString flagHierarchy("hierarchy");
const MString flagString("string");
const MString flagSelected("selected");
const MString flagTemplate("template");
const MString flagView("view");
const MString optionChildrenToo("childrenToo");
const MString optionTemplate("template");
const MString flagExportEdits("exportEdits");
MString copyValue;
MString flagValue;
MString connectValue;
MString match;
MString srcTimeValue;
MString dstTimeValue;
// Start parsing.
//
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList);
unsigned nOptions = optionList.length();
for (unsigned i = 0; i < nOptions; i++) {
theOption.clear();
optionList[i].split('=', theOption);
if (theOption.length() < 1) {
continue;
}
if (theOption[0] == flagCopies && theOption.length() > 1) {
copyValue = theOption[1];;
} else if (theOption[0] == flagOption && theOption.length() > 1) {
flagValue = theOption[1];
} else if (theOption[0] == flagConnect && theOption.length() > 1) {
if (theOption[1].asInt() != 0) {
connectValue += theOption[1];
}
}
else if( theOption[0] == flagTemplate && theOption.length() > 1)
{
templateName = theOption[1];
}
else if( theOption[0] == flagView && theOption.length() > 1)
{
viewName = theOption[1];
}
else if (theOption[0] == flagSrcTime && theOption.length() > 1) {
srcTimeValue += theOption[1];
}
else if ((theOption[0] == flagDstTime || theOption[0] == flagOldDstTime )&& theOption.length() > 1) {
dstTimeValue += theOption[1];
}
else if (theOption[0] == flagMatch && theOption.length() > 1) {
match = theOption[1];
}
else if (theOption[0] == flagSearch && theOption.length() > 1) {
search = theOption[1];
}
else if (theOption[0] == flagReplace && theOption.length() > 1) {
replace = theOption[1];
}
else if (theOption[0] == flagPrefix && theOption.length() > 1) {
prefix = theOption[1];
}
else if (theOption[0] == flagSuffix && theOption.length() > 1) {
suffix = theOption[1];
}
else if (theOption[0] == flagMapFile && theOption.length() > 1) {
mapFile = theOption[1];
}
else if (theOption[0] == flagSelected && theOption.length() > 1) {
includeChildren = (theOption[1] == optionChildrenToo) ? true : false;
if(theOption[1] == optionTemplate)
useTemplate = true;
}
else if (theOption[0] == flagExportEdits && theOption.length() > 1) {
exportEditsFile = theOption[1];
}
}
if (copyValue.length() > 0) {
pasteFlags += " -copies ";
pasteFlags += copyValue;
pasteFlags += " ";
}
if (flagValue.length() > 0) {
pasteFlags += " -option \"";
pasteFlags += flagValue;
pasteFlags += "\" ";
if(flagValue == MString("replace"))
replaceLayers = true;
}
if (connectValue.length() > 0) {
pasteFlags += " -connect ";
pasteFlags += connectValue;
pasteFlags += " ";
}
if (dstTimeValue.length() > 0) {
bool useQuotes = !dstTimeValue.isDouble();
pasteFlags += " -time ";
if (useQuotes) pasteFlags += "\"";
pasteFlags += dstTimeValue;
if (useQuotes) pasteFlags += "\"";
pasteFlags += " ";
}
if (srcTimeValue.length() > 0)
{
MTime lClipStartTime;
MTime lClipEndTime;
MStringArray lTimes;
if ( MStatus::kSuccess == srcTimeValue.split( L':', lTimes ) )
{
if ( lTimes.length() > 0 )
{
double lImportStartFrame = lTimes[0].asDouble();
double lImportEndFrame = lImportStartFrame;
if ( lTimes.length() > 1 )
{
lImportEndFrame = lTimes[1].asDouble();
}
fReader.setImportFrameRange( lImportStartFrame, lImportEndFrame );
}
else
{
fReader.clearImportFrameRange();
}
}
}
else
{
fReader.clearImportFrameRange();
}
if(match.length() >0)
{
if(match == flagHierarchy)
type = atomNodeNameReplacer::eHierarchy;
else if(match == flagString)
type = atomNodeNameReplacer::eSearchReplace;
else if(match == flagMapFile)
type = atomNodeNameReplacer::eMapFile;
} //not set, then we leave what we had
}
// If the selection list is empty, there is nothing to import.
//
MSelectionList sList;
std::vector<unsigned int> depths;
atomTemplateReader templateReader;
if(useTemplate == true)
{
templateReader.setTemplate(templateName,viewName);
includeChildren = false;
templateReader.selectNodes(); //make the selection set be us.
}
SelectionGetter::getSelectedObjects(includeChildren,sList,depths);
if (sList.isEmpty()) {
MString msg = MStringResource::getString(kNothingSelected, status);
MGlobal::displayError(msg);
return (MS::kFailure);
}
atomNodeNameReplacer replacer(type,sList,depths,prefix,suffix,search,replace,mapFile);
if (mode == kImportAccessMode) {
status = importAnim(sList,animFile,pasteFlags,replacer,exportEditsFile,templateReader,replaceLayers);
}
animFile.close();
return status;
}
MStatus animImport::reader( const MFileObject& file,
const MString& options,
FileAccessMode mode)
{
MStatus status = MS::kFailure;
MString fileName = file.fullName();
#if defined (OSMac_)
char fname[MAXPATHLEN];
strcpy (fname, fileName.asChar());
ifstream animFile(fname);
#else
ifstream animFile(fileName.asChar());
#endif
// Parse the options. The options syntax is in the form of
// "flag=val;flag1=val;flag2=val"
//
MString pasteFlags;
if (options.length() > 0) {
// Set up the flags for the paste command.
//
const MString flagTargetTime("targetTime");
const MString flagTime("time");
const MString flagCopies("copies");
const MString flagOption("option");
const MString flagConnect("connect");
MString copyValue;
MString flagValue;
MString connectValue;
MString timeValue;
// Start parsing.
//
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList);
unsigned nOptions = optionList.length();
for (unsigned i = 0; i < nOptions; i++) {
theOption.clear();
optionList[i].split('=', theOption);
if (theOption.length() < 1) {
continue;
}
if (theOption[0] == flagCopies && theOption.length() > 1) {
copyValue = theOption[1];;
} else if (theOption[0] == flagOption && theOption.length() > 1) {
flagValue = theOption[1];
} else if (theOption[0] == flagConnect && theOption.length() > 1) {
if (theOption[1].asInt() != 0) {
connectValue += theOption[1];
}
} else if (theOption[0] == flagTime && theOption.length() > 1) {
timeValue += theOption[1];
}
}
if (copyValue.length() > 0) {
pasteFlags += " -copies ";
pasteFlags += copyValue;
pasteFlags += " ";
}
if (flagValue.length() > 0) {
pasteFlags += " -option \"";
pasteFlags += flagValue;
pasteFlags += "\" ";
}
if (connectValue.length() > 0) {
pasteFlags += " -connect ";
pasteFlags += connectValue;
pasteFlags += " ";
}
if (timeValue.length() > 0) {
bool useQuotes = !timeValue.isDouble();
pasteFlags += " -time ";
if (useQuotes) pasteFlags += "\"";
pasteFlags += timeValue;
if (useQuotes) pasteFlags += "\"";
pasteFlags += " ";
}
}
if (mode == kImportAccessMode) {
status = importAnim(animFile, pasteFlags);
}
animFile.close();
return status;
}
MStatus atomExport::writer( const MFileObject& file,
const MString& options,
FileAccessMode mode)
{
MStatus status = MS::kFailure;
MString fileName = file.fullName();
#if defined (OSMac_)
char fname[MAXPATHLEN];
strcpy (fname, fileName.asChar());
ofstream animFile(fname);
#else
ofstream animFile(fileName.asChar());
#endif
// Defaults.
//
MString copyFlags("copyKey -cb api -fea 1 ");
int precision = kDefaultPrecision;
bool statics = false;
bool includeChildren = false;
std::set<std::string> attrStrings;
// Parse the options. The options syntax is in the form of
// "flag=val;flag1=val;flag2=val"
//
bool useSpecifiedRange = false;
bool useTemplate = false;
bool cached = false;
bool constraint = false;
bool sdk = false;
bool animLayers = true;
MString templateName;
MString viewName;
MTime startTime = MAnimControl::animationStartTime();
MTime endTime = MAnimControl::animationEndTime();
MString exportEditsFile;
MString exportFlags;
if (options.length() > 0) {
const MString flagPrecision("precision");
const MString flagStatics("statics");
const MString flagConstraint("constraint");
const MString flagSDK("sdk");
const MString flagAnimLayers("animLayers");
const MString flagCopyKeyCmd("copyKeyCmd");
const MString flagSelected("selected");
const MString flagTemplate("template");
const MString flagView("view");
const MString optionChildrenToo("childrenToo");
const MString optionTemplate("template");
const MString flagAttr("at");
const MString flagWhichRange("whichRange");
const MString flagRange("range");
const MString flagExportEdits("exportEdits");
const MString flagCached("baked");
// Start parsing.
//
MStringArray optionList;
MStringArray theOption;
options.split(';', optionList);
unsigned nOptions = optionList.length();
for (unsigned i = 0; i < nOptions; i++) {
theOption.clear();
optionList[i].split('=', theOption);
if (theOption.length() < 1) {
continue;
}
if (theOption[0] == flagPrecision && theOption.length() > 1) {
if (theOption[1].isInt()) {
precision = theOption[1].asInt();
}
}
else if( theOption[0] == flagTemplate && theOption.length() > 1)
{
templateName = theOption[1];
}
else if( theOption[0] == flagView && theOption.length() > 1)
{
viewName = theOption[1];
}
else if ( theOption[0] ==
flagWhichRange && theOption.length() > 1) {
if (theOption[1].isInt())
useSpecifiedRange = (theOption[1].asInt() ==1) ? false : true;
}
else if ( theOption[0] ==
flagRange && theOption.length() > 1)
{
MStringArray rangeArray;
theOption[1].split(':',rangeArray);
if(rangeArray.length()==2)
{
if(rangeArray[0].isDouble())
{
double val = rangeArray[0].asDouble();
startTime = MTime(val,MTime::uiUnit());
}
else if(rangeArray[0].isInt())
{
double val = (double)rangeArray[0].asInt();
startTime = MTime(val,MTime::uiUnit());
}
if(rangeArray[1].isDouble())
{
double val = rangeArray[1].asDouble();
endTime = MTime(val,MTime::uiUnit());
}
else if(rangeArray[1].isInt())
{
double val = (double)rangeArray[1].asInt();
endTime = MTime(val,MTime::uiUnit());
}
}
}
else if ( theOption[0] ==
flagStatics && theOption.length() > 1) {
if (theOption[1].isInt()) {
statics = (theOption[1].asInt()) ? true : false;
}
}
else if ( theOption[0] ==
flagSDK && theOption.length() > 1) {
if (theOption[1].isInt()) {
sdk = (theOption[1].asInt()) ? true : false;
}
}
else if ( theOption[0] ==
flagConstraint && theOption.length() > 1) {
if (theOption[1].isInt()) {
constraint = (theOption[1].asInt()) ? true : false;
}
}
else if ( theOption[0] ==
flagAnimLayers && theOption.length() > 1) {
if (theOption[1].isInt()) {
animLayers = (theOption[1].asInt()) ? true : false;
}
}
else if ( theOption[0] ==
flagCached && theOption.length() > 1) {
if (theOption[1].isInt()) {
cached = (theOption[1].asInt()) ? true : false;
}
}
else if (theOption[0] == flagSelected && theOption.length() > 1) {
includeChildren = (theOption[1] == optionChildrenToo) ? true : false;
if(theOption[1] == optionTemplate)
useTemplate = true;
}
else if (theOption[0] == flagAttr && theOption.length() > 1) {
std::string str(theOption[1].asChar());
attrStrings.insert(str);
}
else if ( theOption[0] ==
flagCopyKeyCmd && theOption.length() > 1) {
// Replace any '>' characters with '"'. This is needed
// since the file translator option boxes do not handle
// escaped quotation marks.
//
const char *optStr = theOption[1].asChar();
size_t nChars = strlen(optStr);
char *copyStr = new char[nChars+1];
copyStr = strcpy(copyStr, optStr);
for (size_t j = 0; j < nChars; j++) {
if (copyStr[j] == '>') {
copyStr[j] = '"';
}
}
copyFlags += copyStr;
delete [] copyStr;
}
else if (theOption[0] == flagExportEdits && theOption.length() > 1)
{
exportEditsFile = theOption[1];
}
}
}
// Set the precision of the ofstream.
//
animFile.precision(precision);
atomTemplateReader templateReader;
if(useTemplate == true)
{
includeChildren = false;
templateReader.setTemplate(templateName,viewName);
templateReader.selectNodes(); //make the template nodes be the selection
}
status = exportSelected(animFile, copyFlags, attrStrings, includeChildren,
useSpecifiedRange, startTime, endTime, statics,
cached,sdk,constraint, animLayers, exportEditsFile,templateReader);
animFile.flush();
animFile.close();
return status;
}
MStatus rtgTranslator::writer ( const MFileObject & fileObject,
const MString & options,
MPxFileTranslator::FileAccessMode mode)
{
char LTmpStr[MAXPATHLEN];
unsigned int i;
int LN;
const MString fname = fileObject.fullName ();
MString extension;
MString baseFileName;
int TimeSlider = 0;
int AnimEnabled = 0;
// Lets strip off the known extension of .rtg if it is there.
extension.set (".rtg");
int extLocation = fileObject.name ().rindex ('.');
if (extLocation > 0 && fileObject.name ().substring (extLocation,
fileObject.name ().length () - 1) == extension)
{
baseFileName = fileObject.name ().substring (0, extLocation - 1);
} else
{
baseFileName = fileObject.name ();
extension.clear ();
}
DtExt_SceneInit( (char *)baseFileName.asChar() );
// Lets now do all of the option processing
if (options.length () > 0)
{
//Start parsing.
MStringArray optionList;
MStringArray theOption;
options.split (';', optionList);
//break out all the options.
for ( i = 0; i < optionList.length (); ++i)
{
theOption.clear ();
optionList[i].split ('=', theOption);
if (theOption.length () > 1)
{
if (theOption[0] == MString ("v18compatible"))
{
rtg_v18_compatible = (int) (theOption[1].asInt() );
} else if (theOption[0] == MString ("timeslider"))
{
TimeSlider = (int) (theOption[1].asInt ());
} else if (theOption[0] == MString ("animEnabled"))
{
AnimEnabled = (int) (theOption[1].asInt ());
} else if (theOption[0] == MString ("animStart"))
{
DtFrameSetStart( (int) (theOption[1].asInt ()) );
} else if (theOption[0] == MString ("animEnd"))
{
DtFrameSetEnd( (int) (theOption[1].asInt ()) );
} else if (theOption[0] == MString ("animStep"))
{
DtFrameSetBy( (int) (theOption[1].asInt ()) );
} else if (theOption[0] == MString ("hrcType"))
{
switch ( theOption[1].asInt () - 1)
{
case VRHRC_FLAT:
DtExt_setOutputTransforms (kTRANSFORMMINIMAL);
DtExt_setParents (0);
break;
case VRHRC_WORLD:
DtExt_setOutputTransforms (kTRANSFORMNONE);
DtExt_setParents (0);
break;
case VRHRC_FULL:
default:
DtExt_setOutputTransforms (kTRANSFORMALL);
DtExt_setParents (1);
break;
}
} else if (theOption[0] == MString ("joints"))
{
// Allow user to specify if the hierarchy should include
// NULL geometry nodes - usually joints
DtExt_setJointHierarchy( theOption[1].asInt() );
} else if (theOption[0] == MString ("exportSel"))
{
switch ( theOption[1].asInt () - 1)
{
case VRSEL_ALL:
DtExt_setWalkMode (ALL_Nodes);
break;
case VRSEL_ACTIVE:
DtExt_setWalkMode (ACTIVE_Nodes);
break;
case VRSEL_PICKED:
DtExt_setWalkMode (PICKED_Nodes);
break;
}
} else if (theOption[0] == MString ("texsample"))
{
// Allow user to specify if the textures should be sampled
// with the Texture Placement options
DtExt_setSoftTextures ( theOption[1].asInt() );
} else if (theOption[0] == MString ("texevaluate"))
{
// Allow the user to specify if the tex should be eval with
// convertSolidTx command or read in if is a file texture.
DtExt_setInlineTextures( theOption[1].asInt() );
} else if (theOption[0] == MString ("texoriginal"))
{
// Allow the user to specify if the tex should be eval at all.
DtExt_setOriginalTexture( theOption[1].asInt() );
} else if (theOption[0] == MString ("Xtexres"))
{
// Set the X size of the texture swatches to use
DtExt_setXTextureRes ( theOption[1].asInt () );
} else if (theOption[0] == MString ("Ytexres"))
{
// Set the Y size of the texture swatches to use
DtExt_setYTextureRes ( theOption[1].asInt () );
} else if (theOption[0] == MString ("MaxXtexres"))
{
// Set the Max X size of the texture swatches to use
DtExt_setMaxXTextureRes( theOption[1].asInt () );
} else if (theOption[0] == MString ("MaxYtexres"))
{
// Set the Max Y size of the texture swatches to use
DtExt_setMaxYTextureRes( theOption[1].asInt () );
} else if (theOption[0] == MString ("precision"))
{
//VR_Precision = theOption[1].asInt ();
} else if (theOption[0] == MString ("verbose"))
{
// DtExt_setDebug ( theOption[1].asInt () );
} else if (theOption[0] == MString ("debug"))
{
int levelG = DtExt_Debug();
if ( (int) (theOption[1].asInt () ) )
levelG |= DEBUG_GEOMAT;
else
levelG &= ~DEBUG_GEOMAT;
DtExt_setDebug( levelG );
} else if (theOption[0] == MString ("debugC"))
{
int levelC = DtExt_Debug();
if ( (int) (theOption[1].asInt () ) )
levelC |= DEBUG_CAMERA;
else
levelC &= ~DEBUG_CAMERA;
DtExt_setDebug( levelC );
} else if (theOption[0] == MString ("debugL"))
{
int levelL = DtExt_Debug();
if ( (int) (theOption[1].asInt () ) )
levelL |= DEBUG_LIGHT;
else
levelL &= ~DEBUG_LIGHT;
DtExt_setDebug( levelL );
} else if (theOption[0] == MString ("reversed"))
{
DtExt_setWinding( theOption[1].asInt() );
} else if (theOption[0] == MString ("tesselation"))
{
if ( theOption[1].asInt() == 2 )
{
DtExt_setTesselate( kTESSQUAD );
} else {
DtExt_setTesselate( kTESSTRI );
}
//
// Now come the translator specific options
//
} else if (theOption[0] == MString ("imageformat"))
{
rtg_output_image_format = theOption[1].asInt();
} else if (theOption[0] == MString ("fileformat"))
{
rtg_output_file_format = theOption[1].asInt();
} else if (theOption[0] == MString ("vnormals"))
{
rtg_output_vert_norms = theOption[1].asInt();
} else if (theOption[0] == MString ("vcolors"))
{
rtg_output_vert_colors = theOption[1].asInt();
} else if (theOption[0] == MString ("tcoords"))
{
rtg_output_tex_coords = theOption[1].asInt();
} else if (theOption[0] == MString ("pnormals"))
{
rtg_output_poly_norms = theOption[1].asInt();
} else if (theOption[0] == MString ("idxcnt"))
{
rtg_show_index_counters = theOption[1].asInt();
} else if (theOption[0] == MString ("anglesdeg"))
{
rtg_output_degrees = theOption[1].asInt();
} else if (theOption[0] == MString ("materials"))
{
rtg_output_materials = theOption[1].asInt();
} else if (theOption[0] == MString ("multitexture"))
{
DtExt_setMultiTexture( theOption[1].asInt() );
} else if (theOption[0] == MString ("mdecomp"))
{
rtg_output_decomp = theOption[1].asInt();
} else if (theOption[0] == MString ("pivoth"))
{
rtg_output_pivots = theOption[1].asInt();
} else if (theOption[0] == MString ("transforms"))
{
rtg_output_transforms = theOption[1].asInt();
} else if (theOption[0] == MString ("ltransforms"))
{
rtg_output_local = theOption[1].asInt();
} else if (theOption[0] == MString ("animation"))
{
rtg_output_animation = theOption[1].asInt();
} else if (theOption[0] == MString ("allnodes"))
{
rtg_output_all_nodes = theOption[1].asInt();
} else if (theOption[0] == MString ("script"))
{
scriptToRun = theOption[1];
} else if (theOption[0] == MString ("scriptAppend"))
{
scriptAppend = (int)(theOption[1].asInt() );
}
}
}
}
// Lets see how we entered this plug-in, either with the export all
// or export selection flag set.
if ( mode == MPxFileTranslator::kExportActiveAccessMode )
{
DtExt_setWalkMode ( ACTIVE_Nodes );
}
// Lets check the TimeSlider control now:
if ( TimeSlider )
{
MTime start( MAnimControl::minTime().value(), MTime::uiUnit() );
DtFrameSetStart( (int) start.value() );
MTime end( MAnimControl::maxTime().value(), MTime::uiUnit() );
DtFrameSetEnd( (int) end.value() );
}
// Now see if the animation is really enabled.
// Else we will set the end frame to the beginning frame automatically
if ( !AnimEnabled )
{
DtFrameSetEnd( DtFrameGetStart() );
}
// Find out where the file is supposed to end up.
MDt_GetPathName ((char *) (fname.asChar ()), LTmpStr, MAXPATHLEN);
LN = (int)strlen (LTmpStr);
if (LTmpStr[LN - 1] == '/')
LTmpStr[LN - 1] = '\0';
DtSetDirectory (LTmpStr);
// Now lets setup some paths to do basic texture file searching
// for those textures with relative paths
MStringArray wSpacePaths;
MStringArray rPaths;
MString usePath;
MString separator;
MGlobal::executeCommand( "workspace -q -rd", wSpacePaths );
MGlobal::executeCommand( "workspace -q -rtl", rPaths );
if ( DtExt_getTextureSearchPath() )
separator.set( "|" );
else
separator.set( "" );
for (i = 0; i < wSpacePaths.length (); ++i)
{
for ( unsigned int j = 0; j < rPaths.length(); j++ )
{
usePath = usePath + separator + wSpacePaths[i] + MString( "/" ) + rPaths[j];
separator.set( "|" );
if ( rPaths[j] == MString( "sourceImages" ) )
usePath = usePath + separator + wSpacePaths[i] + MString( "/" )
+ MString( "sourceimages" );
}
}
DtExt_addTextureSearchPath( (char *)usePath.asChar() );
// Now we can setup the database from the wire file geometry.
// This is where all the Maya data are retrieved, cached, and processed.
//
// Say that we want to have camera info
DtExt_setOutputCameras( 1 );
//Now we can setup the database from the wire file geometry
DtExt_dbInit();
DtFrameSet( DtFrameGetStart() );
// Now do the export
rtgExport();
// Now lets see if the user wants something else to be done
if ( 0 < scriptToRun.length() )
{
if ( scriptAppend )
{
scriptToRun += MString( " " ) + MString( LTmpStr );
}
system( scriptToRun.asChar() );
}
// Clean house.
//
DtExt_CleanUp();
return MS::kSuccess;
}
