private MIntArray GetMinTime() { MIntArray minTime = new MIntArray(); MGlobal.executeCommand("playbackOptions -q -animationStartTime", minTime); return(minTime); }
private static List <Material> GetMaterialsMesh(ref MFnMesh Mesh, ref MDagPath Path) { // Get materials for this mesh var Result = new List <Material>(); // Fetch data var Shaders = new MObjectArray(); var ShaderIndices = new MIntArray(); Mesh.getConnectedShaders(Path.instanceNumber, Shaders, ShaderIndices); // Iterate and add for (int i = 0; i < (int)Shaders.length; i++) { // Find plug var ShaderNode = new MFnDependencyNode(Shaders[i]); var ShaderPlug = ShaderNode.findPlug("surfaceShader"); var MatPlug = new MPlugArray(); ShaderPlug.connectedTo(MatPlug, true, false); if (MatPlug.length > 0) { Result.Add(new Material(CleanNodeName(new MFnDependencyNode(MatPlug[0].node).name))); } } return(Result); }
public static List <List <Point> > getFaceVerticies(MFnMesh mayaMesh) { List <List <Point> > faces = new List <List <Point> >(mayaMesh.numVertices); PointList verts; MPointArray mayaVerts = new MPointArray(); MIntArray ids = new MIntArray(); mayaMesh.getPoints(mayaVerts, MSpace.Space.kWorld); for (int i = 0; i < mayaMesh.numPolygons; i++) { mayaMesh.getPolygonVertices(i, ids); verts = new PointList(ids.Count); foreach (var vtxid in ids) { if (MGlobal.isZAxisUp) { verts.Add(Point.ByCoordinates(mayaVerts[vtxid].x, mayaVerts[vtxid].y, mayaVerts[vtxid].z)); } else { verts.Add(Point.ByCoordinates(mayaVerts[vtxid].x, -mayaVerts[vtxid].z, mayaVerts[vtxid].y)); } } faces.Add(verts); } return(faces); }
private MIntArray GetMaxTime() { MIntArray maxTime = new MIntArray(); MGlobal.executeCommand("playbackOptions -q -animationEndTime", maxTime); return(maxTime); }
/// <summary> /// Return true if node descendant hierarchy has any exportable Mesh, Camera, Light or Locator /// </summary> private bool isNodeRelevantToExportRec(MDagPath mDagPathRoot) { var mIteratorType = new MIteratorType(); MIntArray listOfFilters = new MIntArray(); listOfFilters.Add((int)MFn.Type.kMesh); listOfFilters.Add((int)MFn.Type.kCamera); listOfFilters.Add((int)MFn.Type.kLight); listOfFilters.Add((int)MFn.Type.kLocator); mIteratorType.setFilterList(listOfFilters); var dagIterator = new MItDag(mIteratorType, MItDag.TraversalType.kDepthFirst); dagIterator.reset(mDagPathRoot); while (!dagIterator.isDone) { MDagPath mDagPath = new MDagPath(); dagIterator.getPath(mDagPath); // Check direct descendants if (getApiTypeOfDirectDescendants(mDagPath) != MFn.Type.kUnknown) { return(true); } dagIterator.next(); } // No relevant node found among descendants return(false); }
/// <summary> /// Extract ordered indices on a triangle basis /// Extract position and normal of each vertex per face /// </summary> /// <param name="mFnMesh"></param> /// <param name="vertices"></param> /// <param name="indices"></param> /// <param name="subMeshes"></param> /// <param name="optimizeVertices"></param> private void ExtractGeometry(MFnMesh mFnMesh, List <GlobalVertex> vertices, List <int> indices, List <BabylonSubMesh> subMeshes, bool optimizeVertices) { // TODO - Multimaterials: create a BabylonSubMesh per submaterial // TODO - optimizeVertices MIntArray triangleCounts = new MIntArray(); MIntArray trianglesVertices = new MIntArray(); mFnMesh.getTriangles(triangleCounts, trianglesVertices); // For each polygon of this mesh for (int polygonId = 0; polygonId < mFnMesh.numPolygons; polygonId++) { MIntArray verticesId = new MIntArray(); int nbTriangles = triangleCounts[polygonId]; // For each triangle of this polygon for (int triangleIndex = 0; triangleIndex < triangleCounts[polygonId]; triangleIndex++) { int[] triangleVertices = new int[3]; mFnMesh.getPolygonTriangleVertices(polygonId, triangleIndex, triangleVertices); // Inverse winding order var tmp = triangleVertices[1]; triangleVertices[1] = triangleVertices[2]; triangleVertices[2] = tmp; // For each vertex of this triangle (3 vertices per triangle) foreach (int vertexId in triangleVertices) { MPoint point = new MPoint(); mFnMesh.getPoint(vertexId, point); MVector normal = new MVector(); mFnMesh.getFaceVertexNormal(polygonId, vertexId, normal); var vertex = new GlobalVertex { BaseIndex = vertexId, Position = point.toArray(), Normal = normal.toArray() }; indices.Add(vertices.Count); vertices.Add(vertex); } } } // BabylonSubMesh var subMesh = new BabylonSubMesh { indexStart = 0, materialIndex = 0 }; subMeshes.Add(subMesh); subMesh.indexCount = indices.Count; subMesh.verticesStart = 0; subMesh.verticesCount = vertices.Count; }
public apiMeshGeomUV() { faceVertexIndex = new MIntArray(); ucoord = new MFloatArray(); vcoord = new MFloatArray(); reset(); }
protected MObject createMesh(MTime time, ref MObject outData) { int numVertices, frame; float cubeSize; MFloatPointArray points = new MFloatPointArray(); MFnMesh meshFS = new MFnMesh(); // Scale the cube on the frame number, wrap every 10 frames. frame = (int)time.asUnits(MTime.Unit.kFilm); if (frame == 0) { frame = 1; } cubeSize = 0.5f * (float)(frame % 10); const int numFaces = 6; numVertices = 8; MFloatPoint vtx_1 = new MFloatPoint(-cubeSize, -cubeSize, -cubeSize); MFloatPoint vtx_2 = new MFloatPoint(cubeSize, -cubeSize, -cubeSize); MFloatPoint vtx_3 = new MFloatPoint(cubeSize, -cubeSize, cubeSize); MFloatPoint vtx_4 = new MFloatPoint(-cubeSize, -cubeSize, cubeSize); MFloatPoint vtx_5 = new MFloatPoint(-cubeSize, cubeSize, -cubeSize); MFloatPoint vtx_6 = new MFloatPoint(-cubeSize, cubeSize, cubeSize); MFloatPoint vtx_7 = new MFloatPoint(cubeSize, cubeSize, cubeSize); MFloatPoint vtx_8 = new MFloatPoint(cubeSize, cubeSize, -cubeSize); points.append(vtx_1); points.append(vtx_2); points.append(vtx_3); points.append(vtx_4); points.append(vtx_5); points.append(vtx_6); points.append(vtx_7); points.append(vtx_8); // Set up an array containing the number of vertices // for each of the 6 cube faces (4 verticies per face) // int[] face_counts = { 4, 4, 4, 4, 4, 4 }; MIntArray faceCounts = new MIntArray(face_counts); // Set up and array to assign vertices from points to each face // int[] face_connects = { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4, 0, 4, 7, 1, 1, 7, 6, 2 }; MIntArray faceConnects = new MIntArray(face_connects); MObject newMesh = meshFS.create(numVertices, numFaces, points, faceCounts, faceConnects, outData); return(newMesh); }
public polyPrimitive() { iarr = new MFloatPointArray(); pa = new MFloatPointArray(); faceCounts = new MIntArray(); faceConnects = new MIntArray(); dagMod = new MDagModifier(); MGlobal.displayInfo("test polyPrimitive."); }
public static bool ContainsHoles(this MFnMesh mesh) { MIntArray holeInfoArray = new MIntArray(); MIntArray holeVertexArray = new MIntArray(); mesh.getHoles(holeInfoArray, holeVertexArray); return(holeInfoArray.length != 0); }
public apiMeshGeom() { vertices = new MPointArray(); face_counts = new MIntArray(); face_connects = new MIntArray(); normals = new MVectorArray(); uvcoords = new apiMeshGeomUV(); faceCount = 0; }
private void computeMeshData() { foreach (MayaMesh mesh in allMeshes) { // Get the Maya mesh MFnMesh mayaMesh = new MFnMesh(mesh.mayaObjectPath); // Does the maya mesh have UVs? MStringArray uvSetNames = new MStringArray(); mayaMesh.getUVSetNames(uvSetNames); bool hasUvs = (uvSetNames.length > 0) && (mayaMesh.numUVs(uvSetNames[0]) > 0); // Iterate through all of the vertices and build the data. MItMeshFaceVertex it = new MItMeshFaceVertex(mesh.mayaObjectPath); while (!it.isDone) { // Create a new vertex and populate its data. Vertex vert = new Vertex(); // Get the local position relative to the world origin. MPoint mayaPos = it.position(MSpace.Space.kObject); vert.position = new Vector3((float)mayaPos.x, (float)mayaPos.y, (float)mayaPos.z); //vert.position = new Vector3((float)mayaPos.x - mesh.sourceXForm.mayaWorldPosition.x, //(float)mayaPos.y - mesh.sourceXForm.mayaWorldPosition.y, //(float)mayaPos.z - mesh.sourceXForm.mayaWorldPosition.z); // Get the normal. MVector mayaNrm = new MVector(); it.getNormal(mayaNrm, MSpace.Space.kObject); vert.normal = new Vector3((float)mayaNrm.x, (float)mayaNrm.y, (float)mayaNrm.z); // Texcoords. if (hasUvs && it.hasUVsProperty) { float[] mayaUvs = new float[2]; it.getUV(mayaUvs, uvSetNames[0]); vert.texcoord = new Vector2(mayaUvs[0], mayaUvs[1]); } // Append the vertex. mesh.vertices.Add(vert); it.next(); } // Get all index data. MIntArray mia1 = new MIntArray(); MIntArray mia2 = new MIntArray(); mayaMesh.getTriangleOffsets(mia1, mia2); foreach (int idx in mia2) { mesh.indices.Add((uint)idx); } } }
public static bool CombineMeshes(List <MFnMesh> meshes, bool smartMergeEdge = false) { for (int i = 0; i < meshes.Count; i++) { MFnMesh m = new MFnMesh(); MIntArray vertCounts = new MIntArray(), indiceLists = new MIntArray(); meshes[i].getVertices(vertCounts, indiceLists); } return(false); }
public TriangleMeshAdapater(MFnMesh mesh) { MIntArray indices = new MIntArray(); MIntArray triangleCounts = new MIntArray(); MPointArray points = new MPointArray(); mesh.getTriangles(triangleCounts, indices); mesh.getPoints(points); // Get the triangle indices Indices = new Int32Collection((int)indices.length); for (int i = 0; i < indices.length; ++i) { Indices.Add(indices[i]); } // Get the control points (vertices) Points = new Point3DCollection((int)points.length); for (int i = 0; i < (int)points.length; ++i) { MPoint pt = points[i]; Points.Add(new Point3D(pt.x, pt.y, pt.z)); } // Get the number of triangle faces and polygon faces Debug.Assert(indices.length % 3 == 0); int triFaces = (int)indices.length / 3; int polyFaces = mesh.numPolygons; // We have normals per polygon, we want one per triangle. Normals = new Vector3DCollection(triFaces); int nCurrentTriangle = 0; // Iterate over each polygon for (int i = 0; i < polyFaces; ++i) { // Get the polygon normal var maya_normal = new MVector(); mesh.getPolygonNormal((int)i, maya_normal); System.Windows.Media.Media3D.Vector3D normal = new System.Windows.Media.Media3D.Vector3D(maya_normal.x, maya_normal.y, maya_normal.z); // Iterate over each tri in the current polygon int nTrisAtFace = triangleCounts[i]; for (int j = 0; j < nTrisAtFace; ++j) { Debug.Assert(nCurrentTriangle < triFaces); Normals.Add(normal); nCurrentTriangle++; } } Debug.Assert(nCurrentTriangle == triFaces); }
public static List <object> MelCommand(string MelCommand) { MStringArray stringResults = new MStringArray(); MIntArray intResults = new MIntArray(); MDoubleArray doubleResults = new MDoubleArray(); MVectorArray vectorResults = new MVectorArray(); List <object> results = new List <object>(); MCommandResult mcr = new MCommandResult(); MDagPath dag = new MDagPath(); try { MGlobal.executeCommand(MelCommand, mcr); // MGlobal.executeCommand(MelCommand, stringResults); } catch (MemberAccessException e) { MGlobal.displayWarning(e.Message); } switch (mcr.resultType) { case MCommandResult.Type.kStringArray: mcr.getResult(stringResults); results.AddRange(stringResults); break; case MCommandResult.Type.kIntArray: mcr.getResult(intResults); results.AddRange(intResults.Cast <object>()); break; case MCommandResult.Type.kDoubleArray: mcr.getResult(doubleResults); results.AddRange(doubleResults.Cast <object>()); break; case MCommandResult.Type.kVectorArray: mcr.getResult(vectorResults); results.AddRange(vectorResults.Cast <object>()); break; default: mcr.getResult(stringResults); results.AddRange(stringResults); break; } mcr.Dispose(); return(results); }
/// <summary> /// Extract the vertices, normals and triangles of a mesh into the M2 collision data fields. /// </summary> /// <param name="wowModel"></param> private static void InjectCollisionMesh(M2 wowModel) { var collisionFound = false; for (var meshIter = new MItDag(MItDag.TraversalType.kDepthFirst, MFn.Type.kMesh); !meshIter.isDone; meshIter.next()) { var meshPath = new MDagPath(); meshIter.getPath(meshPath); var meshFn = new MFnMesh(meshPath); // only want non-history items if (meshFn.isIntermediateObject) { continue; } var name = meshFn.name; if (name != "Collision") { continue; //TODO use custom attribute } if (collisionFound) { throw new Exception("More than one collision box has been found. One supported."); } MGlobal.displayInfo("\t Collision mesh detected."); wowModel.CollisionBox = new CAaBox(AxisInvert(meshFn.boundingBox.min), AxisInvert(meshFn.boundingBox.max)); wowModel.CollisionSphereRadius = (float)Math.Max(meshFn.boundingBox.depth / 2, meshFn.boundingBox.width / 2); //TODO fixme better iterate through faces var collisionPoints = new MFloatPointArray(); meshFn.getPoints(collisionPoints, MSpace.Space.kWorld); var collisionNormals = new MFloatVectorArray(); meshFn.getNormals(collisionNormals, MSpace.Space.kWorld); var collisionTriangles = new MIntArray(); meshFn.getTriangles(new MIntArray(), collisionTriangles); for (var i = 0; i < collisionPoints.Count; i++) { wowModel.CollisionVertices.Add(AxisInvert(collisionPoints[i])); wowModel.CollisionNormals.Add(AxisInvert(collisionNormals[i])); } foreach (var vertIndex in collisionTriangles) { wowModel.CollisionTriangles.Add((ushort)vertIndex); } collisionFound = true; } }
public static int[][] getFaceVertId(MFnMesh mayaMesh) { List <int[]> vtxIds = new List <int[]>(mayaMesh.numPolygons); MIntArray ids = new MIntArray(); for (int i = 0; i < mayaMesh.numPolygons; i++) { mayaMesh.getPolygonVertices(i, ids); vtxIds.Add(ids.ToArray()); } return(vtxIds.ToArray()); }
private static void unpackDynMesh(Mesh dynMesh, out MIntArray faceCnx, out MFloatPointArray verticies, out MIntArray faceVtxCt) { MIntArray m_faceCnx = new MIntArray(); MFloatPointArray m_verticies = new MFloatPointArray(); MIntArray m_faceVtxCt = new MIntArray(); MFloatPoint vtxToAdd = new MFloatPoint(); foreach (var vtx in dynMesh.VertexPositions) { if (MGlobal.isZAxisUp) { vtxToAdd.x = (float)vtx.X; vtxToAdd.y = (float)vtx.Y; vtxToAdd.z = (float)vtx.Z; } else { vtxToAdd.x = (float)vtx.X; vtxToAdd.y = (float)vtx.Z; vtxToAdd.z = -(float)vtx.Y; } m_verticies.Add(vtxToAdd); } foreach (var fidx in dynMesh.FaceIndices) { int vtxCt = (int)fidx.Count; m_faceVtxCt.Add(vtxCt); if (vtxCt == 3) { m_faceCnx.Add((int)fidx.A); m_faceCnx.Add((int)fidx.B); m_faceCnx.Add((int)fidx.C); } else { m_faceCnx.Add((int)fidx.A); m_faceCnx.Add((int)fidx.B); m_faceCnx.Add((int)fidx.C); m_faceCnx.Add((int)fidx.D); } } verticies = m_verticies; faceCnx = m_faceCnx; faceVtxCt = m_faceVtxCt; }
public TriangleMeshAdapater(MFnMesh mesh) { MIntArray indices = new MIntArray(); MIntArray triangleCounts = new MIntArray(); MPointArray points = new MPointArray(); mesh.getTriangles(triangleCounts, indices); mesh.getPoints(points); // Get the triangle indices Indices = new Int32Collection((int)indices.length); for (int i = 0; i < indices.length; ++i) Indices.Add(indices[i]); // Get the control points (vertices) Points = new Point3DCollection((int)points.length); for (int i = 0; i < (int)points.length; ++i) { MPoint pt = points[i]; Points.Add(new Point3D(pt.x, pt.y, pt.z)); } // Get the number of triangle faces and polygon faces Debug.Assert(indices.length % 3 == 0); int triFaces = (int)indices.length / 3; int polyFaces = mesh.numPolygons; // We have normals per polygon, we want one per triangle. Normals = new Vector3DCollection(triFaces); int nCurrentTriangle = 0; // Iterate over each polygon for (int i = 0; i < polyFaces; ++i) { // Get the polygon normal var maya_normal = new MVector(); mesh.getPolygonNormal((int)i, maya_normal); System.Windows.Media.Media3D.Vector3D normal = new System.Windows.Media.Media3D.Vector3D(maya_normal.x, maya_normal.y, maya_normal.z); // Iterate over each tri in the current polygon int nTrisAtFace = triangleCounts[i]; for (int j = 0; j < nTrisAtFace; ++j) { Debug.Assert(nCurrentTriangle < triFaces); Normals.Add(normal); nCurrentTriangle++; } } Debug.Assert(nCurrentTriangle == triFaces); }
private void ValidateMeshTopology(MFnMesh mesh, MDagPath meshDagPath, MIntArray polygonShaderIndices, ref MIntArray vertexShaders, uint shaderCount) { //Check if the mesh contains holes MIntArray holeInfoArray = new MIntArray(); MIntArray holeVertexArray = new MIntArray(); mesh.getHoles(holeInfoArray, holeVertexArray); if (holeInfoArray.length != 0) { MGlobal.displayError("SKNFile:Create - Mesh contains holes"); throw new Exception("SKNFile:Create - Mesh contains holes"); } //Check for non-Triangulated polygons and shared shaders vertexShaders = new MIntArray((uint)mesh.numVertices, -1); MItMeshPolygon polygonIterator = new MItMeshPolygon(meshDagPath); for (polygonIterator.reset(); !polygonIterator.isDone; polygonIterator.next()) { if (!polygonIterator.hasValidTriangulation) { MGlobal.displayError("SKNFile:Create - Mesh contains a non-Triangulated polygon"); throw new Exception("SKNFile:Create - Mesh contains a non-Triangulated polygon"); } int shaderIndex = polygonShaderIndices[(int)polygonIterator.index()]; MIntArray vertices = new MIntArray(); polygonIterator.getVertices(vertices); if (shaderIndex == -1) { MGlobal.displayError("SKNFile:Create - Mesh contains a face with no shader"); throw new Exception("SKNFile:Create - Mesh contains a face with no shader"); } for (int i = 0; i < vertices.length; i++) { if (shaderCount > 1 && vertexShaders[vertices[i]] != -1 && shaderIndex != vertexShaders[vertices[i]]) { MGlobal.displayError("SKNFile:Create - Mesh contains a vertex with multiple sahders"); throw new Exception("SKNFile:Create - Mesh contains a vertex with multiple sahders"); } else { vertexShaders[vertices[i]] = shaderIndex; } } } }
internal static Mesh MTDMeshFromMayaMesh(MFnMesh mayaMesh, MSpace.Space space) { PointList vertices = new PointList(mayaMesh.numVertices); ; List <IndexGroup> faceIndexList = new List <IndexGroup>(mayaMesh.numPolygons); MPointArray mayaVerts = new MPointArray(); mayaMesh.getPoints(mayaVerts, space); if (MGlobal.isYAxisUp) { vertices.AddRange(mayaVerts.Select(v => Point.ByCoordinates(v.x, -v.z, v.y))); } else { vertices.AddRange(mayaVerts.Select(v => Point.ByCoordinates(v.x, v.y, v.z))); } MIntArray faceIndex = new MIntArray(); for (int i = 0; i < mayaMesh.numPolygons; i++) { mayaMesh.getPolygonVertices(i, faceIndex); if (faceIndex.length > 4) { WarningException wa = new WarningException("The DynMesh will not show in Dynamo if it has any faces with 4 verts or more. The DynMesh can be represented as closed curves ."); return(null); } if (faceIndex.length == 3) { faceIndexList.Add(IndexGroup.ByIndices((uint)faceIndex[0], (uint)faceIndex[1], (uint)faceIndex[2])); } else { faceIndexList.Add(IndexGroup.ByIndices((uint)faceIndex[0], (uint)faceIndex[1], (uint)faceIndex[2], (uint)faceIndex[3])); } } mayaMesh.Dispose(); mayaVerts.Dispose(); faceIndex.Dispose(); using (vertices) { return(Mesh.ByPointsFaceIndices(vertices, faceIndexList)); } }
/// <summary> /// Extract all shaders (M2Batch) linked to a mesh. /// </summary> private static void ExtractMeshShaders(MayaM2Mesh mesh, MDagPath meshPath) { MGlobal.displayInfo("Looking for shaders in mesh " + meshPath.fullPathName); var meshFn = new MFnMesh(meshPath); // get the number of instances var numInstances = meshFn.parentCount; MGlobal.displayInfo("\t" + numInstances + " instances."); // loop through each instance of the mesh for (uint i = 0; i < numInstances; ++i) { // attach a function set to this instances parent transform //var fn = new MFnDependencyNode(fnMesh.parent(i)); // this will hold references to the shaders used on the meshes var shaderEngines = new MObjectArray(); // this is used to hold indices to the materials returned in the object array var faceIndices = new MIntArray(); // get the shaders used by the i'th mesh instance meshFn.getConnectedShaders(i, shaderEngines, faceIndices); switch (shaderEngines.length) { // if no shader applied to the mesh instance case 0: break; // if all faces use the same material case 1: var materials = GetMaterials(shaderEngines[0]); MGlobal.displayInfo("\t\tIn shaderEngine[0], found " + materials.length + " materials."); //TODO Extract Material data ExtractMaterial(mesh, materials[0]); //TODO Extract Transparency data //TODO Shader break; //Multiple materials, each applied only on some faces. default: throw new NotImplementedException("Cannot handle more than one shaderEngine per mesh."); } } }
public MObject ConvertMeshMaya(TriMesh triMesh) { MFnMesh meshMaya = new MFnMesh(); int verticeNum = triMesh.Vertices.Count; MFloatPointArray points = new MFloatPointArray(); for (int i = 0; i < verticeNum; i++) { float x = (float)triMesh.Vertices[i].Traits.Position.x; float y = (float)triMesh.Vertices[i].Traits.Position.y; float z = (float)triMesh.Vertices[i].Traits.Position.z; MFloatPoint vertex = new MFloatPoint(x, y, z); points.append(vertex); } int faceNum = triMesh.Faces.Count; int[] face_Counts = new int[faceNum]; for (int i = 0; i < faceNum; i++) { face_Counts[i] = 3; } MIntArray faceCounts = new MIntArray(face_Counts); int[] faceTopology = new int[faceNum * 3]; for (int j = 0; j < faceNum; j++) { int index = j * 3; faceTopology[index] = triMesh.Faces[j].GetVertex(0).Index; faceTopology[index + 1] = triMesh.Faces[j].GetVertex(1).Index; faceTopology[index + 2] = triMesh.Faces[j].GetVertex(2).Index; } MIntArray faceConnects = new MIntArray(faceTopology); MObject mesh = meshMaya.create(verticeNum, faceNum, points, faceCounts, faceConnects); return(mesh); }
/// <summary> /// Get the local indices from mesh relative triangle indices obtained with MItMeshPolygon.getTriangle(). /// Original C++ script by Bruno 'Beosil' Heidelberger and Thomas Cowell. /// </summary> /// <param name="polyMeshRelative"></param> /// <param name="triMeshRelative"></param> /// <returns>A list of 3 face-relative indices each.</returns> private static MIntArray GetLocalTriangle(MIntArray polyMeshRelative, MIntArray triMeshRelative) { Debug.Assert(triMeshRelative.Count == 3); var result = new MIntArray(); foreach (var vertMeshIndex in triMeshRelative) { for (var gv = 0; gv < polyMeshRelative.Count; gv++) { if (polyMeshRelative[gv] != vertMeshIndex) { continue; } result.Add(gv); break; } } return(result); }
private static void unpackTsMesh(TSplineSurface tsMesh, out MIntArray faceCnx, out MFloatPointArray verticies, out MIntArray faceVtxCt) { MIntArray m_faceCnx = new MIntArray(); MFloatPointArray m_verticies = new MFloatPointArray(); MIntArray m_faceVtxCt = new MIntArray(); MFloatPoint vtxToAdd = new MFloatPoint(); var tsMeshCompress = tsMesh.CompressIndexes(); foreach (var vtx in tsMeshCompress.Vertices) { if (MGlobal.isZAxisUp) { vtxToAdd.x = (float)vtx.PointGeometry.X; vtxToAdd.y = (float)vtx.PointGeometry.Y; vtxToAdd.z = (float)vtx.PointGeometry.Z; } else { vtxToAdd.x = (float)vtx.PointGeometry.X; vtxToAdd.y = (float)vtx.PointGeometry.Z; vtxToAdd.z = -(float)vtx.PointGeometry.Y; } m_verticies.Add(vtxToAdd); } foreach (var fidx in tsMeshCompress.Faces) { int vtxCt = fidx.Vertices.Length; m_faceVtxCt.Add(vtxCt); foreach (var fVert in fidx.Vertices) { m_faceCnx.Add(fVert.Index); } } verticies = m_verticies; faceCnx = m_faceCnx; faceVtxCt = m_faceVtxCt; }
public static List <int[]> GetFaceVertexIdx(string dagName, string space) { MDagPath dagPath = DMInterop.getDagNode(dagName); MSpace.Space mspace = MSpace.Space.kWorld; Enum.TryParse(space, out mspace); MFnMesh mayaMesh = new MFnMesh(dagPath); List <int[]> vtxIds = new List <int[]>(mayaMesh.numPolygons); MIntArray ids = new MIntArray(); for (int i = 0; i < mayaMesh.numPolygons; i++) { mayaMesh.getPolygonVertices(i, ids); vtxIds.Add(ids.ToArray()); } return(vtxIds); }
public TriMesh ConvertTriMesh(MFnMesh mesh) { if (mesh == null) { MGlobal.displayInfo("Mesh is null \n"); } TriMesh trimesh = new TriMesh(); MIntArray indices = new MIntArray(); MIntArray triangleCounts = new MIntArray(); MPointArray points = new MPointArray(); mesh.getTriangles(triangleCounts, indices); mesh.getPoints(points); // Get the triangle indices for (int i = 0; i < (int)points.length; ++i) { MPoint pt = points[i]; VertexTraits trait = new VertexTraits(pt.x, pt.y, pt.z); trimesh.Vertices.Add(trait); } MGlobal.displayInfo(indices.Count.ToString() + "\n"); int j = 0; while (j < indices.Count) { int a = indices[j]; j++; int b = indices[j]; j++; int c = indices[j]; j++; trimesh.Faces.AddTriangles(trimesh.Vertices[a], trimesh.Vertices[b], trimesh.Vertices[c]); } return(trimesh); }
public static List <Surface> meshToNurbs(MFnMesh mayaMesh) { MFnSubd subDmesh = new MFnSubd(); subDmesh.isIntermediateObject = true; MPointArray mayaVerts = new MPointArray(); mayaMesh.getPoints(mayaVerts, MSpace.Space.kWorld); MIntArray polyVertct = new MIntArray(); MIntArray ids = new MIntArray(); MIntArray idList = new MIntArray(); for (int i = 0; i < mayaMesh.numPolygons; i++) { mayaMesh.getPolygonVertices(i, ids); foreach (var id in ids) { idList.Add(id); } polyVertct.Add(ids.Count); } subDmesh.createBaseMesh(false, mayaMesh.numVertices, mayaMesh.numPolygons, mayaVerts, polyVertct, idList); try { MUintArray creaseEdgId = new MUintArray(); MDoubleArray creaseEdgeVal = new MDoubleArray(); mayaMesh.getCreaseEdges(creaseEdgId, creaseEdgeVal); foreach (var edgId in creaseEdgId) { subDmesh.edgeSetCrease(edgId, true); } } catch {} try { MUintArray creaseVertId = new MUintArray(); MDoubleArray creaseVertVal = new MDoubleArray(); mayaMesh.getCreaseVertices(creaseVertId, creaseVertVal); foreach (var vertId in creaseVertId) { subDmesh.vertexSetCrease(vertId, true); } } catch { } subDmesh.updateAllEditsAndCreases(); MObjectArray nurbsSurfs = new MObjectArray(); subDmesh.convertToNurbs(nurbsSurfs); List <MFnNurbsSurface> mfnSurfaceList = new List <MFnNurbsSurface>(nurbsSurfs.Count); foreach (var surf in nurbsSurfs) { mfnSurfaceList.Add(new MFnNurbsSurface(surf)); } List <Surface> dynSurfaceList = new List <Surface>(mfnSurfaceList.Count); foreach (var mfnNS in mfnSurfaceList) { dynSurfaceList.Add(DMSurface.mNurbsSurfaceToDynamoSurface(mfnNS, MSpace.Space.kObject)); } MGlobal.deleteNode(subDmesh.model); return(dynSurfaceList); }
// // Description // // This function takes an input surface of type kMeshData and converts // the geometry into this nodes attributes. // Returns false if nothing is connected. // public bool computeInputMesh(MPlug plug, MDataBlock datablock, MPointArray vertices, MIntArray counts, MIntArray connects, MVectorArray normals, apiMeshGeomUV uvs) { // Get the input subdiv // MDataHandle inputData = datablock.inputValue( inputMesh ); MObject surf = inputData.asMesh; // Check if anything is connected // MObject thisObj = thisMObject(); MPlug surfPlug = new MPlug( thisObj, inputMesh ); if ( !surfPlug.isConnected ) { datablock.setClean( plug ); return false; } // Extract the mesh data // MFnMesh surfFn = new MFnMesh(surf); surfFn.getPoints( vertices, MSpace.Space.kObject ); // Check to see if we have UVs to copy. // bool hasUVs = surfFn.numUVsProperty > 0; surfFn.getUVs( uvs.ucoord, uvs.vcoord ); for ( int i=0; i<surfFn.numPolygons; i++ ) { MIntArray polyVerts = new MIntArray(); surfFn.getPolygonVertices( i, polyVerts ); int pvc = (int)polyVerts.length; counts.append( pvc ); int uvId; for ( int v=0; v<pvc; v++ ) { if ( hasUVs ) { surfFn.getPolygonUVid( i, v, out uvId ); uvs.faceVertexIndex.append( uvId ); } connects.append( polyVerts[v] ); } } for ( int n=0; n<(int)vertices.length; n++ ) { MVector normal = new MVector(); surfFn.getVertexNormal( n, normal ); normals.append( normal ); } return true; }
// // Description // // Constructs a cube // public void buildCube(double cube_size, MPointArray pa, MIntArray faceCounts, MIntArray faceConnects, MVectorArray normals, apiMeshGeomUV uvs) { const int num_faces = 6; const int num_face_connects = 24; const double normal_value = 0.5775; const int uv_count = 14; pa.clear(); faceCounts.clear(); faceConnects.clear(); uvs.reset(); pa.append( new MPoint( -cube_size, -cube_size, -cube_size ) ); pa.append( new MPoint( cube_size, -cube_size, -cube_size ) ); pa.append( new MPoint( cube_size, -cube_size, cube_size ) ); pa.append( new MPoint( -cube_size, -cube_size, cube_size ) ); pa.append( new MPoint( -cube_size, cube_size, -cube_size ) ); pa.append( new MPoint( -cube_size, cube_size, cube_size ) ); pa.append( new MPoint( cube_size, cube_size, cube_size ) ); pa.append( new MPoint( cube_size, cube_size, -cube_size ) ); normals.append( new MVector( -normal_value, -normal_value, -normal_value ) ); normals.append( new MVector( normal_value, -normal_value, -normal_value ) ); normals.append( new MVector( normal_value, -normal_value, normal_value ) ); normals.append( new MVector( -normal_value, -normal_value, normal_value ) ); normals.append( new MVector( -normal_value, normal_value, -normal_value ) ); normals.append( new MVector( -normal_value, normal_value, normal_value ) ); normals.append( new MVector( normal_value, normal_value, normal_value ) ); normals.append( new MVector( normal_value, normal_value, -normal_value ) ); // Define the UVs for the cube. // float[] uv_pts = new float[uv_count*2] { 0.375f, 0.0f, 0.625f, 0.0f, 0.625f, 0.25f, 0.375f, 0.25f, 0.625f, 0.5f, 0.375f, 0.5f, 0.625f, 0.75f, 0.375f, 0.75f, 0.625f, 1.0f, 0.375f, 1.0f, 0.875f, 0.0f, 0.875f, 0.25f, 0.125f, 0.0f, 0.125f, 0.25f }; // UV Face Vertex Id. // int[] uv_fvid = new int[num_face_connects]{ 0, 1, 2, 3, 3, 2, 4, 5, 5, 4, 6, 7, 7, 6, 8, 9, 1, 10, 11, 2, 12, 0, 3, 13 }; int i; for ( i = 0; i < uv_count; i ++ ) { uvs.append_uv( uv_pts[i*2], uv_pts[i*2 + 1] ); } for ( i = 0; i < num_face_connects; i ++ ) { uvs.faceVertexIndex.append( uv_fvid[i] ); } // Set up an array containing the number of vertices // for each of the 6 cube faces (4 vertices per face) // int[] face_counts = new int[num_faces]{ 4, 4, 4, 4, 4, 4 }; for ( i=0; i<num_faces; i++ ) { faceCounts.append( face_counts[i] ); } // Set up and array to assign vertices from pa to each face // int[] face_connects = new int[ num_face_connects ]{ 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4, 0, 4, 7, 1, 1, 7, 6, 2 }; for ( i=0; i<num_face_connects; i++ ) { faceConnects.append( face_connects[i] ); } }
public void Load(string name) { List <StaticObjectVertex> vertices = GetVertices(); List <uint> indices = GetIndices(); MIntArray polygonIndexCounts = new MIntArray((uint)indices.Count / 3); MIntArray polygonIndices = new MIntArray((uint)indices.Count); MFloatPointArray meshVertices = new MFloatPointArray((uint)vertices.Count); MFloatArray arrayU = new MFloatArray((uint)vertices.Count); MFloatArray arrayV = new MFloatArray((uint)vertices.Count); MFnMesh mesh = new MFnMesh(); MDagPath meshDagPath = new MDagPath(); MDGModifier modifier = new MDGModifier(); MFnSet set = new MFnSet(); for (int i = 0; i < indices.Count / 3; i++) { polygonIndexCounts[i] = 3; } for (int i = 0; i < indices.Count; i++) { polygonIndices[i] = (int)indices[i]; } for (int i = 0; i < vertices.Count; i++) { StaticObjectVertex vertex = vertices[i]; meshVertices[i] = new MFloatPoint(vertex.Position.X, vertex.Position.Y, vertex.Position.Z); arrayU[i] = vertex.UV.X; arrayV[i] = 1 - vertex.UV.Y; } //Assign mesh data mesh.create(vertices.Count, indices.Count / 3, meshVertices, polygonIndexCounts, polygonIndices, arrayU, arrayV, MObject.kNullObj); mesh.getPath(meshDagPath); mesh.assignUVs(polygonIndexCounts, polygonIndices); //Set names mesh.setName(name); MFnTransform transformNode = new MFnTransform(mesh.parent(0)); transformNode.setName("transform_" + name); //Get render partition MFnPartition renderPartition = MayaHelper.FindRenderPartition(); //Create Materials uint startIndex = 0; for (int i = 0; i < this.Submeshes.Count; i++) { MFnDependencyNode dependencyNode = new MFnDependencyNode(); MFnLambertShader lambertShader = new MFnLambertShader(); StaticObjectSubmesh submesh = this.Submeshes[i]; lambertShader.create(true); lambertShader.setName(submesh.Name); lambertShader.color = MaterialProvider.GetMayaColor(i); MObject shadingEngine = dependencyNode.create("shadingEngine", submesh.Name + "_SG"); MObject materialInfo = dependencyNode.create("materialInfo", submesh.Name + "_MaterialInfo"); MPlug partitionPlug = new MFnDependencyNode(shadingEngine).findPlug("partition"); MPlug setsPlug = MayaHelper.FindFirstNotConnectedElement(renderPartition.findPlug("sets")); modifier.connect(partitionPlug, setsPlug); MPlug outColorPlug = lambertShader.findPlug("outColor"); MPlug surfaceShaderPlug = new MFnDependencyNode(shadingEngine).findPlug("surfaceShader"); modifier.connect(outColorPlug, surfaceShaderPlug); MPlug messagePlug = new MFnDependencyNode(shadingEngine).findPlug("message"); MPlug shadingGroupPlug = new MFnDependencyNode(materialInfo).findPlug("shadingGroup"); modifier.connect(messagePlug, shadingGroupPlug); modifier.doIt(); MFnSingleIndexedComponent component = new MFnSingleIndexedComponent(); MObject faceComponent = component.create(MFn.Type.kMeshPolygonComponent); MIntArray groupPolygonIndices = new MIntArray(); uint endIndex = (startIndex + (uint)submesh.Indices.Count) / 3; for (uint j = startIndex / 3; j < endIndex; j++) { groupPolygonIndices.append((int)j); } component.addElements(groupPolygonIndices); set.setObject(shadingEngine); set.addMember(meshDagPath, faceComponent); startIndex += (uint)submesh.Indices.Count; } mesh.updateSurface(); }
private void computeMeshData() { foreach( MayaMesh mesh in allMeshes ) { // Get the Maya mesh MFnMesh mayaMesh = new MFnMesh(mesh.mayaObjectPath); // Does the maya mesh have UVs? MStringArray uvSetNames = new MStringArray(); mayaMesh.getUVSetNames(uvSetNames); bool hasUvs = (uvSetNames.length > 0) && (mayaMesh.numUVs(uvSetNames[0]) > 0); // Iterate through all of the vertices and build the data. MItMeshFaceVertex it = new MItMeshFaceVertex(mesh.mayaObjectPath); while( !it.isDone ) { // Create a new vertex and populate its data. Vertex vert = new Vertex(); // Get the local position relative to the world origin. MPoint mayaPos = it.position(MSpace.Space.kObject); vert.position = new Vector3((float)mayaPos.x, (float)mayaPos.y, (float)mayaPos.z); //vert.position = new Vector3((float)mayaPos.x - mesh.sourceXForm.mayaWorldPosition.x, //(float)mayaPos.y - mesh.sourceXForm.mayaWorldPosition.y, //(float)mayaPos.z - mesh.sourceXForm.mayaWorldPosition.z); // Get the normal. MVector mayaNrm = new MVector(); it.getNormal(mayaNrm, MSpace.Space.kObject); vert.normal = new Vector3((float)mayaNrm.x, (float)mayaNrm.y, (float)mayaNrm.z); // Texcoords. if( hasUvs && it.hasUVsProperty ) { float[] mayaUvs = new float[2]; it.getUV(mayaUvs, uvSetNames[0]); vert.texcoord = new Vector2(mayaUvs[0], mayaUvs[1]); } // Append the vertex. mesh.vertices.Add(vert); it.next(); } // Get all index data. MIntArray mia1 = new MIntArray(); MIntArray mia2 = new MIntArray(); mayaMesh.getTriangleOffsets(mia1, mia2); foreach( int idx in mia2 ) { mesh.indices.Add((uint)idx); } } }
/// <summary> /// Extract ordered indices on a triangle basis /// Extract position and normal of each vertex per face /// </summary> /// <param name="mFnMesh"></param> /// <param name="vertices"></param> /// <param name="indices"></param> /// <param name="subMeshes"></param> /// <param name="uvSetNames"></param> /// <param name="isUVExportSuccess"></param> /// <param name="optimizeVertices"></param> private void ExtractGeometry(MFnMesh mFnMesh, List <GlobalVertex> vertices, List <int> indices, List <BabylonSubMesh> subMeshes, MStringArray uvSetNames, ref bool[] isUVExportSuccess, bool optimizeVertices) { // TODO - optimizeVertices MIntArray triangleCounts = new MIntArray(); MIntArray trianglesVertices = new MIntArray(); mFnMesh.getTriangles(triangleCounts, trianglesVertices); MObjectArray shaders = new MObjectArray(); MIntArray faceMatIndices = new MIntArray(); // given a face index => get a shader index mFnMesh.getConnectedShaders(0, shaders, faceMatIndices); // Export geometry even if an error occured with shaders // This is a fix for Maya test files // TODO - Find the reason why shaders.count = 0 int nbShaders = Math.Max(1, shaders.Count); bool checkShader = nbShaders == shaders.Count; RaiseVerbose("shaders.Count=" + shaders.Count, 2); // For each material of this mesh for (int indexShader = 0; indexShader < nbShaders; indexShader++) { var nbIndicesSubMesh = 0; var minVertexIndexSubMesh = int.MaxValue; var maxVertexIndexSubMesh = int.MinValue; var subMesh = new BabylonSubMesh { indexStart = indices.Count, materialIndex = indexShader }; // For each polygon of this mesh for (int polygonId = 0; polygonId < faceMatIndices.Count; polygonId++) { if (checkShader && faceMatIndices[polygonId] != indexShader) { continue; } // The object-relative (mesh-relative/global) vertex indices for this face MIntArray polygonVertices = new MIntArray(); mFnMesh.getPolygonVertices(polygonId, polygonVertices); // For each triangle of this polygon for (int triangleId = 0; triangleId < triangleCounts[polygonId]; triangleId++) { int[] polygonTriangleVertices = new int[3]; mFnMesh.getPolygonTriangleVertices(polygonId, triangleId, polygonTriangleVertices); /* * Switch coordinate system at global level * * Piece of code kept just in case * See BabylonExporter for more information */ //// Inverse winding order to flip faces //var tmp = triangleVertices[1]; //triangleVertices[1] = triangleVertices[2]; //triangleVertices[2] = tmp; // For each vertex of this triangle (3 vertices per triangle) foreach (int vertexIndexGlobal in polygonTriangleVertices) { // Get the face-relative (local) vertex id int vertexIndexLocal = 0; for (vertexIndexLocal = 0; vertexIndexLocal < polygonVertices.Count; vertexIndexLocal++) { if (polygonVertices[vertexIndexLocal] == vertexIndexGlobal) { break; } } GlobalVertex vertex = ExtractVertex(mFnMesh, polygonId, vertexIndexGlobal, vertexIndexLocal, uvSetNames, ref isUVExportSuccess); vertex.CurrentIndex = vertices.Count; indices.Add(vertex.CurrentIndex); vertices.Add(vertex); minVertexIndexSubMesh = Math.Min(minVertexIndexSubMesh, vertex.CurrentIndex); maxVertexIndexSubMesh = Math.Max(maxVertexIndexSubMesh, vertex.CurrentIndex); nbIndicesSubMesh++; } } } if (nbIndicesSubMesh != 0) { subMesh.indexCount = nbIndicesSubMesh; subMesh.verticesStart = minVertexIndexSubMesh; subMesh.verticesCount = maxVertexIndexSubMesh - minVertexIndexSubMesh + 1; subMeshes.Add(subMesh); } } }
protected MObject createMesh(MTime time, ref MObject outData) { int numVertices, frame; float cubeSize; MFloatPointArray points = new MFloatPointArray(); MFnMesh meshFS = new MFnMesh(); // Scale the cube on the frame number, wrap every 10 frames. frame = (int)time.asUnits(MTime.Unit.kFilm); if (frame == 0) frame = 1; cubeSize = 0.5f * (float)(frame % 10); const int numFaces = 6; numVertices = 8; MFloatPoint vtx_1 = new MFloatPoint(-cubeSize, -cubeSize, -cubeSize); MFloatPoint vtx_2 = new MFloatPoint(cubeSize, -cubeSize, -cubeSize); MFloatPoint vtx_3 = new MFloatPoint(cubeSize, -cubeSize, cubeSize); MFloatPoint vtx_4 = new MFloatPoint(-cubeSize, -cubeSize, cubeSize); MFloatPoint vtx_5 = new MFloatPoint(-cubeSize, cubeSize, -cubeSize); MFloatPoint vtx_6 = new MFloatPoint(-cubeSize, cubeSize, cubeSize); MFloatPoint vtx_7 = new MFloatPoint(cubeSize, cubeSize, cubeSize); MFloatPoint vtx_8 = new MFloatPoint(cubeSize, cubeSize, -cubeSize); points.append(vtx_1); points.append(vtx_2); points.append(vtx_3); points.append(vtx_4); points.append(vtx_5); points.append(vtx_6); points.append(vtx_7); points.append(vtx_8); // Set up an array containing the number of vertices // for each of the 6 cube faces (4 verticies per face) // int[] face_counts = { 4, 4, 4, 4, 4, 4 }; MIntArray faceCounts = new MIntArray(face_counts); // Set up and array to assign vertices from points to each face // int[] face_connects = { 0, 1, 2, 3, 4, 5, 6, 7, 3, 2, 6, 5, 0, 3, 5, 4, 0, 4, 7, 1, 1, 7, 6, 2 }; MIntArray faceConnects = new MIntArray(face_connects); MObject newMesh = meshFS.create(numVertices, numFaces, points, faceCounts, faceConnects, outData); return newMesh; }
// // Description // // Create circles of vertices starting with // the top pole ending with the bottom pole // public void buildSphere(double rad, int div, MPointArray vertices, MIntArray counts, MIntArray connects, MVectorArray normals, apiMeshGeomUV uvs) { double u = -Math.PI / 2.0; double v = -Math.PI; double u_delta = Math.PI / ((double)div); double v_delta = 2 * Math.PI / ((double)div); MPoint topPole = new MPoint( 0.0, rad, 0.0 ); MPoint botPole = new MPoint( 0.0, -rad, 0.0 ); // Build the vertex and normal table // vertices.append( botPole ); normals.append( botPole.minus(MPoint.origin) ); int i; for ( i=0; i<(div-1); i++ ) { u += u_delta; v = -Math.PI; for ( int j=0; j<div; j++ ) { double x = rad * Math.Cos(u) * Math.Cos(v); double y = rad * Math.Sin(u); double z = rad * Math.Cos(u) * Math.Sin(v) ; MPoint pnt = new MPoint( x, y, z ); vertices.append( pnt ); normals.append( pnt.minus(MPoint.origin) ); v += v_delta; } } vertices.append( topPole ); normals.append( topPole.minus(MPoint.origin) ); // Create the connectivity lists // int vid = 1; int numV = 0; for ( i=0; i<div; i++ ) { for ( int j=0; j<div; j++ ) { if ( i==0 ) { counts.append( 3 ); connects.append( 0 ); connects.append( j+vid ); connects.append( (j==(div-1)) ? vid : j+vid+1 ); } else if ( i==(div-1) ) { counts.append( 3 ); connects.append( j+vid+1-div ); connects.append( vid+1 ); connects.append( j==(div-1) ? vid+1-div : j+vid+2-div ); } else { counts.append( 4 ); connects.append( j + vid+1-div ); connects.append( j + vid+1 ); connects.append( j == (div-1) ? vid+1 : j+vid+2 ); connects.append( j == (div-1) ? vid+1-div : j+vid+2-div ); } numV++; } vid = numV; } // TODO: Define UVs for sphere ... // }
public Material MakeMaterial(MFnMesh fnMesh) { MaterialGroup matGroup =new MaterialGroup () ; MObjectArray shaders =new MObjectArray() ; MIntArray indices =new MIntArray () ; fnMesh.getConnectedShaders (0, shaders, indices) ; for ( int i =0 ; i < shaders.length ; i++ ) { MFnDependencyNode shaderGroup =new MFnDependencyNode (shaders [i]) ; MPlug shaderPlug =shaderGroup.findPlug ("surfaceShader") ; MPlugArray connections =new MPlugArray () ; shaderPlug.connectedTo (connections, true, false) ; for ( int u =0 ; u < connections.length ; u++ ) { MFnDependencyNode depNode =new MFnDependencyNode (connections [u].node) ; //MPlug colorPlug =depNode.findPlug ("color") ; //MColor mcolor =new MColor () ; ///*MPlugArray cc =new MPlugArray () ; //colorPlug.connectedTo (cc, true , false) ; //if ( cc.length > 0 ) { // // Plug is driven by an input connection. // for ( int v =0 ; v < cc.length ; v++ ) { // MPlug color2Plug =cc [v] ; // Console.WriteLine (color2Plug.numChildren) ; // color2Plug.child (0).getValue (mcolor.r) ; // color2Plug.child (1).getValue (mcolor.g) ; // color2Plug.child (2).getValue (mcolor.b) ; // //color2Plug.child (3).getValue (mcolor.a) ; // } //} else {*/ // mcolor.r =colorPlug.child (0).asFloat () ; // mcolor.g =colorPlug.child (1).asFloat () ; // mcolor.b =colorPlug.child (2).asFloat () ; // //colorPlug.child (3).getValue (mcolor.a) ; ////} //MPlug trPlug =depNode.findPlug ("transparency") ; //float transparency =1.0f - trPlug.child (0).asFloat () ; ////return new DiffuseMaterial (new SolidColorBrush (Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b))) ; //DiffuseMaterial diffuse =new DiffuseMaterial (new SolidColorBrush (Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b))) ; //colorPlug =depNode.findPlug ("ambientColor") ; //mcolor.r =colorPlug.child (0).asFloat () ; //mcolor.g =colorPlug.child (1).asFloat () ; //mcolor.b =colorPlug.child (2).asFloat () ; //diffuse.AmbientColor =Color.FromScRgb (transparency, mcolor.r, mcolor.g, mcolor.b) ; //matGroup.Children.Add (diffuse) ; //colorPlug =depNode.findPlug ("specularColor") ; //mcolor.r =colorPlug.child (0).asFloat () ; //mcolor.g =colorPlug.child (1).asFloat () ; //mcolor.b =colorPlug.child (2).asFloat () ; //MPlug powerPlug =depNode.findPlug ("cosinePower") ; //SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f, mcolor.r, mcolor.g, mcolor.b)), powerPlug.asDouble ()) ; //matGroup.Children.Add (specular) ; //EmissiveMaterial emissive =new EmissiveMaterial () ; //matGroup.Children.Add (emissive) ; try { MFnLambertShader lambert =new MFnLambertShader (connections [u].node) ; SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - lambert.transparency.r, lambert.color.r, lambert.color.g, lambert.color.b)) ; brush.Opacity =1.0f - lambert.transparency.r ; DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; diffuse.AmbientColor =Color.FromScRgb (1.0f - lambert.ambientColor.a, lambert.ambientColor.r, lambert.ambientColor.g, lambert.ambientColor.b) ; // no more attributes matGroup.Children.Add (diffuse) ; // No specular color EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - lambert.incandescence.a, lambert.incandescence.r, lambert.incandescence.g, lambert.incandescence.b))) ; // no more attributes matGroup.Children.Add (emissive) ; } catch { } //try { // MFnReflectShader reflect =new MFnReflectShader (connections [u].node) ; // SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - reflect.specularColor.a, reflect.specularColor.r, reflect.specularColor.g, reflect.specularColor.b)), reflect.cosPower) ; // // no more attributes // matGroup.Children.Add (specular) ; //} catch { //} try { MFnPhongShader phong =new MFnPhongShader (connections [u].node) ; //See Lambert //SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - phong.transparency.r, phong.color.r, phong.color.g, phong.color.b)) ; //brush.Opacity =1.0f - phong.transparency.r ; //DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; //diffuse.AmbientColor =Color.FromScRgb (1.0f - phong.ambientColor.a, phong.ambientColor.r, phong.ambientColor.g, phong.ambientColor.b) ; //// no more attributes //matGroup.Children.Add (diffuse) ; SpecularMaterial specular =new SpecularMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.specularColor.a, phong.specularColor.r, phong.specularColor.g, phong.specularColor.b)), phong.cosPower) ; // no more attributes matGroup.Children.Add (specular) ; //See Lambert //EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.incandescence.a, phong.incandescence.r, phong.incandescence.g, phong.incandescence.b))) ; //// no more attributes //matGroup.Children.Add (emissive) ; } catch { } // todo //try { // MFnBlinnShader phong =new MFnBlinnShader (connections [u].node) ; // //See Lambert // //SolidColorBrush brush =new SolidColorBrush (Color.FromScRgb (1.0f - phong.transparency.r, phong.color.r, phong.color.g, phong.color.b)) ; // //brush.Opacity =1.0f - phong.transparency.r ; // //DiffuseMaterial diffuse =new DiffuseMaterial (brush) ; // //diffuse.AmbientColor = Color.FromScRgb (1.0f - phong.ambientColor.a, phong.ambientColor.r, phong.ambientColor.g, phong.ambientColor.b) ; // //// no more attributes // //matGroup.Children.Add (diffuse) ; // //See Lambert // //EmissiveMaterial emissive =new EmissiveMaterial (new SolidColorBrush (Color.FromScRgb (1.0f - phong.incandescence.a, phong.incandescence.r, phong.incandescence.g, phong.incandescence.b))) ; // //// no more attributes // //matGroup.Children.Add (emissive) ; //} catch { //} } } // Default to Blue if ( matGroup.Children.Count == 0 ) matGroup.Children.Add (new DiffuseMaterial (new SolidColorBrush (Color.FromRgb (0, 0, 255)))) ; return (matGroup) ; }
private BabylonNode ExportMesh(MObject mObject, BabylonScene babylonScene) { MFnMesh mFnMesh = new MFnMesh(mObject); MFnDagNode mFnDagNode = new MFnDagNode(mObject); var mObjectParent = mFnMesh.parent(0); MFnDagNode mFnDagNodeParent = new MFnDagNode(mObjectParent); // --- prints --- #region prints RaiseVerbose("BabylonExporter.Mesh | mFnMesh data", 2); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.name=" + mFnMesh.name, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.absoluteName=" + mFnMesh.absoluteName, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.fullPathName=" + mFnMesh.fullPathName, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.partialPathName=" + mFnMesh.partialPathName, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numVertices=" + mFnMesh.numVertices, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numEdges=" + mFnMesh.numEdges, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numPolygons=" + mFnMesh.numPolygons, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numFaceVertices=" + mFnMesh.numFaceVertices, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numNormals=" + mFnMesh.numNormals, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numUVSets=" + mFnMesh.numUVSets, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numUVsProperty=" + mFnMesh.numUVsProperty, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.activeColor=" + mFnMesh.activeColor.toString(), 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.attributeCount=" + mFnMesh.attributeCount, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.childCount=" + mFnMesh.childCount, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.displayColors=" + mFnMesh.displayColors, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.dormantColor=" + mFnMesh.dormantColor, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.hasUniqueName=" + mFnMesh.hasUniqueName, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.inUnderWorld=" + mFnMesh.inUnderWorld, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isDefaultNode=" + mFnMesh.isDefaultNode, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isInstanceable=" + mFnMesh.isInstanceable, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isInstanced(true)=" + mFnMesh.isInstanced(true), 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isInstanced(false)=" + mFnMesh.isInstanced(false), 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isInstanced()=" + mFnMesh.isInstanced(), 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isIntermediateObject=" + mFnMesh.isIntermediateObject, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.isShared=" + mFnMesh.isShared, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numColorSets=" + mFnMesh.numColorSets, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.numColorsProperty=" + mFnMesh.numColorsProperty, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.objectColor=" + mFnMesh.objectColor, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.parentCount=" + mFnMesh.parentCount, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.parentNamespace=" + mFnMesh.parentNamespace, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.uuid().asString()=" + mFnMesh.uuid().asString(), 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.dagRoot().apiType=" + mFnMesh.dagRoot().apiType, 3); RaiseVerbose("BabylonExporter.Mesh | mFnMesh.model.equalEqual(mFnMesh.objectProperty)=" + mFnMesh.model.equalEqual(mFnMesh.objectProperty), 3); RaiseVerbose("BabylonExporter.Mesh | ToString(mFnMesh.transformationMatrix)=" + mFnMesh.transformationMatrix.toString(), 3); var transformationMatrix = new MTransformationMatrix(mFnMesh.transformationMatrix); RaiseVerbose("BabylonExporter.Mesh | transformationMatrix.getTranslation().toString()=" + transformationMatrix.getTranslation().toString(), 3); var transformationMatrixParent = new MTransformationMatrix(mFnDagNodeParent.transformationMatrix); RaiseVerbose("BabylonExporter.Mesh | transformationMatrixParent.getTranslation().toString()=" + transformationMatrixParent.getTranslation().toString(), 3); // Geometry MIntArray triangleCounts = new MIntArray(); MIntArray trianglesVertices = new MIntArray(); mFnMesh.getTriangles(triangleCounts, trianglesVertices); RaiseVerbose("BabylonExporter.Mesh | triangleCounts.ToArray()=" + triangleCounts.ToArray().toString(), 3); RaiseVerbose("BabylonExporter.Mesh | trianglesVertices.ToArray()=" + trianglesVertices.ToArray().toString(), 3); int[] polygonsVertexCount = new int[mFnMesh.numPolygons]; for (int polygonId = 0; polygonId < mFnMesh.numPolygons; polygonId++) { polygonsVertexCount[polygonId] = mFnMesh.polygonVertexCount(polygonId); } RaiseVerbose("BabylonExporter.Mesh | polygonsVertexCount=" + polygonsVertexCount.toString(), 3); //MFloatPointArray points = new MFloatPointArray(); //mFnMesh.getPoints(points); //RaiseVerbose("BabylonExporter.Mesh | points.ToArray()=" + points.ToArray().Select(mFloatPoint => mFloatPoint.toString()), 3); //MFloatVectorArray normals = new MFloatVectorArray(); //mFnMesh.getNormals(normals); //RaiseVerbose("BabylonExporter.Mesh | normals.ToArray()=" + normals.ToArray().Select(mFloatPoint => mFloatPoint.toString()), 3); for (int polygonId = 0; polygonId < mFnMesh.numPolygons; polygonId++) { MIntArray verticesId = new MIntArray(); RaiseVerbose("BabylonExporter.Mesh | polygonId=" + polygonId, 3); int nbTriangles = triangleCounts[polygonId]; RaiseVerbose("BabylonExporter.Mesh | nbTriangles=" + nbTriangles, 3); for (int triangleIndex = 0; triangleIndex < triangleCounts[polygonId]; triangleIndex++) { RaiseVerbose("BabylonExporter.Mesh | triangleIndex=" + triangleIndex, 3); int[] triangleVertices = new int[3]; mFnMesh.getPolygonTriangleVertices(polygonId, triangleIndex, triangleVertices); RaiseVerbose("BabylonExporter.Mesh | triangleVertices=" + triangleVertices.toString(), 3); foreach (int vertexId in triangleVertices) { RaiseVerbose("BabylonExporter.Mesh | vertexId=" + vertexId, 3); MPoint point = new MPoint(); mFnMesh.getPoint(vertexId, point); RaiseVerbose("BabylonExporter.Mesh | point=" + point.toString(), 3); MVector normal = new MVector(); mFnMesh.getFaceVertexNormal(polygonId, vertexId, normal); RaiseVerbose("BabylonExporter.Mesh | normal=" + normal.toString(), 3); } } } #endregion if (IsMeshExportable(mFnMesh) == false) { return(null); } RaiseMessage(mFnMesh.name, 1); var babylonMesh = new BabylonMesh { name = mFnMesh.name, id = mFnMesh.uuid().asString() }; // Position / rotation / scaling / hierarchy ExportNode(babylonMesh, mFnDagNode, babylonScene); // Misc. // TODO - Retreive from Maya // TODO - What is the difference between isVisible and visibility? // TODO - Fix fatal error: Attempting to save in C:/Users/Fabrice/AppData/Local/Temp/Fabrice.20171205.1613.ma //babylonMesh.isVisible = mDagPath.isVisible; //babylonMesh.visibility = meshNode.MaxNode.GetVisibility(0, Tools.Forever); //babylonMesh.receiveShadows = meshNode.MaxNode.RcvShadows == 1; //babylonMesh.applyFog = meshNode.MaxNode.ApplyAtmospherics == 1; if (mFnMesh.numPolygons < 1) { RaiseError($"Mesh {babylonMesh.name} has no face", 2); } if (mFnMesh.numVertices < 3) { RaiseError($"Mesh {babylonMesh.name} has not enough vertices", 2); } if (mFnMesh.numVertices >= 65536) { RaiseWarning($"Mesh {babylonMesh.name} has more than 65536 vertices which means that it will require specific WebGL extension to be rendered. This may impact portability of your scene on low end devices.", 2); } // TODO - Material var vertices = new List <GlobalVertex>(); var indices = new List <int>(); // TODO - UV, color, alpha //var mappingChannels = unskinnedMesh.ActiveMapChannelNum; //bool hasUV = false; //bool hasUV2 = false; //for (int i = 0; i < mappingChannels.Count; ++i) //{ // var indexer = i; // var channelNum = mappingChannels[indexer]; // if (channelNum == 1) // { // hasUV = true; // } // else if (channelNum == 2) // { // hasUV2 = true; // } //} //var hasColor = unskinnedMesh.NumberOfColorVerts > 0; //var hasAlpha = unskinnedMesh.GetNumberOfMapVerts(-2) > 0; // TODO - Add custom properties var optimizeVertices = false; // meshNode.MaxNode.GetBoolProperty("babylonjs_optimizevertices"); // Compute normals var subMeshes = new List <BabylonSubMesh>(); ExtractGeometry(mFnMesh, vertices, indices, subMeshes, optimizeVertices); if (vertices.Count >= 65536) { RaiseWarning($"Mesh {babylonMesh.name} has {vertices.Count} vertices. This may prevent your scene to work on low end devices where 32 bits indice are not supported", 2); if (!optimizeVertices) { RaiseError("You can try to optimize your object using [Try to optimize vertices] option", 2); } } RaiseMessage($"{vertices.Count} vertices, {indices.Count / 3} faces", 2); // Buffers babylonMesh.positions = vertices.SelectMany(v => v.Position).ToArray(); babylonMesh.normals = vertices.SelectMany(v => v.Normal).ToArray(); babylonMesh.subMeshes = subMeshes.ToArray(); // Buffers - Indices babylonMesh.indices = indices.ToArray(); babylonScene.MeshesList.Add(babylonMesh); RaiseMessage("BabylonExporter.Mesh | done", 3); return(babylonMesh); }
//====================================================================== // // Do the metadata creation. The metadata will be randomly initialized // based on the channel type and the structure specified. For recognized // components the number of metadata elements will correspond to the count // of components in the selected mesh, otherwise a random number of metadata // elements between 1 and 100 will be created (at consecutive indices). // // The previously existing metadata is preserved for later undo. // override public void doIt(MArgList args) { MArgDatabase argsDb = new MArgDatabase(syntax, args); checkArgs(ref argsDb); clearResult(); uint numNodes = fNodes.length; int i; for (i = 0; i < numNodes; ++i) { // fNodes[i] is the transform not the shape itself MFnDagNode dagNode = new MFnDagNode(fNodes[i]); MObject obj = dagNode.child(0); // obj is the shape, which is where we can add the meta data MFnDependencyNode node = new MFnDependencyNode(obj); // Get the current metadata (empty if none yet) Associations newMetadata = new Associations(node.metadata); Channel newChannel = newMetadata.channel(fChannelType); // Check to see if the requested stream name already exists Stream oldStream = newChannel.dataStream(fStreamName); if (oldStream != null) { string fmt = MStringResource.getString(MetaDataRegisterMStringResources.kCreateMetadataHasStream); string msg = String.Format(fmt, fStreamName); MGlobal.displayError( msg ); continue; } Stream newStream = new Stream(fStructure, fStreamName); string strmName = newStream.name; int indexCount = 0; MFnMesh mesh = null; Random rndIndexCount = new Random(); // Treat the channel type initializations different for meshes if (obj.hasFn(MFn.Type.kMesh)) { mesh = new MFnMesh(obj); // Get mesh-specific channel type parameters if (fChannelType == "face") { indexCount = mesh.numPolygons; } else if (fChannelType == "edge") { indexCount = mesh.numEdges; } else if (fChannelType == "vertex") { indexCount = mesh.numVertices; } else if (fChannelType == "vertexFace") { indexCount = mesh.numFaceVertices; } else { // Set a random number between 1 to 100 indexCount = rndIndexCount.Next(1, 100); } } else { // Create generic channel type information indexCount = rndIndexCount.Next(1, 100); } // Fill specified stream ranges with random data int structureMemberCount = fStructure.memberCount; uint m,n,d; Random rnd = new Random(); for (m = 0; m < indexCount; ++m) { // Walk each structure member and fill with random data // tailored to the member data type. Handle handle = new Handle(fStructure); for (n = 0; n < structureMemberCount; ++n) { handle.setPositionByMemberIndex(n); switch (handle.dataType) { case Member.eDataType.kBoolean: { bool[] data = new bool[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { int randomInt = rnd.Next(0, 2); bool randomBool = randomInt == 1 ? true : false; data[d] = randomBool; } handle.asBooleanArray = data; break; } case Member.eDataType.kDouble: { double[] data = new double[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { // Set a random number between -2000000000.0.0 and 2000000000.0.0 data[d] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; } handle.asDoubleArray = data; break; } case Member.eDataType.kDoubleMatrix4x4: { double[] data = new double[handle.dataLength * 16]; for (d = 0; d < handle.dataLength; ++d) { data[d*16+0] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+1] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+2] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+3] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+4] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+5] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+6] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+7] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+8] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+9] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+10] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+11] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+12] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+13] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+14] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; data[d*16+15] = rnd.NextDouble()*4000000000.0 - 2000000000.0 ; } handle.asDoubleMatrix4x4 = data; break; } case Member.eDataType.kFloat: { float[] data = new float[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { // Set a random number between -2000000.0 and 2000000.0 data[d] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; } handle.asFloatArray = data; break; } case Member.eDataType.kFloatMatrix4x4: { float[] data = new float[handle.dataLength * 16]; for (d = 0; d < handle.dataLength; ++d) { // Set a random number between -2000000.0 and 2000000.0 data[d*16+0] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+1] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+2] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+3] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+4] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+5] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+6] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+7] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+8] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+9] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+10] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+11] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+12] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+13] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+14] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; data[d*16+15] = (float)rnd.NextDouble()*4000000.0f - 2000000.0f ; } handle.asFloatMatrix4x4 = data; break; } case Member.eDataType.kInt8: { sbyte[] data = new sbyte[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = (sbyte)rnd.Next(SByte.MinValue, SByte.MaxValue+1); } handle.asInt8Array = data; break; } case Member.eDataType.kInt16: { short[] data = new short[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = (short)rnd.Next(Int16.MinValue, Int16.MaxValue+1); } handle.asInt16Array = data; break; } case Member.eDataType.kInt32: { int[] data = new int[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { // rnd.Next returns a number between [arg1,arg2[ // but unfortunately I can't pass Int32.MaxValue+1 here.... data[d] = rnd.Next(Int32.MinValue, Int32.MaxValue); } handle.asInt32Array = data; break; } case Member.eDataType.kInt64: { long[] data = new long[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { // rnd.Next() gives a number between [0,Int32 data[d] = (long)rnd.Next(Int32.MinValue, Int32.MaxValue); if( data[d] >= 0 ) data[d] *= Int64.MaxValue / Int32.MaxValue; else data[d] *= Int64.MinValue / Int32.MinValue; } handle.asInt64Array = data; break; } case Member.eDataType.kUInt8: { byte[] data = new byte[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = (byte)rnd.Next(0, Byte.MaxValue + 1); } handle.asUInt8Array = data; break; } case Member.eDataType.kUInt16: { ushort[] data = new ushort[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = (ushort)rnd.Next(0, UInt16.MaxValue + 1); } handle.asUInt16Array = data; break; } case Member.eDataType.kUInt32: { uint[] data = new uint[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = (uint)rnd.Next(); } handle.asUInt32Array = data; break; } case Member.eDataType.kUInt64: { ulong[] data = new ulong[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { data[d] = ((ulong)rnd.Next()) * UInt64.MaxValue / UInt32.MaxValue; } handle.asUInt64Array = data; break; } case Member.eDataType.kString: { string[] randomStrings = new string[] { "banana", "tomatoe", "apple", "pineapple", "apricot", "pepper", "olive", "grapefruit" }; string[] data = new string[handle.dataLength]; for (d = 0; d < handle.dataLength; ++d) { int index = rnd.Next( randomStrings.Length ); data[d] = randomStrings[index]; } handle.asStringArray = data; break; } default: { Debug.Assert(false, "This should never happen"); break; } } } newStream.setElement(new Index(m), handle); } newChannel.setDataStream(newStream); newMetadata.setChannel(newChannel); // Note: the following will not work if "obj" is a shape constructed by a source object // You need to delete the history of the shape before calling this... fDGModifier.setMetadata(obj, newMetadata); fDGModifier.doIt(); // Set the result to the number of actual metadata values set as a // triple value: // (# nodes, # metadata elements, # members per element) // MIntArray theResult = new MIntArray(); theResult.append( (int) fNodes.length ); theResult.append( (int) indexCount ); theResult.append( (int) structureMemberCount ); setResult( theResult ); } }
public TriMesh ConvertTriMesh(MFnMesh mesh) { if(mesh==null) { MGlobal.displayInfo("Mesh is null \n"); } TriMesh trimesh = new TriMesh(); MIntArray indices = new MIntArray(); MIntArray triangleCounts = new MIntArray(); MPointArray points = new MPointArray(); mesh.getTriangles(triangleCounts, indices); mesh.getPoints(points); // Get the triangle indices for (int i = 0; i < (int)points.length; ++i) { MPoint pt = points[i]; VertexTraits trait = new VertexTraits(pt.x, pt.y, pt.z); trimesh.Vertices.Add(trait); } MGlobal.displayInfo( indices.Count.ToString() +"\n"); int j=0; while(j<indices.Count) { int a = indices[j]; j++; int b = indices[j]; j++; int c = indices[j]; j++; trimesh.Faces.AddTriangles(trimesh.Vertices[a], trimesh.Vertices[b], trimesh.Vertices[c]); } return trimesh; }
public MObject ConvertMeshMaya(TriMesh triMesh) { MFnMesh meshMaya = new MFnMesh(); int verticeNum = triMesh.Vertices.Count; MFloatPointArray points = new MFloatPointArray(); for(int i=0;i<verticeNum;i++) { float x=(float)triMesh.Vertices[i].Traits.Position.x; float y=(float)triMesh.Vertices[i].Traits.Position.y; float z=(float)triMesh.Vertices[i].Traits.Position.z; MFloatPoint vertex = new MFloatPoint(x,y,z); points.append(vertex); } int faceNum = triMesh.Faces.Count; int[] face_Counts=new int[faceNum]; for(int i=0;i<faceNum;i++) { face_Counts[i]=3; } MIntArray faceCounts = new MIntArray(face_Counts); int[] faceTopology=new int[faceNum*3]; for(int j=0;j<faceNum ;j++) { int index=j*3; faceTopology[index]=triMesh.Faces[j].GetVertex(0).Index ; faceTopology[index+1]=triMesh.Faces[j].GetVertex(1).Index ; faceTopology[index+2]=triMesh.Faces[j].GetVertex(2).Index ; } MIntArray faceConnects = new MIntArray(faceTopology); MObject mesh= meshMaya.create(verticeNum, faceNum, points, faceCounts, faceConnects); return mesh; }
unsafe public override void getTweakedUVs(MObject meshObj, MIntArray uvList, MFloatArray uPos, MFloatArray vPos) { int i = 0; MFloatArray uArray = new MFloatArray(); MFloatArray vArray = new MFloatArray(); MFnMesh mesh = new MFnMesh(meshObj); mesh.getUVs(uArray, vArray); uint nbUvShells = 0; MIntArray uvShellIds = new MIntArray(); if ((!flipGlobal) || extendToShell) // First, extract the UV shells. mesh.getUvShellsIds(uvShellIds, ref nbUvShells); if (extendToShell) { bool[] selected = new bool[nbUvShells]; for (i = 0; i < nbUvShells; i++) { selected[i] = false; } for (i = 0; i < nbUvShells; i++) { int index = uvList[i]; index = uvShellIds[index]; selected[index] = true; } uint numUvs = (uint)mesh.numUVsProperty; uint numSelUvs = 0; // Preallocate a buffer, large enough to hold all Ids. This // prevents multiple reallocation from happening when growing // the array. uvList.length = numUvs; for (i = 0; i < numUvs; i++) { int index = uvShellIds[i]; if (selected[index]) { uvList.set((int)i, numSelUvs); numSelUvs++; } } // clamp the array to the proper size. uvList.length = numSelUvs; } int nbUvShellsInt = (int)nbUvShells; // For global flips, just pretend there is only one shell if (flipGlobal) nbUvShellsInt = 1; float[] minMax = new float[nbUvShellsInt * 4]; for (i = 0; i < nbUvShellsInt; i++) { minMax[4 * i + 0] = 1e30F; // Min U minMax[4 * i + 1] = 1e30F; // Min V minMax[4 * i + 2] = -1e30F; // Max U minMax[4 * i + 3] = -1e30F; // Max V } // Get the bounding box of the UVs, for each shell if flipGlobal // is true, or for the whole selection if false. for (i = 0; i < uvList.length; i++) { int indx = uvList[i]; int shellId = 0; if (!flipGlobal) { shellId = uvShellIds[indx]; } float value = uArray[indx]; if (value < minMax[4 * shellId + 0]) minMax[4 * shellId + 0] = value; value = vArray[indx]; if (value < minMax[4 * shellId + 1]) minMax[4 * shellId + 1] = value; value = uArray[indx]; if (value > minMax[4 * shellId + 2]) minMax[4 * shellId + 2] = value; value = vArray[indx]; if (value > minMax[4 * shellId + 3]) minMax[4 * shellId + 3] = value; } // Adjust the size of the output arrays uPos.length = uvList.length; vPos.length = uvList.length; for (i = 0; i < uvList.length; i++) { int shellId = 0; int indx = uvList[i]; if (!flipGlobal) shellId = uvShellIds[indx]; // Flip U or V along the bounding box center. if (horizontal) { float value = uArray[indx]; value = minMax[4 * shellId + 0] + minMax[4 * shellId + 2] - value; uPos.set(value, (uint)i); value = vArray[indx]; vPos.set(value, (uint)i); } else { float value = uArray[indx]; uPos.set(value, (uint)i); value = vArray[indx]; value = minMax[4 * shellId + 1] + minMax[4 * shellId + 3] - value; vPos.set(value, (uint)i); } } return; }