! Add flag to control hash types

src/MeshInfoCmd.cpp

@@ -8,10 +8,13 @@
 #include <maya/MDagPath.h>
 #include <maya/MFnMesh.h>
 #include <maya/MFloatArray.h>
+#include <maya/MPointArray.h>
 #include <maya/MItDag.h>
+
 #include <algorithm>
 #include <functional>
 #include <vector>
+#include <fstream>
 #include <iostream>
 #include <sstream>
 #include <chrono>
@@ -37,9 +40,12 @@ MSyntax MeshInfoCmd::newSyntex()
 
 	syntax.addFlag(kVtxHashFlag, kVtxHashFlagLong, MSyntax::kNoArg);
 	syntax.addFlag(kUvHashFlag, kUvHashFlagLong, MSyntax::kNoArg);
+	syntax.addFlag(kPtHashFlag, kPtHashFlagLong, MSyntax::kNoArg);
 	syntax.addFlag(kExtendToShapeFlag, kExtendToShapeFlagLong, MSyntax::kNoArg);
 	syntax.addFlag(kNoIntermediaFlag, kNoIntermediaFlagLong, MSyntax::kNoArg);
 	syntax.addFlag(kFileFlag, kFileFlagLong, MSyntax::kString);
+
+	syntax.enableQuery(true);
 	return syntax;
 }
 
@@ -68,6 +74,39 @@ MString MeshInfoCmd::getHash(MFloatArray & arrayData1, MFloatArray & arrayData2)
 	return MString(hex);
 }
 
+MString MeshInfoCmd::getHash(MPointArray & arrayData)
+{
+	auto SHA1 = sha1();
+	SHA1.add(&arrayData[0], sizeof(MPoint) * arrayData.length());
+	char hex[SHA1_HEX_SIZE];
+	SHA1.finalize().print_hex(hex);
+	return MString(hex);
+}
+
+MString MeshInfoCmd::getVtxHash(MFnMesh & fnMesh)
+{
+	MIntArray vertexCount, vertexList;
+	fnMesh.getVertices(vertexCount, vertexList);
+	MString vtx_hash = getHash(vertexCount, vertexList);
+	return vtx_hash;
+}
+
+MString MeshInfoCmd::getUvHash(MFnMesh & fnMesh)
+{
+	MFloatArray uArray, vArray;
+	fnMesh.getUVs(uArray, vArray);
+	MString uv_hash = getHash(uArray, vArray);
+	return uv_hash;
+}
+
+MString MeshInfoCmd::getPtHash(MFnMesh & fnMesh)
+{
+	MPointArray ptArray;
+	fnMesh.getPoints(ptArray);
+	MString pt_hash = getHash(ptArray);
+	return pt_hash;
+}
+
 MStatus MeshInfoCmd::extendToShape(MSelectionList & list)
 {
 	MStatus status;
@@ -81,23 +120,24 @@ MStatus MeshInfoCmd::extendToShape(MSelectionList & list)
 
 	for (unsigned int i = 0; i < nObj; i++)
 	{
+
 		MObject node;
 		current_list.getDependNode(0, node);
-		if (!node.hasFn(MFn::kMesh))
+		if (!node.hasFn(MFn::kMesh)) {
-		{
+
 			MItDag itDag;
 			itDag.reset(node);
 			while (!itDag.isDone())
 			{
+
 				MObject currentItem = itDag.currentItem();
-				if (!currentItem.hasFn(MFn::kMesh))
+				if (currentItem.hasFn(MFn::kMesh)) {
-					continue;
+					MDagPath dagPath;
+					MFnMesh fnMesh(dagPath);
 
-				MDagPath dagPath;
+					itDag.getPath(dagPath);
-				MFnMesh fnMesh(dagPath);
+					list.add(dagPath);
-
+				}
-				itDag.getPath(dagPath);
-				list.add(dagPath);
 				itDag.next();
 			}
 		}
@@ -123,26 +163,60 @@ MStatus MeshInfoCmd::doIt(const MArgList & args)
 		return status;
 	}
 
+	bool isQuery = argData.isQuery();
 	bool vtxHashGen = argData.isFlagSet(kVtxHashFlag);
 	bool uvHashGen = argData.isFlagSet(kUvHashFlag);
+	bool ptHashGen = argData.isFlagSet(kPtHashFlag);
 	bool ets = argData.isFlagSet(kExtendToShapeFlag);
 	bool noIntermdia = argData.isFlagSet(kNoIntermediaFlag);
 	bool fileGen = argData.isFlagSet(kFileFlag);
 
+	if (list.isEmpty()) {
+
+		MGlobal::displayError("Error to get object in selection list");
+		return MS::kNotFound;
+	}
+
+	if (isQuery) {
+
+		MObject node;
+		list.getDependNode(0, node);
+
+		if (!node.hasFn(MFn::kMesh)) {
+			MGlobal::displayError("Input node is not mesh type in query mode");
+			return MS::kInvalidParameter;
+		}
+
+		MDagPath meshPath;
+		list.getDagPath(0, meshPath);
+		MFnMesh fnMesh(meshPath);
+		if (vtxHashGen) {
+			setResult(getVtxHash(fnMesh));
+			return MS::kSuccess;
+		}
+		if (uvHashGen) {
+			setResult(getUvHash(fnMesh));
+			return MS::kSuccess;
+		}
+		if (ptHashGen) {
+			setResult(getPtHash(fnMesh));
+			return MS::kSuccess;
+		}
+	}
+
 	if (ets) {
 		extendToShape(list);
 	}
 
 	unsigned nObj = list.length();
-	MStringArray result;
+	
-	std::vector<std::string> header = { "name", "vertices_hash", "uv_hash" };
+	std::vector<std::string> header = { "name", "vertices_hash", "uv_hash", "point_hash", "num_vertices", "num_polygons" };
 	auto meshInfo = json::array();
 	meshInfo.push_back(header);
 	
-	if (nObj)
+	if (nObj){
-	{
+
-		for (unsigned int i = 0; i < nObj; i++)
+		for (unsigned int i = 0; i < nObj; i++) {
-		{
 			MDagPath dagPath;
 			MObject depNode;
 			list.getDependNode(i, depNode);
@@ -159,45 +233,51 @@ MStatus MeshInfoCmd::doIt(const MArgList & args)
 				if (fnMesh.isIntermediateObject())
 					continue;
 			}
-			/*std::vector<int> intArray;
-			intArray.resize(vertexList.length());
-			vertexList.get(&intArray[0]);*/
-			//std::copy(intArray.begin(), intArray.end(), std::ostream_iterator<int>(ss_result, ","));
 
-			/*auto SHA1 = sha1();
+			MString vtxHash, uvHash, ptHash;
-			//SHA1.add(&intArray[0], sizeof(int) * intArray.size());
-			SHA1.add(&vertexList[0], sizeof(int) * vertexList.length());
-			char hex[SHA1_HEX_SIZE];
-			SHA1.finalize().print_hex(hex);*/
 
-			//char hex[SHA1_HEX_SIZE];
-			result.append(fnMesh.name());
-			MString vtx_hash, uv_hash;
 			if (vtxHashGen || fileGen) {
-				MIntArray vertexCount, vertexList;
+				vtxHash = getVtxHash(fnMesh);
-				fnMesh.getVertices(vertexCount, vertexList);
-				vtx_hash = getHash(vertexCount, vertexList);
-				result.append(vtx_hash);
-				
 			}
 				
-			if (uvHashGen || fileGen){
+			if (uvHashGen || fileGen) {
-				MFloatArray uArray, vArray;
+				uvHash = getUvHash(fnMesh);
-				fnMesh.getUVs(uArray, vArray);
-				uv_hash = getHash(uArray, vArray);
-				result.append(uv_hash);
 			}
 
-			if (fileGen)
+			if (ptHashGen || fileGen) {
-			{
+				ptHash = getPtHash(fnMesh);
-				std::vector<std::string> hashData = { fnMesh.name().asChar(), vtx_hash.asChar(), uv_hash.asChar() };
-				meshInfo.push_back(hashData);
 			}
 			
+			if (fileGen)
+			{
+				std::vector<std::string> hashData = { 
+					fnMesh.name().asChar(), 
+					vtxHash.asChar(), uvHash.asChar(), ptHash.asChar(), 
+					std::to_string(fnMesh.numVertices()),
+					std::to_string(fnMesh.numPolygons())
+				};
+				meshInfo.push_back(hashData);
+			}
 		}
 	}
+
 	std::string meshInfo_s = meshInfo.dump(4);
-	MGlobal::displayInfo(meshInfo_s.c_str());
+
-	setResult(result);
+	if (fileGen)
+	{
+		MString filePath;
+		argData.getFlagArgument(kFileFlag, 0, filePath);
+		std::ofstream out(filePath.asChar());
+		out << meshInfo_s;
+		out.close();
+
+		char buff[1024];
+		sprintf(buff, "Mesh info file exported : %s", filePath.asChar());
+		MGlobal::displayInfo(buff);
+	}
+	else {
+		setResult(MString(meshInfo_s.c_str()));
+	}
+	
 	return status;
 }

src/MeshInfoCmd.h

@@ -8,6 +8,8 @@
 #define kVtxHashFlagLong "-vtxHash"
 #define kUvHashFlag "-uvh"
 #define kUvHashFlagLong "-uvHash"
+#define kPtHashFlag "-pth"
+#define kPtHashFlagLong "-ptHash"
 #define kExtendToShapeFlag "-ets"
 #define kExtendToShapeFlagLong "-extendToShape"
 #define kNoIntermediaFlag "-ni"
@@ -27,5 +29,9 @@ public:
 
 	MString getHash(MIntArray& arrayData1, MIntArray& arrayData2);
 	MString getHash(MFloatArray& arrayData1, MFloatArray& arrayData2);
+	MString getHash(MPointArray& arrayData);
+	MString getVtxHash(MFnMesh& fnMesh);
+	MString getUvHash(MFnMesh& fnMesh);
+	MString getPtHash(MFnMesh& fnMesh);
 	MStatus extendToShape(MSelectionList &list);
 };