MStatus liqAttachPrefAttribute::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getObjects(objectNames); if (!status) { MGlobal::displayError("error parsing object list"); return MS::kFailure; } worldSpace = false; int flagIndex = args.flagIndex("ws", "worldSpace"); if (flagIndex != MArgList::kInvalidArgIndex) worldSpace = true; exportN = false; flagIndex = args.flagIndex("en", "exportN"); if (flagIndex != MArgList::kInvalidArgIndex) exportN = true; //printf(">> got %d objects to PREF !\n",objectNames.length() ); return redoIt(); }
MStatus liqWriteArchive::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getCommandArgument(0, tempStr); if (!status) { MGlobal::displayError("error parsing object name argument"); return MS::kFailure; } objectNames.append(tempStr); status = argParser.getCommandArgument(1, outputFilename); if (!status) { MGlobal::displayError("error parsing rib filename argument"); return MS::kFailure; } outputRootTransform = false; int flagIndex = args.flagIndex("rt", "rootTransform"); if (flagIndex != MArgList::kInvalidArgIndex) { outputRootTransform = true; } outputChildTransforms = true; flagIndex = args.flagIndex("ct", "childTransforms"); if (flagIndex != MArgList::kInvalidArgIndex) { outputChildTransforms = true; } debug = false; flagIndex = args.flagIndex("d", "debug"); if (flagIndex != MArgList::kInvalidArgIndex) { debug = true; } binaryRib = false; flagIndex = args.flagIndex("b", "binary"); if (flagIndex != MArgList::kInvalidArgIndex) { binaryRib = true; } return redoIt(); }
MStatus setupRGBShaders::doIt( const MArgList & args ) { unsigned int FIndex = args.flagIndex( "fp", "folderPath" ); unsigned int fIndex = args.flagIndex( "fn", "fileName" ); if( FIndex == MArgList::kInvalidArgIndex || fIndex == MArgList::kInvalidArgIndex ) { MGlobal::displayError( "Error specifying flag or flag values. \n-fp, -folderPath <folder_path> \t -fn, -fileName <file_name>" ); return MS::kFailure; } folderPath = args.asString( FIndex ); fileName = args.asString( fIndex ); MItDag meshIt( MItDag::kDepthFirst, MFn::kMesh ); for( ; !meshIt.isDone(); meshIt.next() ) { MDagPath dagPath; meshIt.getPath( dagPath ); meshObjs.append( dagPath.transform() ); } MItDag camIt( MItDag::kDepthFirst, MFn::kCamera ); for( ; !camIt.isDone(); camIt.next() ) { MDagPath dagPath; camIt.getPath( dagPath ); MFnDependencyNode camFn( dagPath.node() ); bool isRenderable; camFn.findPlug( "renderable" ).getValue( isRenderable ); if( isRenderable ) camObjs.append( dagPath.transform() ); } MGlobal::executeCommand( "setAttr miDefaultFramebuffer.datatype 5" ); return redoIt(); }
MStatus vixo_hairCacheExport::doIt(const MArgList& args) { MString vixoHairNode; int startFrame,endFrame; unsigned index; index=args.flagIndex("vhn","vixoHairNode"); if(MArgList::kInvalidArgIndex!=index) { args.get(index+1,vixoHairNode); } index=args.flagIndex("sf","startFrame"); if(MArgList::kInvalidArgIndex!=index) { args.get(index+1,startFrame); } index=args.flagIndex("ef","endFrame"); if(MArgList::kInvalidArgIndex!=index) { args.get(index+1,endFrame); } //get hairCacheFileName MSelectionList slist; MGlobal::getSelectionListByName(vixoHairNode,slist); MDagPath vixoHairNodeDag; slist.getDagPath(0,vixoHairNodeDag); vixoHairNodeDag.extendToShape(); MFnDagNode fnVixoHair(vixoHairNodeDag); MPlug plugCacheFileName=fnVixoHair.findPlug("hairCacheFileName"); MString cacheFileName=plugCacheFileName.asString(); //~get hairCacheFileName //get staticMesh MPlug plugStaticMesh=fnVixoHair.findPlug("staticInMesh"); MObject staticMeshObj=MFnMeshData(plugStaticMesh.asMObject()).object(); //~get staticMesh //build out dataBase MFnMesh fnStaticMesh(staticMeshObj); map<int,set<outInVertexRelationInfo>> outVertexDataBase; map<int,vector<outVIDCtrlInfo>> outVertexControlData; for(int i=0;i<fnStaticMesh.numVertices();i++) { set<outInVertexRelationInfo> temp; temp.clear(); outVertexDataBase.insert(pair<int,set<outInVertexRelationInfo>>(i,temp)); } //build out dataBase //get inCurveVID map<int,int> plugMapVID; map<int,int> VIDMapPlug; map<int,inVertexBasicInfo> inVIDMapInVertexDataBase; MPlug plugAllInCurve=fnVixoHair.findPlug("inCtrlCurveData"); MIntArray existIndex; plugAllInCurve.getExistingArrayAttributeIndices(existIndex); for(int i=0;i<existIndex.length();i++) { MPlugArray arr; plugAllInCurve.elementByLogicalIndex(existIndex[i]).connectedTo(arr,true,false); MFnDependencyNode fnHairSystem(arr[0].node()); MPlug inputHairs=fnHairSystem.findPlug("inputHair"); arr.clear(); inputHairs.elementByLogicalIndex(existIndex[i]).connectedTo(arr,true,false); MFnDependencyNode fnFolli(arr[0].node()); int vid=fnFolli.findPlug("vertexID").asInt(); plugMapVID.insert(pair<int,int>(existIndex[i],vid)); VIDMapPlug.insert(pair<int,int>(vid,existIndex[i])); initBasicStepInfo(vid,staticMeshObj,inVIDMapInVertexDataBase); } //~get inCurveVID //build in out relation map<int,inVertexBasicInfo>::iterator inDBIter; for(inDBIter=inVIDMapInVertexDataBase.begin();inDBIter!=inVIDMapInVertexDataBase.end();inDBIter++) { buileRelationBetweenInOut(inDBIter->first,inVIDMapInVertexDataBase,outVertexDataBase); } map<int,set<outInVertexRelationInfo>>::iterator outDBIter; for(outDBIter=outVertexDataBase.begin();outDBIter!=outVertexDataBase.end();outDBIter++) { sortControlOrder(outDBIter->first,outVertexDataBase,outVertexControlData); } //~build in out relation for(int i=startFrame;i<=endFrame;i++) { MString currentTime; currentTime.set(i); MGlobal::executeCommand("currentTime "+currentTime); MGlobal::executeCommand("dgeval "+vixoHairNode+".hiddenOutput"); //get dynamic mesh MPlug plugDynamicMesh=fnVixoHair.findPlug("dynamicInMesh"); MObject dynamicMeshObj=MFnMeshData(plugDynamicMesh.asMObject()).object(); //~get dynamic mesh //export cache //faceid triid vid position normal tangent vector<forExportHairCache> exportData; exportBasicData(dynamicMeshObj,exportData); //curve tangent //get in curve infos map<int,MVectorArray> inCurveShape; getInCurveInfo(plugMapVID,vixoHairNode,inCurveShape); //~get in curve infos vector<vec3> outCurveCacheData; vec3 init; init.x=0; init.y=0; init.z=0; outCurveCacheData.resize(fnStaticMesh.numVertices()*inCurveShape.begin()->second.length(),init); buildCache(inCurveShape.begin()->second.length(),dynamicMeshObj,outCurveCacheData,inCurveShape,outVertexControlData); //~export cache //write to file MString fileName=getFileName(cacheFileName,i); fstream fout(fileName.asChar(),ios_base::out|ios_base::binary); int triNumvertexNum[3]; triNumvertexNum[0]=exportData.size(); triNumvertexNum[1]=fnStaticMesh.numVertices(); triNumvertexNum[2]=inCurveShape.begin()->second.length(); fout.write((char*)triNumvertexNum,sizeof(int)*3); fout.write((char*)&exportData[0],sizeof(forExportHairCache)*exportData.size()); fout.write((char*)&outCurveCacheData[0],sizeof(vec3)*outCurveCacheData.size()); fout.flush(); fout.close(); /* MString fileNameDebug=fileName+".dbg"; fout.open(fileNameDebug.asChar(),ios_base::out); for(int i=0;i<outCurveCacheData.size();i++) { fout<<outCurveCacheData[i].x<<" "<<outCurveCacheData[i].y<<" "<<outCurveCacheData[i].z<<endl; } fout.flush(); fout.close(); */ //~write to file } return MS::kSuccess; }
MStatus ribGenCmd::doIt( const MArgList& args) { /*=========================================* * the parameters of command * =========================================*/ MString ribPath, shaderPath; unsigned index; index = args.flagIndex("p", "ribPath"); if(MArgList::kInvalidArgIndex != index) args.get(index+1, ribPath); index = args.flagIndex("sp", "shaderPath"); if(MArgList::kInvalidArgIndex != index) args.get(index+1, shaderPath); /*=========================================* * shaderPath & ribPath *=========================================*/ RtToken shader= new char[50] , path=new char[50]; strcpy(shader, shaderPath.asChar()); strcpy(path, ribPath.asChar()); char *curve[] = {"curves"}; RtMatrix identityMatrix = { { 1, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 }}; RtInt ustep, vstep; ustep = vstep =1; /*=====================================* * Begenning of writting out the .rib file. *=====================================*/ RiBegin(path); RiAttributeBegin(); RiTransformBegin(); //RiSurface(shader); RiTransformEnd(); //RiAttribute("identifier", "name", curve); RiConcatTransform(identityMatrix); RiShadingInterpolation(RI_SMOOTH); RiBasis(RiBezierBasis, ustep, RiBezierBasis, vstep); int nodeId = 0, knotNum = 0; float baseWidth = 0.0f, tipWidth = 0.0f; MObject surface, node; /*=========================================* * get the informations of selected Objects in scene. *=========================================*/ MSelectionList selection; MGlobal::getActiveSelectionList(selection); MItSelectionList iter(selection, MFn::kNurbsSurface ); for(; !iter.isDone(); iter.next()) { RtInt numCurves = 0; RtInt numVertexs = 0; /*======================================* * get the drawHairNode from selected NurbsSurface. *======================================*/ iter.getDependNode(surface); MFnDependencyNode surfaceFn(surface); MStatus state; MPlug plug = surfaceFn.findPlug("worldSpace",false, &state); plug = plug.elementByLogicalIndex(0); MPlugArray desPlugs; plug.connectedTo(desPlugs,false,true); plug = desPlugs[0]; node = plug.node(); //drawHairNode has found here!! /*=====================================* * get the attributes of drawHairNode. *=====================================*/ MFnDependencyNode hairNodeFn(node); plug = hairNodeFn.findPlug("nodeId"); plug.getValue(nodeId); MGlobal::displayInfo(MString(" nodeId: ")+nodeId); plug = hairNodeFn.findPlug("number"); plug.getValue(numCurves); plug= hairNodeFn.findPlug("smooth"); plug.getValue(knotNum); plug = hairNodeFn.findPlug("baseWidth"); plug.getValue(baseWidth); plug = hairNodeFn.findPlug("tipWidth"); plug.getValue(tipWidth); /*=====================================* * caculate the linear interpolate of the width of the curve. *=====================================*/ numVertexs = numCurves * knotNum; int widthNum = numCurves * (knotNum -2 ); float *curveWidth = new float[widthNum]; float widthStep = 0.0f; for(int c=0; c<widthNum; ++c){ widthStep = ((c%(knotNum-2)) / (float)(knotNum-3)) *(tipWidth - baseWidth); if(widthStep < epslion) widthStep = 0.0f; curveWidth[c] = baseWidth + widthStep; } RtInt *nvertices = new RtInt[numCurves]; //the numbers of vertices on each curve. RtPoint *vertexs = new RtPoint[numVertexs]; //the total vertexs. /*=====================================* * nvertices[] assignment. *=====================================*/ for(int j=0; j<numCurves ; ++j){ nvertices[j] = knotNum; } /*=====================================* * get the hair's datas from the static member * named "nodeManager" of the drawHairNode class. *=====================================*/ nodeMap::iterator iter = drawHairNode::nodeManager.find(nodeId); vector<MPointArray> helixVec = iter->second; /*=====================================* * vertexs[] assignment. *=====================================*/ float x=0, y=0, z=0; int countVT=0; for(vector<MPointArray>::iterator it=helixVec.begin(); it != helixVec.end(); ++it){ MPointArray helixCurve = (MPointArray)(*it); for(int k=0; k < helixCurve.length() ; ++k){ x = helixCurve[k].x; if(fabs(x) < epslion) vertexs[countVT][0] = 0; else vertexs[countVT][0] = helixCurve[k].x; y = helixCurve[k].y; if(fabs(y) < epslion) vertexs[countVT][1] = 0; else vertexs[countVT][1] = helixCurve[k].y; z = helixCurve[k].z; if(fabs(z) < epslion) vertexs[countVT++][2] = 0; else vertexs[countVT++][2] = helixCurve[k].z; } } RiCurves( RI_CUBIC, numCurves, nvertices, RI_NONPERIODIC, RI_P, vertexs, RI_WIDTH, curveWidth, RI_NULL); } RiAttributeEnd(); RiEnd(); return redoIt(); }
MStatus testExCameraSetCmd::parseArgs( const MArgList& args) // // Parses the command line arguments. // { MStatus status; // Get the flags. If the create or help flags are used, return success and ignore the other flags. createUsed = (args.flagIndex(kCreateFlag, kCreateFlagLong) != MArgList::kInvalidArgIndex); editUsed = (args.flagIndex(kEditFlag, kEditFlagLong) != MArgList::kInvalidArgIndex); queryUsed = (args.flagIndex(kQueryFlag, kQueryFlagLong) != MArgList::kInvalidArgIndex); helpUsed = (args.flagIndex(kHelpFlag, kHelpFlagLong) != MArgList::kInvalidArgIndex); numLayersUsed = (args.flagIndex(kNumLayersFlag, kNumLayersFlagLong) != MArgList::kInvalidArgIndex); // If flags are used which require no other information, return now. if (createUsed || helpUsed) return MS::kSuccess; unsigned int maxArg = args.length() - 1; unsigned int activeIndex = args.flagIndex(kActiveFlag, kActiveFlagLong); unsigned int appendCameraIndex = args.flagIndex(kAppendCameraFlag, kAppendCameraFlagLong); unsigned int appendCameraAndSetIndex = args.flagIndex(kAppendCameraAndSetFlag, kAppendCameraAndSetFlagLong); unsigned int cameraIndex = args.flagIndex(kCameraFlag, kCameraFlagLong); unsigned int deleteLayerIndex = args.flagIndex(kDeleteLayerFlag, kDeleteLayerFlagLong); unsigned int layerIndex = args.flagIndex(kLayerFlag, kLayerFlagLong); unsigned int layerTypeIndex = args.flagIndex(kLayerTypeFlag, kLayerTypeFlagLong); unsigned int setIndex = args.flagIndex(kSetFlag, kSetFlagLong); activeUsed = (activeIndex != MArgList::kInvalidArgIndex); appendCameraUsed = (appendCameraIndex != MArgList::kInvalidArgIndex); appendCameraAndSetUsed = (appendCameraAndSetIndex != MArgList::kInvalidArgIndex); cameraUsed = (cameraIndex != MArgList::kInvalidArgIndex); deleteLayerUsed = (deleteLayerIndex != MArgList::kInvalidArgIndex); layerUsed = (layerIndex != MArgList::kInvalidArgIndex); layerTypeUsed = (layerTypeIndex != MArgList::kInvalidArgIndex); setUsed = (setIndex != MArgList::kInvalidArgIndex); // Process each flag. bool maxArgUsed = false; if (activeUsed) { if (editUsed) { activeVal = args.asBool((activeIndex+1), &status); if (status != MS::kSuccess) { MGlobal::displayError("-active must be either true or false"); return status; } if ((layerTypeIndex+1) == maxArg) maxArgUsed = true; } } if (appendCameraUsed) { camName = args.asString((appendCameraIndex+1), &status); if (status != MS::kSuccess) { MGlobal::displayError("-appendCamera must have a valid camera node specified"); return status; } if ((appendCameraIndex+1) == maxArg) maxArgUsed = true; } if (appendCameraAndSetUsed) { camName = args.asString((appendCameraAndSetIndex+1)); setName = args.asString((appendCameraAndSetIndex+2)); if ((appendCameraAndSetIndex+2) == maxArg) maxArgUsed = true; } if (cameraUsed) { if (editUsed) { camName = args.asString(cameraIndex+1); if ((cameraIndex+1) == maxArg) maxArgUsed = true; } } if (deleteLayerUsed) { cameraLayer = args.asInt(deleteLayerIndex+1); if ((deleteLayerIndex+1) == maxArg) maxArgUsed = true; } if (layerUsed) { cameraLayer = args.asInt(layerIndex+1); if ((layerIndex+1) == maxArg) maxArgUsed = true; } if (layerTypeUsed) { if (editUsed) { layerTypeVal = args.asString(layerTypeIndex+1); if ((layerTypeIndex+1) == maxArg) maxArgUsed = true; } } if (setUsed) { if (editUsed) { setName = args.asString(setIndex+1); if ((setIndex+1) == maxArg) maxArgUsed = true; } } // If all of the arguments have been used, get the cameraSet node from the selection list. // Otherwise, get it from the last argument. if (maxArgUsed) MGlobal::getActiveSelectionList(list); else list.add(args.asString(maxArg)); return MS::kSuccess; }