//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
MStatus CVstSelectCoincidentFacesCmd::DoSelect()
{
MSelectionList meshList;
GetSpecifiedMeshes( meshList );
MSelectionList coincidentList;
MDagPath mDagPath;
MObject cObj;
MPointArray points;
MIntArray iIndexes;
MIntArray jIndexes;
uint iCount;
bool addI;
bool same;
bool foundVertex;
double tolerance( MPoint_kTol );
if ( m_undo.ArgDatabase().isFlagSet( kOptTolerance ) )
{
MDistance optTolerance;
m_undo.ArgDatabase().getFlagArgument( kOptTolerance, 0U, optTolerance );
tolerance = optTolerance.as( MDistance::internalUnit() );
}
for ( MItSelectionList sIt( meshList ); !sIt.isDone(); sIt.next() )
{
if ( !sIt.getDagPath( mDagPath, cObj ) )
continue;
MFnSingleIndexedComponent sFn;
MObject sObj( sFn.create( MFn::kMeshPolygonComponent ) );
MFnMesh meshFn( mDagPath );
meshFn.getPoints( points );
if ( !sIt.hasComponents() )
{
const uint nFaces( meshFn.numPolygons() );
for ( uint i( 0U ); i != nFaces; ++i )
{
meshFn.getPolygonVertices( i, iIndexes );
iCount = iIndexes.length();
addI = false;
for ( uint j( i + 1 ); j < nFaces; ++j )
{
meshFn.getPolygonVertices( j, jIndexes );
if ( jIndexes.length() == iCount )
{
same = true;
for ( uint k( 0U ); k != iCount; ++k )
{
foundVertex = false;
const MPoint &kPoint( points[ iIndexes[ k ] ] );
for ( uint l( 0U ); l < iCount; ++l )
{
if ( kPoint.isEquivalent( points[ jIndexes[ l ] ], tolerance ) )
{
foundVertex = true;
break;
}
}
if ( !foundVertex )
{
same = false;
break;
}
}
if ( same )
{
addI = true;
sFn.addElement( j );
}
}
}
if ( addI )
{
sFn.addElement( i );
}
}
}
else
{
MFnSingleIndexedComponent cFn( cObj );
MIntArray cA;
MFnSingleIndexedComponent( cObj ).getElements( cA );
const uint nFaces( cA.length() );
for ( uint i( 0U ); i != nFaces; ++i )
{
meshFn.getPolygonVertices( cA[ i ], iIndexes );
iCount = iIndexes.length();
addI = false;
for ( uint j( i + 1U ); j < nFaces; ++j )
{
meshFn.getPolygonVertices( cA[ j ], jIndexes );
if ( jIndexes.length() == iCount )
{
same = true;
for ( uint k( 0U ); k != iCount; ++k )
{
foundVertex = false;
const MPoint &kPoint( points[ iIndexes[ k ] ] );
for ( uint l( 0U ); l < iCount; ++l )
{
if ( kPoint.isEquivalent( points[ jIndexes[ l ] ], tolerance ) )
{
foundVertex = true;
break;
}
}
if ( !foundVertex )
{
same = false;
break;
}
}
if ( same )
{
addI = true;
sFn.addElement( cA[ j ] );
}
}
}
if ( addI )
{
sFn.addElement( cA[ i ] );
}
}
}
if ( sFn.elementCount() > 0 )
{
coincidentList.add( mDagPath, sObj );
}
else
{
MSelectionList tmpList;
tmpList.add( mDagPath, cObj );
MStringArray tmpA;
tmpList.getSelectionStrings( tmpA );
minfo << "No coincident faces on:";
for ( uint i( 0U ); i != tmpA.length(); ++i )
{
minfo << " " << tmpA[ i ];
}
minfo << std::endl;
}
}
if ( coincidentList.length() )
{
MGlobal::setActiveSelectionList( coincidentList );
MStringArray tmpA;
coincidentList.getSelectionStrings( tmpA );
setResult( tmpA );
}
else
{
if ( meshList.length() > 0U )
{
minfo << "No coincident faces found" << std::endl;
}
}
return MS::kSuccess;
}
//---------------------------------------------------------------
void DocumentExporter::exportAsset()
{
COLLADASW::Asset asset(&mStreamWriter);
// Add contributor information
// Set the author
char* userName = getenv ( USERNAME );
if ( !userName || *userName == 0 )
{
userName = getenv ( USER );
}
if ( userName && *userName != 0 )
{
asset.getContributor().mAuthor = NativeString( userName ).toUtf8String();
}
// Source is the scene we have exported from
String currentScene = MFileIO::currentFile().asChar();
if ( currentScene.size() > 0 )
{
COLLADASW::URI sourceFileUri ( COLLADASW::URI::nativePathToUri ( currentScene ) );
if ( sourceFileUri.getScheme ().empty () )
sourceFileUri.setScheme ( COLLADASW::URI::SCHEME_FILE );
asset.getContributor().mSourceData = sourceFileUri.getURIString();
}
std::size_t foundLast = COLLADABU::CURRENT_REVISION.find_last_of(".");
std::size_t foundFirst = COLLADABU::CURRENT_REVISION.find_first_of(".");
String versionMajor = COLLADABU::CURRENT_REVISION.substr(0, foundFirst);
String versionMinor = COLLADABU::CURRENT_REVISION.substr(foundFirst + 1, foundLast - foundFirst -1 );
asset.getContributor().mAuthoringTool = AUTHORING_TOOL_NAME + MGlobal::mayaVersion().asChar() +
(COLLADABU::CURRENT_REVISION.empty() ? "" : String("; ") + String("Version: ") + versionMajor + "." + versionMinor) +
(COLLADABU::CURRENT_REVISION.empty() ? "" : String("; ") + String("Revision: ") + COLLADABU::CURRENT_REVISION.substr(foundLast + 1));
// comments
MString optstr = MString("\n\t\t\tColladaMaya export options: ")
+ "\n\t\t\tbakeTransforms=" + ExportOptions::bakeTransforms()
+ ";relativePaths=" + ExportOptions::relativePaths()
+ ";preserveSourceTree=" + ExportOptions::preserveSourceTree()
+ ";copyTextures=" + ExportOptions::copyTextures()
+ ";exportTriangles=" + ExportOptions::exportTriangles()
+ ";exportCgfxFileReferences=" + ExportOptions::exportCgfxFileReferences()
+ ";\n\t\t\tisSampling=" + ExportOptions::isSampling()
+ ";curveConstrainSampling=" + ExportOptions::curveConstrainSampling()
+ ";removeStaticCurves=" + ExportOptions::removeStaticCurves()
+ ";exportPhysics=" + ExportOptions::exportPhysics()
+ ";exportConvexMeshGeometries=" + ExportOptions::exportConvexMeshGeometries()
+ ";exportPolygonMeshes=" + ExportOptions::exportPolygonMeshes()
+ ";exportLights=" + ExportOptions::exportLights()
+ ";\n\t\t\texportCameras=" + ExportOptions::exportCameras()
+ ";exportAnimationsOnly=" + ExportOptions::exportAnimationsOnly()
+ ";exportSeparateFile=" + ExportOptions::exportSeparateFile()
+ ";modelNameDAE=" + ExportOptions::getDAEmodelName()
+ ";exportJoints=" + ExportOptions::exportJoints()
+ ";exportSkin=" + ExportOptions::exportSkin()
+ ";exportAnimations=" + ExportOptions::exportAnimations()
+ ";exportOptimizedBezierAnimation=" + ExportOptions::exportOptimizedBezierAnimations()
+ ";exportInvisibleNodes=" + ExportOptions::exportInvisibleNodes()
+ ";exportDefaultCameras=" + ExportOptions::exportDefaultCameras()
+ ";\n\t\t\texportTexCoords=" + ExportOptions::exportTexCoords()
+ ";exportNormals=" + ExportOptions::exportNormals()
+ ";exportNormalsPerVertex=" + ExportOptions::exportNormalsPerVertex()
+ ";exportVertexColors=" + ExportOptions::exportVertexColors()
+ ";exportVertexColorsPerVertex=" + ExportOptions::exportVertexColorsPerVertex()
+ ";\n\t\t\texportTexTangents=" + ExportOptions::exportTexTangents()
+ ";exportTangents=" + ExportOptions::exportTangents()
+ ";exportReferencedMaterials=" + ExportOptions::exportReferencedMaterials()
+ ";exportMaterialsOnly=" + ExportOptions::exportMaterialsOnly()
+ ";\n\t\t\texportXRefs=" + ExportOptions::exportXRefs()
+ ";dereferenceXRefs=" + ExportOptions::dereferenceXRefs()
+ ";exportCameraAsLookat=" + ExportOptions::exportCameraAsLookat()
+ ";cameraXFov=" + ExportOptions::cameraXFov()
+ ";cameraYFov=" + ExportOptions::cameraYFov()
+ ";doublePrecision=" + ExportOptions::doublePrecision () + "\n\t\t";
asset.getContributor().mComments = optstr.asChar();
// Up axis
if ( MGlobal::isYAxisUp() )
asset.setUpAxisType ( COLLADASW::Asset::Y_UP );
else if ( MGlobal::isZAxisUp() )
asset.setUpAxisType ( COLLADASW::Asset::Z_UP );
// Retrieve the linear unit name
MString mayaLinearUnitName;
MGlobal::executeCommand ( "currentUnit -q -linear -fullName;", mayaLinearUnitName );
String linearUnitName = mayaLinearUnitName.asChar();
// Get the UI unit type (internal units are centimeter, collada want
// a number relative to meters).
// All transform components with units will be in maya's internal units
// (radians for rotations and centimeters for translations).
MDistance testDistance ( 1.0f, MDistance::uiUnit() );
// Get the conversion factor relative to meters for the collada document.
// For example, 1.0 for the name "meter"; 1000 for the name "kilometer";
// 0.3048 for the name "foot".
double colladaConversionFactor = ( float ) testDistance.as ( MDistance::kMeters );
float colladaUnitFactor = float ( 1.0 / colladaConversionFactor );
asset.setUnit ( linearUnitName, colladaConversionFactor );
// Asset heraus schreiben
asset.add();
}