//------------------------------------------------------ void MaterialExporter::exportMaterialsByShaderPlug() { // Get all shaders, which are in the default shader list. MObject defaultShaderList = DagHelper::getNode ( ATTR_DEFAULT_SHADER_LIST1 ); MPlug defaultShadersPlug = MFnDependencyNode ( defaultShaderList ).findPlug ( ATTR_SHADERS ); uint shaderCount = defaultShadersPlug.evaluateNumElements(); for ( uint i = 0; i < shaderCount; ++i ) { MObject shader = DagHelper::getNodeConnectedTo ( defaultShadersPlug.elementByPhysicalIndex ( i ) ); MFnDependencyNode shadingEngineFn ( shader ); // Get the name of the current material (this is the maya material id) String mayaMaterialId = DocumentExporter::mayaNameToColladaName ( shadingEngineFn.name(), true ); bool doExportMaterial = true; bool isFromReferencedFile = shadingEngineFn.isFromReferencedFile(); // bool isDefaulNode = shadingEngineFn.isDefaultNode(); // if ( isDefaulNode ) // { // doExportMaterial = false; // } // else if ( isFromReferencedFile ) if ( isFromReferencedFile ) { if ( ExportOptions::exportXRefs() && ExportOptions::dereferenceXRefs() ) doExportMaterial = true; else doExportMaterial = false; } if ( doExportMaterial ) { MObject shadingEngine = ShaderHelper::getShadingEngine ( shader ); exportMaterial ( shadingEngine ); } } }
MStatus findTexturesPerPolygon::doIt( const MArgList& ) // // Description: // Find the texture files that apply to the color of each polygon of // a selected shape if the shape has its polygons organized into sets. // { // Get the selection and choose the first path on the selection list. // MStatus status; MDagPath path; MObject cmp; MSelectionList slist; MGlobal::getActiveSelectionList(slist); slist.getDagPath(0, path, cmp); // Have to make the path include the shape below it so that // we can determine if the underlying shape node is instanced. // By default, dag paths only include transform nodes. // path.extendToShape(); // If the shape is instanced then we need to determine which // instance this path refers to. // int instanceNum = 0; if (path.isInstanced()) instanceNum = path.instanceNumber(); // Get a list of all sets pertaining to the selected shape and the // members of those sets. // MFnMesh fnMesh(path); MObjectArray sets; MObjectArray comps; if (!fnMesh.getConnectedSetsAndMembers(instanceNum, sets, comps, true)) cerr << "ERROR: MFnMesh::getConnectedSetsAndMembers\n"; // Loop through all the sets. If the set is a polygonal set, find the // shader attached to the and print out the texture file name for the // set along with the polygons in the set. // for ( unsigned i=0; i<sets.length(); i++ ) { MObject set = sets[i]; MObject comp = comps[i]; MFnSet fnSet( set, &status ); if (status == MS::kFailure) { cerr << "ERROR: MFnSet::MFnSet\n"; continue; } // Make sure the set is a polygonal set. If not, continue. MItMeshPolygon piter(path, comp, &status); if ((status == MS::kFailure) || comp.isNull()) continue; // Find the texture that is applied to this set. First, get the // shading node connected to the set. Then, if there is an input // attribute called "color", search upstream from it for a texture // file node. // MObject shaderNode = findShader(set); if (shaderNode == MObject::kNullObj) continue; MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status); if (status == MS::kFailure) continue; MItDependencyGraph dgIt(colorPlug, MFn::kFileTexture, MItDependencyGraph::kUpstream, MItDependencyGraph::kBreadthFirst, MItDependencyGraph::kNodeLevel, &status); if (status == MS::kFailure) continue; dgIt.disablePruningOnFilter(); // If no texture file node was found, just continue. // if (dgIt.isDone()) continue; // Print out the texture node name and texture file that it references. // MObject textureNode = dgIt.thisNode(); MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName"); MString textureName; filenamePlug.getValue(textureName); cerr << "Set: " << fnSet.name() << endl; cerr << "Texture Node Name: " << MFnDependencyNode(textureNode).name() << endl; cerr << "Texture File Name: " << textureName.asChar() << endl; // Print out the set of polygons that are contained in the current set. // for ( ; !piter.isDone(); piter.next() ) cerr << " poly component: " << piter.index() << endl; } return MS::kSuccess; }
// -------------------------------------- void ReferenceManager::processReference ( const MObject& referenceNode ) { MStatus status; MFnDependencyNode referenceNodeFn ( referenceNode, &status ); if (status != MStatus::kSuccess) return; #if MAYA_API_VERSION >= 600 MString referenceNodeName = MFnDependencyNode( referenceNode ).name(); Reference* reference = new Reference(); reference->referenceNode = referenceNode; mReferences.push_back ( reference ); // Get the paths of the root transforms included in this reference MObjectArray subReferences; getRootObjects ( referenceNode, reference->paths, subReferences ); uint pathCount = reference->paths.length(); // Process the sub-references first uint subReferenceCount = subReferences.length(); for (uint i = 0; i < subReferenceCount; ++i) { MObject& subReference = subReferences[i]; if ( subReference != MObject::kNullObj ) processReference ( subReference ); } // Retrieve the reference node's filename MString command = MString("reference -rfn \"") + referenceNodeFn.name() + MString("\" -q -filename;"); MString filename; status = MGlobal::executeCommand ( command, filename ); if (status != MStatus::kSuccess || filename.length() == 0) return; // Strip the filename of the multiple file token int stripIndex = filename.index('{'); if (stripIndex != -1) filename = filename.substring(0, stripIndex - 1); // Avoid transform look-ups on COLLADA references. int extLocation = filename.rindex('.'); if (extLocation > 0) { MString ext = filename.substring(extLocation + 1, filename.length() - 1).toLowerCase(); if (ext == "dae" || ext == "xml") return; } // Check for already existing file information // Otherwise create a new file information sheet with current node names for ( ReferenceFileList::iterator it = mFiles.begin(); it != mFiles.end(); ++it ) { if ((*it)->filename == filename) { reference->file = (*it); break; } } if ( reference->file == NULL ) reference->file = processReferenceFile(filename); // Get the list of the root transform's first child's unreferenced parents. // This is a list of the imported nodes! for (uint j = 0; j < pathCount; ++j) { MDagPath path = reference->paths[j]; if (path.childCount() > 0) { path.push ( path.child(0) ); MFnDagNode childNode ( path ); if (!childNode.object().hasFn(MFn::kTransform)) continue; uint parentCount = childNode.parentCount(); for (uint k = 0; k < parentCount; ++k) { MFnDagNode parentNode(childNode.parent(k)); if (parentNode.object() == MObject::kNullObj || parentNode.isFromReferencedFile()) continue; MDagPath parentPath = MDagPath::getAPathTo(parentNode.object()); if (parentPath.length() > 0) { ReferenceRootList::iterator it = reference->reroots.insert( reference->reroots.end(), ReferenceRoot() ); (*it).index = j; (*it).reroot = parentPath; } } } } #endif }
MStatus ReferenceManager::getReferenceFilename(const MObject & referenceNode, MString & referenceFilename) { MString command = MString("referenceQuery -filename ") + MFnDependencyNode(referenceNode).name(); return MGlobal::executeCommand(command, referenceFilename); }
//----------------------------------------------------------------------------- // Creates a vstAttachment Locator //----------------------------------------------------------------------------- MStatus CVstAttachmentCmd::DoCreate() { MDagModifier *mDagModifier( new MDagModifier ); if ( !mDagModifier ) { merr << "Can't create new MDagModifier" << std::endl; return MS::kFailure; } MString optName( "vstAttachment" ); if ( m_mArgDatabase->isFlagSet( kOptName ) ) { m_mArgDatabase->getFlagArgument( kOptName, 0, optName ); } // Create the helper bone locator's transform MObject xObj = mDagModifier->createNode( "transform" ); mDagModifier->doIt(); if ( xObj.isNull() ) { merr << "Can't create new transform node" << std::endl; return MS::kFailure; } // name the shape & the transform the same thing mDagModifier->renameNode( xObj, optName ); mDagModifier->doIt(); MObject vstAttachmentObj = mDagModifier->createNode( "vstAttachment", xObj ); if ( vstAttachmentObj.isNull() ) { merr << "Can't create new vstAttachment node" << std::endl; mDagModifier->undoIt(); return MS::kFailure; } // name the shape & the transform the same thing mDagModifier->renameNode( vstAttachmentObj, MFnDependencyNode( xObj ).name() ); mDagModifier->doIt(); m_undoable = true; m_mDagModifier = mDagModifier; if ( m_mArgDatabase->isFlagSet( kOptParent ) ) { MSelectionList mSelectionList; m_mArgDatabase->getObjects( mSelectionList ); for ( MItSelectionList sIt( mSelectionList, MFn::kDagNode ); !sIt.isDone(); sIt.next() ) { MDagPath mDagPath; if ( sIt.getDagPath( mDagPath ) ) { m_mDagModifier->reparentNode( xObj, mDagPath.node() ); m_mDagModifier->doIt(); break; } } } // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MDagPath xDagPath; MDagPath::getAPathTo( xObj, xDagPath ); MGlobal::select( xDagPath, MObject::kNullObj, MGlobal::kReplaceList ); setResult( xDagPath.partialPathName() ); return MS::kSuccess; }
MStatus FileTranslator::writer ( const MFileObject& file, const MString& options, MPxFileTranslator::FileAccessMode mode ) { MStatus status = MStatus::kFailure; try { // Save current selection MSelectionList selection; MGlobal::getActiveSelectionList(selection); // Extract the filename #if defined (OSMac_) char nameBuffer[MAXPATHLEN]; strcpy ( nameBuffer, file.fullName().asChar() ); const MString fileName ( nameBuffer ); #else const MString fileName = file.fullName(); #endif // OSMac // TODO Export the referenced files! // Maya forces the write of all the references, on export. // Intentionally skip known reference file paths. for ( MItDependencyNodes it ( MFn::kReference ); !it.isDone(); it.next() ) { MObject refNode = it.item(); MString refNodeName = MFnDependencyNode ( refNode ).name(); MString refNodeFilename; MGlobal::executeCommand ( MString ( "reference -rfn \"" ) + refNodeName + MString ( "\" -q -filename" ), refNodeFilename ); if ( refNodeFilename == fileName ) return MStatus::kSuccess; if ( ExportOptions::exportXRefs() ) { // TODO Open file export dialog ( !? HOW ?! ) to get a DAE filename // to export the referenced file. } } // Parse the export options ExportOptions::set ( options ); // Check, if we should just export the selected Objects exportSelection = mode == MPxFileTranslator::kExportActiveAccessMode; // Do the actual export now status = exportIntoFile ( fileName, exportSelection ); // Restore selection MGlobal::setActiveSelectionList(selection); } catch ( COLLADASW::StreamWriterException* swException ) { String message = "StreamWriterException: " + swException->getMessage(); MGlobal::displayWarning ( message.c_str() ); } catch ( ... ) { MGlobal::displayWarning ( "ColladaMaya has thrown an exception!" ); } return status; }
//----------------------------------------------------------------------------- // Figures out the material path name from the maya shading group //----------------------------------------------------------------------------- MString ValveMaya::GetMaterialPath( const MObject &shadingGroupObj, MObject *pFileObj, MObject *pPlace2dTextureObj, MObject *pVmtObj, bool *pbTransparent, MString *pDebugWhy ) { MString materialPath( "debug/debugEmpty" ); const MObject surfaceShaderObj( FindInputNode( shadingGroupObj, "surfaceShader" ) ); if ( surfaceShaderObj.isNull() ) { if ( pDebugWhy ) { *pDebugWhy = MString( "Can't find surfaceShader node from shadingGroup: No input to " ) + MFnDependencyNode( shadingGroupObj ).name() + ".surfaceShader"; } return materialPath; } if ( MFnDependencyNode( surfaceShaderObj ).typeName() == "vsVmt" ) { MPlug vmtP = MFnDependencyNode( surfaceShaderObj ).findPlug( "vmtPath" ); if ( !vmtP.isNull() ) { vmtP.getValue( materialPath ); return materialPath; } } const MObject fileObj( FindInputNodeOfType( surfaceShaderObj, "file", "color" ) ); if ( fileObj.isNull() ) { if ( pDebugWhy ) { *pDebugWhy = MString( "Can't find file texture node from surfaceShader: No input to " ) + MFnDependencyNode( surfaceShaderObj ).name() + ".color"; } return materialPath; } if ( pFileObj ) { *pFileObj = fileObj; } if ( pbTransparent ) { const MObject transObj( FindInputNodeOfType( surfaceShaderObj, "file", "transparency" ) ); if ( fileObj == transObj ) { *pbTransparent = true; } } if ( pPlace2dTextureObj ) { MObject place2dTextureObj( FindInputNodeOfType( fileObj, "place2dTexture", "uvCoord" ) ); if ( !place2dTextureObj.isNull() ) { const MPlug uvCoordP( MFnDependencyNode( place2dTextureObj ).findPlug( "uvCoord" ) ); if ( !( uvCoordP.isNull() || uvCoordP.isConnected() || uvCoordP.isLocked() ) ) { *pPlace2dTextureObj = place2dTextureObj; } } } // Check to see if a vsVmtToTex node is driving the filename const MObject vsVmtToTexObj = FindInputNodeOfType( fileObj, "vsVmtToTex" ); if ( !vsVmtToTexObj.isNull() ) { if ( pVmtObj ) { *pVmtObj = vsVmtToTexObj; } const MPlug materialPathP = MFnDependencyNode( vsVmtToTexObj ).findPlug( "materialPath" ); if ( !materialPathP.isNull() ) { materialPathP.getValue( materialPath ); if ( materialPath.length() ) { return materialPath; } } } // Otherwise do path munging to figure out MString fileTexture; int fLen( 0 ); const MFnDependencyNode fileFn( fileObj ); const MPlug fileP( fileFn.findPlug( "fileTextureName" ) ); fileP.getValue( fileTexture ); fLen = fileTexture.length(); if ( fLen == 0 ) { if ( pDebugWhy ) { *pDebugWhy = MString( "No texture filename specified on file texture node: " ) + MFnDependencyNode( fileObj ).name() + ".fileTextureName is empty"; } return materialPath; } MStringArray path; const uint pLen( SplitPath( StripExtension( fileTexture ), path ) ); if ( pLen == 0 ) return fileTexture.asChar(); materialPath = path[ pLen - 1 ]; // Make the path into a relative path for ( int i = pLen - 2; i >= 0; --i ) { if ( i > 1 && ( !stricmp( path[ i - 1 ].asChar(), "game" ) || !stricmp( path[ i - 1 ].asChar(), "content" ) ) ) break; if ( !stricmp( path[ i ].asChar(), "materials" ) || !stricmp( path[ i ].asChar(), "materialsrc" ) ) break; materialPath = path[ i ] + "/" + materialPath; } return materialPath; }
//----------------------------------------------------------------------------- // // Purpose: Create a Maya Dag node named properly // //----------------------------------------------------------------------------- MStatus ValveMaya::CreateDagNode( const char *const i_nodeType, const char *const i_transformName, const MObject &i_parentObj, MObject *o_pTransformObj, MObject *o_pShapeObj, MDagModifier *i_mDagModifier) { MStatus retVal; // If the user didn't supply an MDagModifier make a temporary one MDagModifier tmpDagModifier; MDagModifier &mDagModifier( i_mDagModifier ? *i_mDagModifier : tmpDagModifier ); // Try and create the node const MObject tObj( mDagModifier.createNode( i_nodeType, i_parentObj, &retVal ) ); if ( !retVal ) return retVal; mDagModifier.doIt(); // Failed... undo the Dag modifier and return failure if ( tObj.isNull() ) { mDagModifier.undoIt(); return MS::kFailure; } // If the caller wants a copy of the created Transform MObject save it if ( o_pTransformObj ) *o_pTransformObj = tObj; // The name the shape will be called MString sName; // Set the name of the transform, it's either the name of the node type or the called specified name if ( i_transformName ) { retVal = mDagModifier.renameNode( tObj, i_transformName ); sName = i_transformName; } else { retVal = mDagModifier.renameNode( tObj, i_nodeType ); sName = i_nodeType; } // If the rename failed, undo the dag modifier and quit if ( !retVal ) { mDagModifier.undoIt(); return retVal; } mDagModifier.doIt(); // Search for the shape node that was created, normally there will be only 1 shape but there are pathological // cases, some might not quite be handled here but most will be MDagPath tDagPath( MDagPath::getAPathTo( tObj ) ); unsigned sEnd( 0 ); tDagPath.numberOfShapesDirectlyBelow( sEnd ); for ( unsigned si( 0 ); si != sEnd; ++si ) { MDagPath sDagPath( tDagPath ); sDagPath.extendToShapeDirectlyBelow( si ); if ( MFnDagNode( sDagPath ).typeName() == i_nodeType ) { // Add the %d suffix so sscanf can be used to check if Maya added a numeric suffix to the transform name const MString tScanfName( sName + "%d" ); // Add the 'Shape' Suffix to the shape name sName += "Shape"; // Get the actual name Maya assigned the node so it can be scanned for a Maya added numeric suffix const MString tName( MFnDependencyNode( tObj ).name() ); int numericSuffix( 0 ); switch ( sscanf( tName.asChar(), tScanfName.asChar(), &numericSuffix ) ) { case 0: default: // There was no numeric suffix added by Maya, so nothing extra to add break; case 1: // Maya added a numeric suffix, add it to the shape name sName += numericSuffix; break; } // Rename the shape node so it now matches the transform, this operation can't really fail const MObject sObj( sDagPath.node() ); // If the caller wants a copy of the created Transform MObject save it if ( o_pShapeObj ) *o_pShapeObj = sObj; mDagModifier.renameNode( sObj, sName ); mDagModifier.doIt(); // Just do the first shape of the appropriate type found break; } } return retVal; }
MStatus ScbWriter::dumpData() { MStatus status; MDagPath dag_path; MDagPath mesh_dag_path; MFnSkinCluster fn_skin_cluster; MSelectionList selection_list; if (MStatus::kSuccess != MGlobal::getActiveSelectionList(selection_list)) FAILURE("ScbWriter: MGlobal::getActiveSelectionList()"); MItSelectionList it_selection_list(selection_list, MFn::kMesh, &status); if (status != MStatus::kSuccess) FAILURE("ScbWriter: it_selection_list()"); if (it_selection_list.isDone()) FAILURE("ScbWriter: no mesh selected!"); it_selection_list.getDagPath(mesh_dag_path); it_selection_list.next(); if (!it_selection_list.isDone()) FAILURE("ScbWriter: more than one mesh selected!"); MFnMesh mesh(mesh_dag_path); strcpy_s(data_.name, ScbData::kNameLen, mesh.name().asChar()); // get shaders int instance_num = 0; if (mesh_dag_path.isInstanced()) instance_num = mesh_dag_path.instanceNumber(); MObjectArray shaders; MIntArray shader_indices; mesh.getConnectedShaders(instance_num, shaders, shader_indices); int shader_count = shaders.length(); MGlobal::displayInfo(MString("shaders for this mesh : ") + shader_count); // check for holes MIntArray hole_info_array; MIntArray hole_vertex_array; mesh.getHoles(hole_info_array, hole_vertex_array); if (hole_info_array.length() != 0) FAILURE("ScbWriter: mesh contains holes"); // check for triangulation MItMeshPolygon mesh_polygon_iter(mesh_dag_path); for (mesh_polygon_iter.reset(); !mesh_polygon_iter.isDone(); mesh_polygon_iter.next()) { if (!mesh_polygon_iter.hasValidTriangulation()) FAILURE("ScbWriter: a poly has no valid triangulation"); } // get transform MFnTransform transform_node(mesh.parent(0)); MVector pos = transform_node.getTranslation(MSpace::kTransform); // get vertices int num_vertices = mesh.numVertices(); data_.num_vtxs = num_vertices; MFloatPointArray vertex_array; mesh.getPoints(vertex_array, MSpace::kWorld); // kObject is done by removing translation values // that way scales and rotations are kept. for (int i = 0; i < num_vertices; i++) { ScbVtx vtx; vtx.x = vertex_array[i].x - static_cast<float>(pos.x); vtx.y = vertex_array[i].y - static_cast<float>(pos.y); vtx.z = vertex_array[i].z - static_cast<float>(pos.z); // check for min if (vtx.x < data_.bbx || i == 0) data_.bbx = vtx.x; if (vtx.y < data_.bby || i == 0) data_.bby = vtx.y; if (vtx.z < data_.bbz || i == 0) data_.bbz = vtx.z; // check for max if (vtx.x > data_.bbdx || i == 0) data_.bbdx = vtx.x; if (vtx.y > data_.bbdy || i == 0) data_.bbdy = vtx.y; if (vtx.z > data_.bbdz || i == 0) data_.bbdz = vtx.z; data_.vertices.push_back(vtx); } // bbd is the size so : data_.bbdx -= data_.bbx; data_.bbdy -= data_.bby; data_.bbdz -= data_.bbz; // get UVs MFloatArray u_array; MFloatArray v_array; mesh.getUVs(u_array, v_array); MIntArray uv_counts; MIntArray uv_ids; mesh.getAssignedUVs(uv_counts, uv_ids); // get triangles MIntArray triangle_counts; MIntArray triangle_vertices; mesh.getTriangles(triangle_counts, triangle_vertices); int numPolys = mesh.numPolygons(); // fill data int cur = 0; for (int i = 0; i < numPolys; i++) { int triangle_count = triangle_counts[i]; int shader = shader_indices[i]; for (int j = 0; j < triangle_count; j++) data_.shader_per_triangle.push_back(shader); for (int j = 0; j < triangle_count * 3; j++) { data_.indices.push_back(triangle_vertices[cur]); data_.u_vec.push_back(u_array[uv_ids[cur]]); data_.v_vec.push_back(1 - v_array[uv_ids[cur]]); cur++; } } data_.num_indices = cur; // fill materials for (int i = 0; i < shader_count; i++) { ScbMaterial material; // get the plug for SurfaceShader MPlug shader_plug = MFnDependencyNode(shaders[i]).findPlug("surfaceShader"); // get the connections to this plug MPlugArray plug_array; shader_plug.connectedTo(plug_array, true, false, &status); // first connection is material. MFnDependencyNode surface_shader(plug_array[0].node()); strcpy_s(material.name, ScbMaterial::kNameLen, surface_shader.name().asChar()); data_.materials.push_back(material); } return MS::kSuccess; }
MStatus CVstAimCmd::redoIt() { MStatus mStatus; if ( !mStatus ) { setResult( MString( "Cannot parse command line" ) + mStatus.errorString() ); return MS::kFailure; } if ( m_mArgDatabase->isFlagSet( kHelp ) ) { PrintHelp(); } else { // See if there are two object specified MDagPath mDagPath; MSelectionList optSelectionList; // Validate specified items to whole dag nodes { MSelectionList tmpSelectionList; m_mArgDatabase->getObjects( tmpSelectionList ); for ( MItSelectionList sIt( tmpSelectionList, MFn::kDagNode ); !sIt.isDone(); sIt.next() ) { if ( sIt.getDagPath( mDagPath ) ) { optSelectionList.add( mDagPath, MObject::kNullObj, true ); } } } if ( m_mArgDatabase->isFlagSet( "create" ) || optSelectionList.length() >= 2 && m_mArgDatabase->numberOfFlagsUsed() == 0 ) { // Error if there aren't at least two if ( optSelectionList.length() < 2 ) { displayError( GetName() + " needs at least two objects specified or selected when -create is used" ); return MS::kFailure; } // Get name command line arg MString optName; if ( m_mArgDatabase->isFlagSet( "name" ) ) { m_mArgDatabase->getFlagArgument( "name", 0, optName ); } m_undoable = true; m_mDagModifier = new MDagModifier; MObject vstAimObj( m_mDagModifier->MDGModifier::createNode( GetName() ) ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { displayError( MString( "Couldn't create " ) + GetName() + " node" ); m_mDagModifier->undoIt(); delete m_mDagModifier; m_mDagModifier = NULL; m_undoable = false; return MS::kFailure; } m_mDagModifier->renameNode( vstAimObj, optName.length() ? optName : GetName() ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { if ( optName.length() ) { displayWarning( MString( "Couldn't rename newly created vstNode \"" ) + optName + "\"" ); } } // Set options on the newly create vstAim node MFnDependencyNode vstAimFn( vstAimObj ); MPlug sP; MPlug dP; if ( m_mArgDatabase->isFlagSet( kAim ) ) { MVector aim; m_mArgDatabase->getFlagArgument( kAim, 0, aim.x ); m_mArgDatabase->getFlagArgument( kAim, 1, aim.y ); m_mArgDatabase->getFlagArgument( kAim, 2, aim.z ); sP = vstAimFn.findPlug( "aimX" ); sP.setValue( aim.x ); sP = vstAimFn.findPlug( "aimY" ); sP.setValue( aim.y ); sP = vstAimFn.findPlug( "aimZ" ); sP.setValue( aim.z ); } if ( m_mArgDatabase->isFlagSet( kUp ) ) { MVector up; m_mArgDatabase->getFlagArgument( kUp, 0, up.x ); m_mArgDatabase->getFlagArgument( kUp, 1, up.y ); m_mArgDatabase->getFlagArgument( kUp, 2, up.z ); sP = vstAimFn.findPlug( "upX" ); sP.setValue( up.x ); sP = vstAimFn.findPlug( "upY" ); sP.setValue( up.y ); sP = vstAimFn.findPlug( "upZ" ); sP.setValue( up.z ); } // Now connect up the newly created vstAim node MDagPath toAim; optSelectionList.getDagPath( 1, toAim ); const MFnDagNode toAimFn( toAim ); if ( toAim.hasFn( MFn::kJoint ) ) { MPlug joP( toAimFn.findPlug( "jointOrient" ) ); if ( !joP.isNull() ) { MAngle jox, joy, joz; joP.child( 0 ).getValue( jox ); joP.child( 1 ).getValue( joy ); joP.child( 2 ).getValue( joz ); if ( abs( jox.value() ) > FLT_EPSILON || abs( joy.value() ) > FLT_EPSILON || abs( joz.value() ) > FLT_EPSILON ) { mwarn << "Joint orient on node being constrained is non-zero ( " << jox.asDegrees() << " " << joy.asDegrees() << " " << joz.asDegrees() << " ), setting to 0" << std::endl; joP.child( 0 ).setValue( MAngle( 0.0 ) ); joP.child( 1 ).setValue( MAngle( 0.0 ) ); joP.child( 2 ).setValue( MAngle( 0.0 ) ); } } } if ( toAim.hasFn( MFn::kTransform ) ) { MPlug mP( toAimFn.findPlug( "rotateAxis" ) ); if ( !mP.isNull() ) { MAngle rx, ry, rz; mP.child( 0 ).getValue( rx ); mP.child( 1 ).getValue( ry ); mP.child( 2 ).getValue( rz ); if ( abs( rx.value() ) > FLT_EPSILON || abs( ry.value() ) > FLT_EPSILON || abs( rz.value() ) > FLT_EPSILON ) { mwarn << "Rotate Axis on node being constrained is non-zero ( " << rx.asDegrees() << " " << ry.asDegrees() << " " << rz.asDegrees() << " ), setting to 0" << std::endl; mP.child( 0 ).setValue( MAngle( 0.0 ) ); mP.child( 1 ).setValue( MAngle( 0.0 ) ); mP.child( 2 ).setValue( MAngle( 0.0 ) ); } } } MDagPath aimAt; optSelectionList.getDagPath( 0, aimAt ); const MFnDagNode aimAtFn( aimAt ); // toAim.rotateOrder -> vstAim.rotateOrder sP = toAimFn.findPlug( "rotateOrder" ); dP = vstAimFn.findPlug( "rotateOrder" ); m_mDagModifier->connect( sP, dP ); // toAim.translate -> vstAim.translate sP = toAimFn.findPlug( "translate" ); dP = vstAimFn.findPlug( "translate" ); m_mDagModifier->connect( sP, dP ); // toAim.parentMatrix[ instance ] -> vstAim.parentSpace sP = toAimFn.findPlug( "parentMatrix" ); sP = sP.elementByLogicalIndex( toAim.instanceNumber() ); dP = vstAimFn.findPlug( "parentSpace" ); m_mDagModifier->connect( sP, dP ); // aimAt.worldMatrix[ instance ] -> vstAim.aimSpace sP = aimAtFn.findPlug( "worldMatrix" ); sP = sP.elementByLogicalIndex( aimAt.instanceNumber() ); dP = vstAimFn.findPlug( "aimSpace" ); m_mDagModifier->connect( sP, dP ); // vstAim.rotation -> toAim.rotation // These have to be connected individually because Maya plays stupid tricks // with rotateOrder if they aren't sP = vstAimFn.findPlug( "rotateX" ); dP = toAimFn.findPlug( "rotateX" ); m_mDagModifier->connect( sP, dP ); sP = vstAimFn.findPlug( "rotateY" ); dP = toAimFn.findPlug( "rotateY" ); m_mDagModifier->connect( sP, dP ); sP = vstAimFn.findPlug( "rotateZ" ); dP = toAimFn.findPlug( "rotateZ" ); m_mDagModifier->connect( sP, dP ); if ( m_mDagModifier->doIt() != MS::kSuccess ) { displayWarning( MString( GetName() ) + ": Couldn't connect everything when creating" ); } // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MGlobal::select( vstAimObj, MGlobal::kReplaceList ); setResult( vstAimFn.name() ); } else if ( m_mArgDatabase->isFlagSet( "select" ) ) { MSelectionList mSelectionList; MDagPath mDagPath; for ( MItDag dagIt; !dagIt.isDone(); dagIt.next() ) { if ( MFnDependencyNode( dagIt.item() ).typeName() == GetName() ) { dagIt.getPath( mDagPath ); mSelectionList.add( mDagPath, MObject::kNullObj, true ); } } if ( mSelectionList.length() ) { m_undoable = true; // Save the current selection just in case we want to undo stuff MGlobal::getActiveSelectionList( m_mSelectionList ); MGlobal::setActiveSelectionList( mSelectionList, MGlobal::kReplaceList ); } } else { displayError( GetName() + ": No valid operation specified via command line arguments\n" ); } } return MS::kSuccess; }
void PhongMat::Insert(std::ostream& fout) const { MStatus status; MObject object; /* for(int j = 0; j < shaderNode.attributeCount(); j++) { MPlug m = shaderNode.findPlug(shaderNode.attribute(j), false); std::cout << " " << shaderNode.attribute(j).apiTypeStr() << " " << " plug " << m.name() << std::endl; } std::cout << std::endl;*/ //MPlug reflectivityPlug = MFnDependencyNode(shaderNode).findPlug("reflectivity"); MPlug sigmaPlug = MFnDependencyNode(shaderNode).findPlug("cosinePower"); MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color"); status = colorPlug.getValue(object); if (status != MStatus::kSuccess) { MGlobal::displayWarning("Could not get color value out"); } MFnNumericData colorData(object, &status); if (status != MStatus::kSuccess) { MGlobal::displayWarning("Could not get color value out (2)"); } MPlug specularPlug = MFnDependencyNode(shaderNode).findPlug("specularColor"); status = specularPlug.getValue(object); if (status != MStatus::kSuccess) { MGlobal::displayWarning("Could not get specular color value out"); } MFnNumericData specularData(object, &status); if (status != MStatus::kSuccess) { MGlobal::displayWarning("Could not get specular color data"); } fout << "Material \"phongmat\" "; if (colorData.numericType() == MFnNumericData::k3Float) { float r,g,b; colorData.getData(r,g,b); fout << "\"color rhod\" [" << r << " " << g << " " << b << "] "; } else if (colorData.numericType() == MFnNumericData::k3Double) { double r,g,b; colorData.getData(r,g,b); fout << "\"color rhod\" [" << r << " " << g << " " << b << "] "; } else { MGlobal::displayWarning("Invalid data type"); } if (specularData.numericType() == MFnNumericData::k3Float) { float r,g,b; specularData.getData(r,g,b); fout << "\"color rhos\" [" << r << " " << g << " " << b << "] "; } else if (specularData.numericType() == MFnNumericData::k3Double) { double r,g,b; specularData.getData(r,g,b); fout << "\"color rhos\" [" << r << " " << g << " " << b << "] "; } else { MGlobal::displayWarning("Invalid data type"); } float sigma; status = sigmaPlug.getValue(sigma); if (status == MStatus::kSuccess) fout << "\"float sigma\" [" << sigma << "] "; // sigma = cosine_power fout << std::endl; }
// Load a joint void skeleton::loadJoint(MDagPath& jointDag,joint* parent) { int i; joint newJoint; joint* parentJoint = parent; if (jointDag.hasFn(MFn::kJoint)) { MFnIkJoint jointFn(jointDag); // Get parent index int idx=-1; if (parent) { idx = parent->id; } // Get joint matrix MMatrix worldMatrix = jointDag.inclusiveMatrix(); /*float translation1[3]; float rotation1[4]; float scale1[3]; extractTranMatrix(worldMatrix,translation1,rotation1,scale1); Quaternion q(rotation1[0],rotation1[1],rotation1[2],rotation1[3]); float angle; Vector3 axis; q.ToAngleAxis(angle,axis); Vector3 x,y,z; q.ToAxes(x,y,z);*/ //printMatrix(worldMatrix); // Calculate scaling factor inherited by parent // Calculate Local Matrix MMatrix localMatrix = worldMatrix; if (parent) localMatrix = worldMatrix * parent->worldMatrix.inverse(); float translation2[3]; float rotation2[4]; float scale2[3]; extractTranMatrix(worldMatrix,translation2,rotation2,scale2); //printMatrix(localMatrix); // Set joint info newJoint.name = jointFn.partialPathName(); newJoint.id = m_joints.size(); newJoint.parentIndex = idx; newJoint.jointDag = jointDag; newJoint.worldMatrix = worldMatrix; newJoint.localMatrix = localMatrix; for (int iRow = 0; iRow < 4; iRow++) for (int iCol = 0; iCol < 3; iCol++) newJoint.tran.m_mat[iRow][iCol] = (FLOAT)worldMatrix[iRow][iCol]; //printMatrix(worldMatrix); /*MQuaternion q; q = worldMatrix; newJoint.tran.q[0] = (float)q.x; newJoint.tran.q[1] = (float)q.y; newJoint.tran.q[2] = (float)q.z; newJoint.tran.q[3] = (float)q.w; newJoint.tran.t[0] = (float)worldMatrix[3][0]; newJoint.tran.t[1] = (float)worldMatrix[3][1]; newJoint.tran.t[2] = (float)worldMatrix[3][2];*/ MPlug plug = jointFn.findPlug("unRibbonEnabled"); if(!plug.isNull()) { bool enabled; plug.getValue(enabled); if(enabled) { plug = jointFn.findPlug("unRibbonVisible"); bool visible; plug.getValue(visible); plug = jointFn.findPlug("unRibbonAbove"); float above; plug.getValue(above); plug = jointFn.findPlug("unRibbonBelow"); float below; plug.getValue(below); plug = jointFn.findPlug("unRibbonEdgesPerSecond"); short edgePerSecond; plug.getValue(edgePerSecond); plug = jointFn.findPlug("unRibbonEdgeLife"); float edgeLife; plug.getValue(edgeLife); plug = jointFn.findPlug("unRibbonGravity"); float gravity; plug.getValue(gravity); plug = jointFn.findPlug("unRibbonTextureRows"); short rows; plug.getValue(rows); plug = jointFn.findPlug("unRibbonTextureCols"); short cols; plug.getValue(cols); plug = jointFn.findPlug("unRibbonTextureSlot"); short slot; plug.getValue(slot); plug = jointFn.findPlug("unRibbonVertexColor"); MObject object; plug.getValue(object); MFnNumericData data(object); float r,g,b; data.getData(r,g,b); plug = jointFn.findPlug("unRibbonVertexAlpha"); float alpha; plug.getValue(alpha); plug = jointFn.findPlug("unRibbonBlendMode"); short blendMode; plug.getValue(blendMode); plug = jointFn.findPlug("unRibbonTextureFilename"); MItDependencyGraph dgIt(plug, MFn::kFileTexture, MItDependencyGraph::kUpstream, MItDependencyGraph::kBreadthFirst, MItDependencyGraph::kNodeLevel); dgIt.disablePruningOnFilter(); MString textureName; if (!dgIt.isDone()) { MObject textureNode = dgIt.thisNode(); MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName"); filenamePlug.getValue(textureName); } else { char str[256]; sprintf(str,"%s ribbon system must has file-texture",newJoint.name.asChar()); MessageBox(0,str,0,0); } newJoint.hasRibbonSystem = true; newJoint.ribbon.visible = visible; newJoint.ribbon.above = above; newJoint.ribbon.below = below; newJoint.ribbon.gravity = gravity; newJoint.ribbon.edgePerSecond = edgePerSecond; newJoint.ribbon.edgeLife = edgeLife; newJoint.ribbon.rows = rows; newJoint.ribbon.cols = cols; newJoint.ribbon.slot = slot; newJoint.ribbon.color[0] = r; newJoint.ribbon.color[1] = g; newJoint.ribbon.color[2] = b; newJoint.ribbon.alpha = alpha; newJoint.ribbon.blendMode = blendMode; newJoint.ribbon.textureFilename = textureName.asChar(); } } plug = jointFn.findPlug("unParticleEnabled"); if(!plug.isNull()) { bool enabled; plug.getValue(enabled); if(enabled) { newJoint.hasParticleSystem = true; plug = jointFn.findPlug("unParticleVisible"); bool visible; plug.getValue(visible); plug = jointFn.findPlug("unParticleSpeed"); float speed; plug.getValue(speed); plug = jointFn.findPlug("unParticleVariationPercent"); float variation; plug.getValue(variation); plug = jointFn.findPlug("unParticleConeAngle"); float coneAngle; plug.getValue(coneAngle); plug = jointFn.findPlug("unParticleGravity"); float gravity; plug.getValue(gravity); plug = jointFn.findPlug("unParticleExplosiveForce"); float explosiveForce = 0.0f; if(!plug.isNull()) { plug.getValue(explosiveForce); } plug = jointFn.findPlug("unParticleLife"); float life; plug.getValue(life); plug = jointFn.findPlug("unParticleLifeVariation"); float lifeVar; if(plug.isNull()) { lifeVar = 0.0f; } else { plug.getValue(lifeVar); } plug = jointFn.findPlug("unParticleEmissionRate"); float emissionRate; plug.getValue(emissionRate); plug = jointFn.findPlug("unParticleLimitNum"); short limitNum; plug.getValue(limitNum); plug = jointFn.findPlug("unParticleInitialNum"); short initialNum = 0; if(!plug.isNull())plug.getValue(initialNum); plug = jointFn.findPlug("unParticleAttachToEmitter"); bool attachToEmitter; plug.getValue(attachToEmitter); plug = jointFn.findPlug("unParticleMoveWithEmitter"); bool moveWithEmitter = false; if(!plug.isNull())plug.getValue(moveWithEmitter); //23 plug = jointFn.findPlug("unParticleForTheSword"); bool forTheSword = false; if(!plug.isNull())plug.getValue(forTheSword); //24 plug = jointFn.findPlug("unParticleForTheSwordInitialAngle"); float forTheSwordInitialAngle = 0; if(!plug.isNull())plug.getValue(forTheSwordInitialAngle); //25 plug = jointFn.findPlug("unParticleWander"); bool wander = false; if(!plug.isNull())plug.getValue(wander); //25 plug = jointFn.findPlug("unParticleWanderRadius"); float wanderRadius = 0.0f; if(!plug.isNull())plug.getValue(wanderRadius); //25 plug = jointFn.findPlug("unParticleWanderSpeed"); float wanderSpeed = 0.0f; if(!plug.isNull())plug.getValue(wanderSpeed); plug = jointFn.findPlug("unParticleAspectRatio"); float aspectRatio; if(plug.isNull()) { aspectRatio = 1.0f; } else { plug.getValue(aspectRatio); } plug = jointFn.findPlug("unParticleInitialAngleBegin"); float angleBegin; if(plug.isNull()) { angleBegin = 0.0f; } else { plug.getValue(angleBegin); } plug = jointFn.findPlug("unParticleInitialAngleEnd"); float angleEnd; if(plug.isNull()) { angleEnd = 0.0f; } else { plug.getValue(angleEnd); } plug = jointFn.findPlug("unParticleRotationSpeed"); float rotationSpeed; if(plug.isNull()) { rotationSpeed = 0; } else { plug.getValue(rotationSpeed); } plug = jointFn.findPlug("unParticleRotationSpeedVar"); float rotationSpeedVar; if(plug.isNull()) { rotationSpeedVar = 0; } else { plug.getValue(rotationSpeedVar); } plug = jointFn.findPlug("unParticleEmitterWidth"); float width; plug.getValue(width); plug = jointFn.findPlug("unParticleEmitterLength"); float length; plug.getValue(length); plug = jointFn.findPlug("unParticleEmitterHeight"); float height = 0.0f; if(!plug.isNull()) { plug.getValue(height); } plug = jointFn.findPlug("unParticleBlendMode"); short blendMode; plug.getValue(blendMode); plug = jointFn.findPlug("unParticleTextureFilename"); MItDependencyGraph dgIt(plug, MFn::kFileTexture, MItDependencyGraph::kUpstream, MItDependencyGraph::kBreadthFirst, MItDependencyGraph::kNodeLevel); dgIt.disablePruningOnFilter(); MString textureName; if (!dgIt.isDone()) { MObject textureNode = dgIt.thisNode(); MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName"); filenamePlug.getValue(textureName); } else { char str[256]; sprintf(str,"%s particle system must has file-texture",newJoint.name.asChar()); MessageBox(0,str,0,0); } plug = jointFn.findPlug("unParticleTextureRows"); short rows; plug.getValue(rows); plug = jointFn.findPlug("unParticleTextureCols"); short cols; plug.getValue(cols); plug = jointFn.findPlug("unParticleTextureChangeStyle"); short changeStyle; if(plug.isNull()) { //0 - 顺序 //1 - 随机 changeStyle = 0; } else { plug.getValue(changeStyle); } plug = jointFn.findPlug("unParticleTextureChangeInterval"); short changeInterval; if(plug.isNull()) { //默认30ms换一个 changeInterval = 30; } else { plug.getValue(changeInterval); } plug = jointFn.findPlug("unParticleTailLength"); float tailLength; plug.getValue(tailLength); plug = jointFn.findPlug("unParticleTimeMiddle"); float timeMiddle; plug.getValue(timeMiddle); plug = jointFn.findPlug("unParticleColorStart"); MObject object; plug.getValue(object); MFnNumericData dataS(object); float colorStart[3]; dataS.getData(colorStart[0],colorStart[1],colorStart[2]); plug = jointFn.findPlug("unParticleColorMiddle"); plug.getValue(object); MFnNumericData dataM(object); float colorMiddle[3]; dataM.getData(colorMiddle[0],colorMiddle[1],colorMiddle[2]); plug = jointFn.findPlug("unParticleColorEnd"); plug.getValue(object); MFnNumericData dataE(object); float colorEnd[3]; dataE.getData(colorEnd[0],colorEnd[1],colorEnd[2]); plug = jointFn.findPlug("unParticleAlpha"); plug.getValue(object); MFnNumericData dataAlpha(object); float alpha[3]; dataAlpha.getData(alpha[0],alpha[1],alpha[2]); //Scale plug = jointFn.findPlug("unParticleScale"); plug.getValue(object); MFnNumericData dataScale(object); float scale[3]; dataScale.getData(scale[0],scale[1],scale[2]); //ScaleVar plug = jointFn.findPlug("unParticleScaleVar"); float scaleVar[3] = {0.0f,0.0f,0.0f}; if(!plug.isNull()) { plug.getValue(object); MFnNumericData dataScaleVar(object); dataScaleVar.getData(scaleVar[0],scaleVar[1],scaleVar[2]); } //FixedSize plug = jointFn.findPlug("unParticleFixedSize"); bool fixedSize = false; if(!plug.isNull()) { plug.getValue(fixedSize); } //HeadLifeSpan plug = jointFn.findPlug("unParticleHeadLifeSpan"); plug.getValue(object); MFnNumericData dataHeadLifeSpan(object); short headLifeSpan[3]; dataHeadLifeSpan.getData(headLifeSpan[0],headLifeSpan[1],headLifeSpan[2]); plug = jointFn.findPlug("unParticleHeadDecay"); plug.getValue(object); MFnNumericData dataHeadDecay(object); short headDecay[3]; dataHeadDecay.getData(headDecay[0],headDecay[1],headDecay[2]); plug = jointFn.findPlug("unParticleTailLifeSpan"); plug.getValue(object); MFnNumericData dataTailLifeSpan(object); short tailLifeSpan[3]; dataTailLifeSpan.getData(tailLifeSpan[0],tailLifeSpan[1],tailLifeSpan[2]); plug = jointFn.findPlug("unParticleTailDecay"); plug.getValue(object); MFnNumericData dataTailDecay(object); short tailDecay[3]; dataTailDecay.getData(tailDecay[0],tailDecay[1],tailDecay[2]); plug = jointFn.findPlug("unParticleHead"); bool head; plug.getValue(head); plug = jointFn.findPlug("unParticleTail"); bool tail; plug.getValue(tail); plug = jointFn.findPlug("unParticleUnShaded"); bool unshaded; plug.getValue(unshaded); plug = jointFn.findPlug("unParticleUnFogged"); bool unfogged; plug.getValue(unfogged); plug = jointFn.findPlug("unParticleBlockByY0"); bool blockByY0 = false; if(!plug.isNull()) plug.getValue(blockByY0); newJoint.particle.visible = visible; newJoint.particle.speed = speed; newJoint.particle.variation = variation / 100.0f; newJoint.particle.coneAngle = coneAngle; newJoint.particle.gravity = gravity; newJoint.particle.explosiveForce = explosiveForce; newJoint.particle.life = life; newJoint.particle.lifeVar = lifeVar; newJoint.particle.emissionRate = emissionRate; newJoint.particle.initialNum = initialNum; newJoint.particle.limitNum = limitNum; newJoint.particle.attachToEmitter = attachToEmitter; newJoint.particle.moveWithEmitter = moveWithEmitter; newJoint.particle.forTheSword = forTheSword; newJoint.particle.forTheSwordInitialAngle = forTheSwordInitialAngle; newJoint.particle.wander = wander; newJoint.particle.wanderRadius = wanderRadius; newJoint.particle.wanderSpeed = wanderSpeed; newJoint.particle.aspectRatio = aspectRatio; newJoint.particle.initialAngleBegin = angleBegin; newJoint.particle.initialAngleEnd = angleEnd; newJoint.particle.rotationSpeed = rotationSpeed; newJoint.particle.rotationSpeedVar = rotationSpeedVar; newJoint.particle.width = width; newJoint.particle.length = length; newJoint.particle.height = height; newJoint.particle.blendMode = blendMode; newJoint.particle.textureFilename = textureName.asChar(); newJoint.particle.textureRows = rows; newJoint.particle.textureCols = cols; newJoint.particle.changeStyle = changeStyle; newJoint.particle.changeInterval = changeInterval; newJoint.particle.tailLength = tailLength; newJoint.particle.timeMiddle = timeMiddle; newJoint.particle.colorStart[0] = colorStart[0]; newJoint.particle.colorStart[1] = colorStart[1]; newJoint.particle.colorStart[2] = colorStart[2]; newJoint.particle.colorMiddle[0] = colorMiddle[0]; newJoint.particle.colorMiddle[1] = colorMiddle[1]; newJoint.particle.colorMiddle[2] = colorMiddle[2]; newJoint.particle.colorEnd[0] = colorEnd[0]; newJoint.particle.colorEnd[1] = colorEnd[1]; newJoint.particle.colorEnd[2] = colorEnd[2]; newJoint.particle.alpha[0] = alpha[0]; newJoint.particle.alpha[1] = alpha[1]; newJoint.particle.alpha[2] = alpha[2]; newJoint.particle.scale[0] = scale[0]; newJoint.particle.scale[1] = scale[1]; newJoint.particle.scale[2] = scale[2]; newJoint.particle.scaleVar[0] = scaleVar[0]; newJoint.particle.scaleVar[1] = scaleVar[1]; newJoint.particle.scaleVar[2] = scaleVar[2]; newJoint.particle.fixedSize = fixedSize; newJoint.particle.headLifeSpan[0] = headLifeSpan[0]; newJoint.particle.headLifeSpan[1] = headLifeSpan[1]; newJoint.particle.headLifeSpan[2] = headLifeSpan[2]; newJoint.particle.headDecay[0] = headDecay[0]; newJoint.particle.headDecay[1] = headDecay[1]; newJoint.particle.headDecay[2] = headDecay[2]; newJoint.particle.tailLifeSpan[0] = tailLifeSpan[0]; newJoint.particle.tailLifeSpan[1] = tailLifeSpan[1]; newJoint.particle.tailLifeSpan[2] = tailLifeSpan[2]; newJoint.particle.tailDecay[0] = tailDecay[0]; newJoint.particle.tailDecay[1] = tailDecay[1]; newJoint.particle.tailDecay[2] = tailDecay[2]; newJoint.particle.head = head; newJoint.particle.tail = tail; newJoint.particle.unshaded = unshaded; newJoint.particle.unfogged = unfogged; newJoint.particle.blockByY0 = blockByY0; } } m_joints.push_back(newJoint); // Get pointer to newly created joint parentJoint = &newJoint; } // Load children joints for (i=0; i<jointDag.childCount();i++) { MObject child; child = jointDag.child(i); MDagPath childDag = jointDag; childDag.push(child); loadJoint(childDag,parentJoint); } }
bool slopeShaderBehavior::shouldBeUsedFor( MObject &sourceNode, MObject &destinationNode, MPlug &sourcePlug, MPlug &destinationPlug) // // Description: // Overloaded function from MPxDragAndDropBehavior // this method will return true if it is going to handle the connection // between the two nodes given. // { bool result = false; if(sourceNode.hasFn(MFn::kLambert)) { //if the source node was a lambert //than we will check the downstream connections to see //if a slope shader is assigned to it. // MObject shaderNode; MFnDependencyNode src(sourceNode); MPlugArray connections; src.getConnections(connections); for(unsigned i = 0; i < connections.length(); i++) { //check the incoming connections to this plug // MPlugArray connectedPlugs; connections[i].connectedTo(connectedPlugs, true, false); for(unsigned j = 0; j < connectedPlugs.length(); j++) { //if the incoming node is a slope shader than //set shaderNode equal to it and break out of the inner //loop // if(MFnDependencyNode(connectedPlugs[j].node()).typeName() == "slopeShader") { shaderNode = connectedPlugs[j].node(); break; } } //if the shaderNode is not null //than we have found a slopeShader // if(!shaderNode.isNull()) { //if the destination node is a mesh than we will take //care of this connection so set the result to true //and break out of the outer loop // if(destinationNode.hasFn(MFn::kMesh)) result = true; break; } } } if(MFnDependencyNode(sourceNode).typeName() == "slopeShader") //if the sourceNode is a slope shader than check what we //are dropping on to // { if(destinationNode.hasFn(MFn::kLambert)) result = true; else if(destinationNode.hasFn(MFn::kMesh)) result = true; } return result; }
MStatus slopeShaderBehavior::connectNodeToNode( MObject &sourceNode, MObject &destinationNode, bool force ) // // Description: // Overloaded function from MPxDragAndDropBehavior // this method will handle the connection between the slopeShader and the shader it is // assigned to as well as any meshes that it is assigned to. // { MStatus result = MS::kFailure; MFnDependencyNode src(sourceNode); //if we are dragging from a lambert //we want to check what we are dragging //onto. if(sourceNode.hasFn(MFn::kLambert)) { MObject shaderNode; MPlugArray connections; MObjectArray shaderNodes; shaderNodes.clear(); //if the source node was a lambert //than we will check the downstream connections to see //if a slope shader is assigned to it. // src.getConnections(connections); unsigned i; for(i = 0; i < connections.length(); i++) { //check the incoming connections to this plug // MPlugArray connectedPlugs; connections[i].connectedTo(connectedPlugs, true, false); for(unsigned j = 0; j < connectedPlugs.length(); j++) { //if the incoming node is a slope shader than //append the node to the shaderNodes array // MObject currentnode = connectedPlugs[j].node(); if(MFnDependencyNode(currentnode).typeName() == "slopeShader") { shaderNodes.append(currentnode); } } } //if we found a shading node //than check the destination node //type to see if it is a mesh // if(shaderNodes.length() > 0) { MFnDependencyNode dest(destinationNode); if(destinationNode.hasFn(MFn::kMesh)) { //if the node is a mesh than for each slopeShader //connect the worldMesh attribute to the dirtyShaderPlug //attribute to force an evaluation of the node when the mesh //changes // for(i = 0; i < shaderNodes.length(); i++) { MPlug srcPlug = dest.findPlug("worldMesh"); MPlug destPlug = MFnDependencyNode(shaderNodes[i]).findPlug("dirtyShaderPlug"); if(!srcPlug.isNull() && !destPlug.isNull()) { MString cmd = "connectAttr -na "; cmd += srcPlug.name() + " "; cmd += destPlug.name(); MGlobal::executeCommand(cmd); } } //get the shading engine so we can assign the shader //to the mesh after doing the connection // MObject shadingEngine = findShadingEngine(sourceNode); //if there is a valid shading engine than make //the connection // if(!shadingEngine.isNull()) { MString cmd = "sets -edit -forceElement "; cmd += MFnDependencyNode(shadingEngine).name() + " "; cmd += MFnDagNode(destinationNode).partialPathName(); result = MGlobal::executeCommand(cmd); } } } } else if(src.typeName() == "slopeShader") //if we are dragging from a slope shader //than we want to see what we are dragging onto // { if(destinationNode.hasFn(MFn::kMesh)) { //if the user is dragging onto a mesh //than make the connection from the worldMesh //to the dirtyShader plug on the slopeShader // MFnDependencyNode dest(destinationNode); MPlug srcPlug = dest.findPlug("worldMesh"); MPlug destPlug = src.findPlug("dirtyShaderPlug"); if(!srcPlug.isNull() && !destPlug.isNull()) { MString cmd = "connectAttr -na "; cmd += srcPlug.name() + " "; cmd += destPlug.name(); result = MGlobal::executeCommand(cmd); } } } return result; }
bool FxAttributeFiller::FillScript( DXCCEffectPath& parameter, MPlug& plug ) { MString plugName= Shader->EncodePlug(plug); MString MELPlugName= MFnDependencyNode(plug.node()).name() + MString(".") + plugName; switch(parameter.End->Description.Class) { case D3DXPC_SCALAR: { if( 0 == lstrcmpiA( SasUiControl.asChar(), "Slider")) { Script.AppendFormat("\tdxfxControlSliderCreate(\"float\", \"%s\", \"%f\", \"%f\", \"%d\", \"%s\");\n", SasUiLabel.asChar(), SasUiMin, SasUiMax, SasUiSteps, MELPlugName.asChar() ); } else { Script.AppendFormat("\tdxfxControlScalarCreate(\"float\", \"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar()); } } break; case D3DXPC_VECTOR: { if( 0 == lstrcmpiA( SasUiControl.asChar(), "ColorPicker") && parameter.End->Description.Columns >= 3) {//COLOR Script.AppendFormat("\tdxfxControlColorCreate(\"%s\", \"%s\", %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Columns); } else {//VECTOR Script.AppendFormat("\tdxfxControlVectorCreate(\"float\", \"%s\", \"%s\", %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Columns); } } break; case D3DXPC_MATRIX_ROWS: case D3DXPC_MATRIX_COLUMNS: { Script.AppendFormat("\tdxfxControlMatrixCreate(\"float\", \"%s\", \"%s\", %d, %d);\n", SasUiLabel.asChar(), MELPlugName.asChar(), parameter.End->Description.Rows, parameter.End->Description.Columns); } break; case D3DXPC_OBJECT: switch(parameter.End->Description.Type) { case D3DXPT_STRING: { Script.AppendFormat("\tdxfxControlStringCreate(\"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar()); } break; case D3DXPT_TEXTURE: case D3DXPT_TEXTURE1D: case D3DXPT_TEXTURE2D: case D3DXPT_TEXTURE3D: case D3DXPT_TEXTURECUBE: { Script.AppendFormat("\tdxfxControlTextureCreate(\"%s\", \"%s\");\n", SasUiLabel.asChar(), MELPlugName.asChar()); } break; default: break; }; break; default: break; }; return true; }
MStatus parseShader(MObject &src, SXRShaderData& d) { MStatus status; MFnSet fnSet( src, &status ); if (status == MStatus::kFailure) { status.perror("Unable to lookup shader from set of shaders for object"); return status; } MObject shaderNode = findShader(src,d); if (shaderNode == MObject::kNullObj) return (MStatus::kFailure); MPlug colorPlug = MFnDependencyNode(shaderNode).findPlug("color", &status); if (status == MStatus::kFailure) return (status); MItDependencyGraph dgIt(colorPlug, MFn::kFileTexture, MItDependencyGraph::kUpstream, MItDependencyGraph::kBreadthFirst, MItDependencyGraph::kNodeLevel, &status); if (status == MStatus::kFailure) return (status); dgIt.disablePruningOnFilter(); // If no texture file node was found, just continue. // if (dgIt.isDone()) { // cout << "no textures found for " << colorPlug.name() << "\n"; return (MStatus::kSuccess); } // Print out the texture node name and texture file that it references. // MObject textureNode = dgIt.thisNode(); MPlug filenamePlug = MFnDependencyNode(textureNode).findPlug("fileTextureName"); MString textureName; filenamePlug.getValue(textureName); MStringArray rgFolders; if (strchr (textureName.asChar(), '\\')) { textureName.split ('\\', rgFolders); } else { textureName.split ('/', rgFolders); } d.tex_name = rgFolders[rgFolders.length() -1]; // cout << "Found texture file: '" << filename.asChar() << "'\n"; short index; //double side flag MPlug xrDoubleSidePlug= MFnDependencyNode(shaderNode).findPlug("xrayDoubleSide", &status); if (status == MS::kSuccess) { MFnEnumAttribute enm = xrDoubleSidePlug.attribute(); if ((status == MS::kSuccess)&&(MS::kSuccess==xrDoubleSidePlug.getValue(index))) d.double_side = index; } //engine MPlug xrEnginePlug= MFnDependencyNode(shaderNode).findPlug("xrayEngineShader", &status); if (status == MS::kSuccess) { MFnEnumAttribute enm = xrEnginePlug.attribute(); if ((status == MS::kSuccess)&&(MS::kSuccess==xrEnginePlug.getValue(index))) d.eng_name = enm.fieldName(index); } //compiler MPlug xrCompilerPlug = MFnDependencyNode(shaderNode).findPlug("xrayCompilerShader", &status); if (status == MS::kSuccess) { MFnEnumAttribute enm = xrCompilerPlug.attribute(); if ((status == MS::kSuccess)&&(MS::kSuccess==xrCompilerPlug.getValue(index))) d.comp_name = enm.fieldName(index); } //game material MPlug xrGameMaterialPlug = MFnDependencyNode(shaderNode).findPlug("xrayGameMaterial", &status); if (status == MS::kSuccess) { MFnEnumAttribute enm = xrGameMaterialPlug.attribute(); if ((status == MS::kSuccess)&&(MS::kSuccess==xrGameMaterialPlug.getValue(index))) d.gmat_name = enm.fieldName(index); } return (MStatus::kSuccess); }