//-----------------------------------------------------------------------------------
visualizeMeshNode::meshStatus visualizeMeshNode::getMeshStatus()
//-----------------------------------------------------------------------------------
{
MDagPath visNodePath, transform;
MDagPath::getAPathTo( thisMObject(), visNodePath);
transform = visNodePath;
transform.pop(); //transform
MSelectionList activeList;
//momentan checken wir nur, ob das Mesh selected ist oder nicht
MGlobal::getActiveSelectionList(activeList);
if( ( activeList.hasItem(transform.node()) || activeList.hasItem( transform ) ) )
return kSelected;
MGlobal::getHiliteList(activeList);
if( ( activeList.hasItem(transform.node()) || activeList.hasItem( transform ) ) )
return kHilited;
return kNone;
// Nur zum testen
// return kSelected;
}
bool OpenSubdivDrawOverride::getSelectionStatus(const MDagPath& objPath) const
{
// retrieve the selection status of the node
MStatus status;
MSelectionList selectedList;
status = MGlobal::getActiveSelectionList(selectedList);
if(!status)
return false;
MDagPath pathCopy = objPath;
do {
if(selectedList.hasItem(pathCopy)) return true;
status = pathCopy.pop();
} while(status);
return false;
}
bool ToMayaSkinClusterConverter::doConversion( IECore::ConstObjectPtr from, MObject &to, IECore::ConstCompoundObjectPtr operands ) const
{
MStatus s;
IECore::ConstSmoothSkinningDataPtr skinningData = IECore::runTimeCast<const IECore::SmoothSkinningData>( from );
assert( skinningData );
const std::vector<std::string> &influenceNames = skinningData->influenceNames()->readable();
const std::vector<Imath::M44f> &influencePoseData = skinningData->influencePose()->readable();
const std::vector<int> &pointIndexOffsets = skinningData->pointIndexOffsets()->readable();
const std::vector<int> &pointInfluenceCounts = skinningData->pointInfluenceCounts()->readable();
const std::vector<int> &pointInfluenceIndices = skinningData->pointInfluenceIndices()->readable();
const std::vector<float> &pointInfluenceWeights = skinningData->pointInfluenceWeights()->readable();
MFnDependencyNode fnSkinClusterNode( to, &s );
MFnSkinCluster fnSkinCluster( to, &s );
if ( s != MS::kSuccess )
{
/// \todo: optional parameter to allow custom node types and checks for the necessary attributes
/// \todo: create a new skinCluster if we want a kSkinClusterFilter and this isn't one
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid skinCluster" ) % fnSkinClusterNode.name() ).str() );
}
const unsigned origNumInfluences = influenceNames.size();
unsigned numInfluences = origNumInfluences;
std::vector<bool> ignoreInfluence( origNumInfluences, false );
std::vector<int> indexMap( origNumInfluences, -1 );
const bool ignoreMissingInfluences = m_ignoreMissingInfluencesParameter->getTypedValue();
const bool ignoreBindPose = m_ignoreBindPoseParameter->getTypedValue();
// gather the influence objects
MObject mObj;
MDagPath path;
MSelectionList influenceList;
MDagPathArray influencePaths;
for ( unsigned i=0, index=0; i < origNumInfluences; i++ )
{
MString influenceName( influenceNames[i].c_str() );
s = influenceList.add( influenceName );
if ( !s )
{
if ( ignoreMissingInfluences )
{
ignoreInfluence[i] = true;
MGlobal::displayWarning( MString( "ToMayaSkinClusterConverter: \"" + influenceName + "\" is not a valid influence" ) );
continue;
}
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid influence" ) % influenceName ).str() );
}
influenceList.getDependNode( index, mObj );
MFnIkJoint fnInfluence( mObj, &s );
if ( !s )
{
if ( ignoreMissingInfluences )
{
ignoreInfluence[i] = true;
influenceList.remove( index );
MGlobal::displayWarning( MString( "ToMayaSkinClusterConverter: \"" + influenceName + "\" is not a valid influence" ) );
continue;
}
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid influence" ) % influenceName ).str() );
}
fnInfluence.getPath( path );
influencePaths.append( path );
indexMap[i] = index;
index++;
}
MPlugArray connectedPlugs;
bool existingBindPose = true;
MPlug bindPlug = fnSkinClusterNode.findPlug( "bindPose", true, &s );
if ( !bindPlug.connectedTo( connectedPlugs, true, false ) )
{
existingBindPose = false;
if ( !ignoreBindPose )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" does not have a valid bindPose" ) % fnSkinClusterNode.name() ).str() );
}
}
MPlug bindPoseMatrixArrayPlug;
MPlug bindPoseMemberArrayPlug;
if ( existingBindPose )
{
MFnDependencyNode fnBindPose( connectedPlugs[0].node() );
if ( fnBindPose.typeName() != "dagPose" )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid bindPose" ) % fnBindPose.name() ).str() );
}
bindPoseMatrixArrayPlug = fnBindPose.findPlug( "worldMatrix", true, &s );
bindPoseMemberArrayPlug = fnBindPose.findPlug( "members", true, &s );
}
/// \todo: optional parameter to reset the skinCluster's geomMatrix plug
// break existing influence connections to the skinCluster
MDGModifier dgModifier;
MMatrixArray ignoredPreMatrices;
MPlug matrixArrayPlug = fnSkinClusterNode.findPlug( "matrix", true, &s );
MPlug bindPreMatrixArrayPlug = fnSkinClusterNode.findPlug( "bindPreMatrix", true, &s );
for ( unsigned i=0; i < matrixArrayPlug.numConnectedElements(); i++ )
{
MPlug matrixPlug = matrixArrayPlug.connectionByPhysicalIndex( i, &s );
matrixPlug.connectedTo( connectedPlugs, true, false );
if ( !connectedPlugs.length() )
{
continue;
}
MFnIkJoint fnInfluence( connectedPlugs[0].node() );
fnInfluence.getPath( path );
if ( ignoreMissingInfluences && !influenceList.hasItem( path ) )
{
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( i );
preMatrixPlug.getValue( mObj );
MFnMatrixData matFn( mObj );
ignoredPreMatrices.append( matFn.matrix() );
ignoreInfluence.push_back( false );
indexMap.push_back( influenceList.length() );
influenceList.add( connectedPlugs[0].node() );
numInfluences++;
}
dgModifier.disconnect( connectedPlugs[0], matrixPlug );
}
MPlug lockArrayPlug = fnSkinClusterNode.findPlug( "lockWeights", true, &s );
for ( unsigned i=0; i < lockArrayPlug.numConnectedElements(); i++ )
{
MPlug lockPlug = lockArrayPlug.connectionByPhysicalIndex( i, &s );
lockPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], lockPlug );
}
}
MPlug paintPlug = fnSkinClusterNode.findPlug( "paintTrans", true, &s );
paintPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], paintPlug );
}
// break existing influence connections to the bind pose
if ( existingBindPose )
{
for ( unsigned i=0; i < bindPoseMatrixArrayPlug.numConnectedElements(); i++ )
{
MPlug matrixPlug = bindPoseMatrixArrayPlug.connectionByPhysicalIndex( i, &s );
matrixPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], matrixPlug );
}
}
for ( unsigned i=0; i < bindPoseMemberArrayPlug.numConnectedElements(); i++ )
{
MPlug memberPlug = bindPoseMemberArrayPlug.connectionByPhysicalIndex( i, &s );
memberPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], memberPlug );
}
}
}
if ( !dgModifier.doIt() )
{
dgModifier.undoIt();
throw IECore::Exception( "ToMayaSkinClusterConverter: Unable to break the influence connections" );
}
// make connections from influences to skinCluster and bindPose
for ( unsigned i=0; i < numInfluences; i++ )
{
if ( ignoreInfluence[i] )
{
continue;
}
int index = indexMap[i];
s = influenceList.getDependNode( index, mObj );
MFnIkJoint fnInfluence( mObj, &s );
MPlug influenceMatrixPlug = fnInfluence.findPlug( "worldMatrix", true, &s ).elementByLogicalIndex( 0, &s );
MPlug influenceMessagePlug = fnInfluence.findPlug( "message", true, &s );
MPlug influenceBindPosePlug = fnInfluence.findPlug( "bindPose", true, &s );
MPlug influenceLockPlug = fnInfluence.findPlug( "lockInfluenceWeights", true, &s );
if ( !s )
{
// add the lockInfluenceWeights attribute if it doesn't exist
MFnNumericAttribute nAttr;
MObject attribute = nAttr.create( "lockInfluenceWeights", "liw", MFnNumericData::kBoolean, false );
fnInfluence.addAttribute( attribute );
influenceLockPlug = fnInfluence.findPlug( "lockInfluenceWeights", true, &s );
}
// connect influence to the skinCluster
MPlug matrixPlug = matrixArrayPlug.elementByLogicalIndex( index );
MPlug lockPlug = lockArrayPlug.elementByLogicalIndex( index );
dgModifier.connect( influenceMatrixPlug, matrixPlug );
dgModifier.connect( influenceLockPlug, lockPlug );
// connect influence to the bindPose
if ( !ignoreBindPose )
{
MPlug bindPoseMatrixPlug = bindPoseMatrixArrayPlug.elementByLogicalIndex( index );
MPlug memberPlug = bindPoseMemberArrayPlug.elementByLogicalIndex( index );
dgModifier.connect( influenceMessagePlug, bindPoseMatrixPlug );
dgModifier.connect( influenceBindPosePlug, memberPlug );
}
}
unsigned firstIndex = find( ignoreInfluence.begin(), ignoreInfluence.end(), false ) - ignoreInfluence.begin();
influenceList.getDependNode( firstIndex, mObj );
MFnDependencyNode fnInfluence( mObj );
MPlug influenceMessagePlug = fnInfluence.findPlug( "message", true, &s );
dgModifier.connect( influenceMessagePlug, paintPlug );
if ( !dgModifier.doIt() )
{
dgModifier.undoIt();
throw IECore::Exception( "ToMayaSkinClusterConverter: Unable to create the influence connections" );
}
// use influencePoseData as bindPreMatrix
for ( unsigned i=0; i < numInfluences; i++ )
{
if ( ignoreInfluence[i] )
{
continue;
}
MMatrix preMatrix = ( i < origNumInfluences ) ? IECore::convert<MMatrix>( influencePoseData[i] ) : ignoredPreMatrices[i-origNumInfluences];
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( indexMap[i], &s );
s = preMatrixPlug.getValue( mObj );
if ( s )
{
MFnMatrixData matFn( mObj );
matFn.set( preMatrix );
mObj = matFn.object();
}
else
{
MFnMatrixData matFn;
mObj = matFn.create( preMatrix );
}
preMatrixPlug.setValue( mObj );
}
// remove unneeded bindPreMatrix children
unsigned existingElements = bindPreMatrixArrayPlug.numElements();
for ( unsigned i=influenceList.length(); i < existingElements; i++ )
{
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( i, &s );
/// \todo: surely there is a way to accomplish this in c++...
MGlobal::executeCommand( ( boost::format( "removeMultiInstance %s" ) % preMatrixPlug.name() ).str().c_str() );
}
// get the geometry
MObjectArray outputGeoObjs;
if ( !fnSkinCluster.getOutputGeometry( outputGeoObjs ) )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: skinCluster \"%s\" does not have any output geometry!" ) % fnSkinCluster.name() ).str() );
}
MFnDagNode dagFn( outputGeoObjs[0] );
MDagPath geoPath;
dagFn.getPath( geoPath );
// loop through all the points of the geometry and set the weights
MItGeometry geoIt( outputGeoObjs[0] );
MPlug weightListArrayPlug = fnSkinClusterNode.findPlug( "weightList", true, &s );
for ( unsigned pIndex=0; !geoIt.isDone(); geoIt.next(), pIndex++ )
{
MPlug pointWeightsPlug = weightListArrayPlug.elementByLogicalIndex( pIndex, &s ).child( 0 );
// remove existing influence weight plugs
MIntArray existingInfluenceIndices;
pointWeightsPlug.getExistingArrayAttributeIndices( existingInfluenceIndices );
for( unsigned i=0; i < existingInfluenceIndices.length(); i++ )
{
MPlug influenceWeightPlug = pointWeightsPlug.elementByLogicalIndex( existingInfluenceIndices[i], &s );
MGlobal::executeCommand( ( boost::format( "removeMultiInstance -break 1 %s" ) % influenceWeightPlug.name() ).str().c_str() );
}
// add new influence weight plugs
int firstIndex = pointIndexOffsets[pIndex];
for( int i=0; i < pointInfluenceCounts[pIndex]; i++ )
{
int influenceIndex = pointInfluenceIndices[ firstIndex + i ];
if ( ignoreInfluence[ influenceIndex ] )
{
continue;
}
int skinClusterInfluenceIndex = fnSkinCluster.indexForInfluenceObject( influencePaths[ indexMap[ influenceIndex ] ] );
MPlug influenceWeightPlug = pointWeightsPlug.elementByLogicalIndex( skinClusterInfluenceIndex, &s );
influenceWeightPlug.setValue( pointInfluenceWeights[ firstIndex + i ] );
}
}
return true;
}
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;
}
MStatus convertVerticesToContainedEdgesCommand::redoIt()
{
MSelectionList finalEdgesSelection;
MDagPath meshDagPath;
MObject multiVertexComponent, singleVertexComponent;
int dummyIndex;
// ITERATE THROUGH EACH "VERTEX COMPONENT" THAT IS CURRENTLY SELECTED:
for (MItSelectionList vertexComponentIter(previousSelectionList, MFn::kMeshVertComponent); !vertexComponentIter.isDone(); vertexComponentIter.next())
{
// STORE THE DAGPATH, COMPONENT OBJECT AND MESH NAME OF THE CURRENT VERTEX COMPONENT:
vertexComponentIter.getDagPath(meshDagPath, multiVertexComponent);
MString meshName = meshDagPath.fullPathName();
// VERTEX COMPONENT HAS TO CONTAIN AT LEAST ONE VERTEX:
if (!multiVertexComponent.isNull())
{
// ITERATE THROUGH EACH "VERTEX" IN THE CURRENT VERTEX COMPONENT:
for (MItMeshVertex vertexIter(meshDagPath, multiVertexComponent); !vertexIter.isDone(); vertexIter.next())
{
// FOR STORING THE EDGES CONNECTED TO EACH VERTEX:
MIntArray connectedEdgesIndices;
vertexIter.getConnectedEdges(connectedEdgesIndices);
// ITERATE THROUGH EACH EDGE CONNECTED TO THE CURRENT VERTEX:
MItMeshEdge edgeIter(meshDagPath);
for (unsigned i=0; i<connectedEdgesIndices.length(); i++)
{
// FIND AND STORE THE *FIRST* "END VERTEX" OF THE CURRENT EDGE:
edgeIter.setIndex(connectedEdgesIndices[i], dummyIndex);
MSelectionList singleVertexList;
MString vertexName = meshName;
vertexName += ".vtx[";
vertexName += edgeIter.index(0);
vertexName += "]";
singleVertexList.add(vertexName);
singleVertexList.getDagPath(0, meshDagPath, singleVertexComponent);
// SEE WHETHER THE VERTEX BELONGS TO THE ORIGINAL SELECTION, AND IF IT DOES PROCEED TO CHECK NEXT END VERTEX:
if (!singleVertexComponent.isNull() && previousSelectionList.hasItem(meshDagPath, singleVertexComponent))
{
// FIND AND STORE THE *SECOND* "END VERTEX" OF THE CURRENT EDGE:
singleVertexList.clear();
vertexName = meshName;
vertexName += ".vtx[";
vertexName += edgeIter.index(1);
vertexName += "]";
singleVertexList.add(vertexName);
singleVertexList.getDagPath(0, meshDagPath, singleVertexComponent);
// SEE WHETHER THE VERTEX BELONGS TO THE ORIGINAL SELECTION, AND IF IT DOES, ADD THE EDGE TO THE FINAL CONTAINED EDGES LIST:
if (!singleVertexComponent.isNull() && previousSelectionList.hasItem(meshDagPath, singleVertexComponent))
{
MString edgeName = meshName;
edgeName += ".e[";
edgeName += connectedEdgesIndices[i];
edgeName += "]";
finalEdgesSelection.add(edgeName);
}
}
}
}
}
}
// FINALLY, MAKE THE NEW "CONTAINED EDGES", THE CURRENT SELECTION:
MGlobal::setActiveSelectionList(finalEdgesSelection, MGlobal::kReplaceList);
// RETURN NEW CONTAINED EDGES LIST FROM THE MEL COMMAND, AS AN ARRAY OF STRINGS:
MStringArray containedEdgesArray;
finalEdgesSelection.getSelectionStrings(containedEdgesArray);
MPxCommand::setResult(containedEdgesArray);
return MS::kSuccess;
}