def sang_poly(chue_nod_poly, lis_xyz, lis_index_chut, lis_n_chut_nai_na, lis_u, lis_v, lis_norm=None): # 頂点のデータを収めておいたリストをmayaの配列オブジェクトにする arr_xyz = om.MFloatPointArray(lis_xyz) # 頂点の位置 arr_index_chut = om.MIntArray(lis_index_chut) # 頂点の番号 arr_n_chut_nai_na = om.MIntArray(lis_n_chut_nai_na) # 各面に使う頂点の数 arr_u = om.MFloatArray(lis_u) # 頂点のuv arr_v = om.MFloatArray(lis_v) trans_fn = om.MFnTransform() trans_obj = trans_fn.create() trans_fn.setName(chue_nod_poly) chue_nod_poly = trans_fn.name() # 準備しておいたデータから全てのポリゴンメッシュを作成する fn_mesh = om.MFnMesh() fn_mesh.create(arr_xyz, arr_n_chut_nai_na, arr_index_chut, arr_u, arr_v, trans_obj) fn_mesh.setName(chue_nod_poly + 'Shape') fn_mesh.assignUVs(arr_n_chut_nai_na, arr_index_chut) if (lis_norm): fn_mesh.setVertexNormals(lis_norm, om.MIntArray(range(len(lis_xyz)))) # 一応MMDからのモデルだという情報をポリゴンのノードに刻んでおく mc.addAttr(chue_nod_poly, longName='MMD_model', niceName='MMDからのモデル', attributeType='bool') mc.setAttr(chue_nod_poly + '.MMD_model', True) mc.setAttr(chue_nod_poly + '.aiOpaque', 0) # arnoldを使う時に不透明度を有効にする return chue_nod_poly
def buildMesh() : numVertices=4 numFaces=1 outputMesh = OpenMaya.MObject() points = OpenMaya.MFloatPointArray() faceConnects = OpenMaya.MIntArray() faceCounts = OpenMaya.MIntArray() p = OpenMaya.MFloatPoint(-1.0,0.0,-1.0) points.append(p) p = OpenMaya.MFloatPoint(-1.0,0.0,1.0) points.append(p) p = OpenMaya.MFloatPoint(1.0,0.0,1.0) points.append(p) p = OpenMaya.MFloatPoint(1.0,0.0,-1.0) points.append(p) faceConnects.append(0) faceConnects.append(1) faceConnects.append(2) faceConnects.append(3) faceCounts.append(4) meshFN = OpenMaya.MFnMesh() meshFN.create(points, [4],faceConnects) nodeName = meshFN.name() print(nodeName) cmds.sets(nodeName, add='initialShadingGroup') cmds.select(nodeName) meshFN.updateSurface()
def __init__(self): ompy.MUserData.__init__(self, False) self.setDeleteAfterUse(False) # don;t delete after draw self.shapes = [] #vector<int> self.coords = ompy.MFloatVectorArray() #MFloatVectorArray self.screenSpaceOffsets = ompy.MFloatVectorArray() #MFloatVectorArray self.sizes = [] #vector<float> self.thicknesses = [] #vector<float> self.colors = ompy.MFloatPointArray() #MFloatPointArray self.pColors = [] #vector<MFloatPointArray> self.names = [] #vector<MString> self.fills = [] #vector<bool> self.spaces = [] #vector<int> self.maxMemorys = [] #vector<int> self.projPlanes = [] #vector<int> self.drawPlaneMode = 0 #int self.cameraPath = ompy.MDagPath() #MDagPath self.attrMatrix = ompy.MFloatMatrix() #MFloatMatrix self.attrNames = [] #vector<MString> self.attrValueType = [] #vector<MString> self.attrValueInt = [] #vector<int> self.attrValueFloat = [] #vector<float> self.attrValueDouble = [] #vector<double> self.attrValueEnum = [] #vector<MString>
def createVoxelMesh(self, pVoxelPositions, pVoxelWidth, pOutMeshData): ''' Create a mesh containing one cubic polygon for each voxel in the pVoxelPositions list. ''' numVoxels = len(pVoxelPositions) numVerticesPerVoxel = 8 # a cube has eight vertices. numPolygonsPerVoxel = 6 # a cube has six faces. numVerticesPerPolygon = 4 # four vertices are required to define a face of a cube. numPolygonConnectsPerVoxel = numPolygonsPerVoxel * numVerticesPerPolygon # 24 # Initialize the required arrays used to create the mesh in MFnMesh.create() totalVertices = numVoxels * numVerticesPerVoxel vertexArray = OpenMaya.MFloatPointArray() vertexArray.setLength(totalVertices) vertexIndexOffset = 0 totalPolygons = numVoxels * numPolygonsPerVoxel polygonCounts = OpenMaya.MIntArray() polygonCounts.setLength(totalPolygons) polygonCountsIndexOffset = 0 totalPolygonConnects = numVoxels * numPolygonConnectsPerVoxel polygonConnects = OpenMaya.MIntArray() polygonConnects.setLength(totalPolygonConnects) polygonConnectsIndexOffset = 0 # Populate the required arrays used in MFnMesh.create() for i in range(0, numVoxels): voxelPosition = pVoxelPositions[i] # Add a new cube to the arrays. self.createCube(voxelPosition, pVoxelWidth, vertexArray, vertexIndexOffset, numVerticesPerVoxel, polygonCounts, polygonCountsIndexOffset, numPolygonsPerVoxel, numVerticesPerPolygon, polygonConnects, polygonConnectsIndexOffset) # Increment the respective index offsets. vertexIndexOffset += numVerticesPerVoxel polygonCountsIndexOffset += numPolygonsPerVoxel polygonConnectsIndexOffset += numPolygonConnectsPerVoxel # Create the mesh now that the arrays have been populated. The mesh is stored in pOutMeshData meshFn = OpenMaya.MFnMesh() meshFn.create(vertexArray, polygonCounts, polygonConnects, parent=pOutMeshData)
def inflateMesh(mesh, scale=1): sel_list = om.MSelectionList() sel_list.add(str(mesh)) DagPath, Obj = sel_list.getComponent(0) Mesh = om.MFnMesh(DagPath) MeshPoints = Mesh.getPoints(om.MSpace.kWorld) newMeshPoints = om.MFloatPointArray() for i in range(len(MeshPoints)): MeshPointNormal = Mesh.getVertexNormal(i, om.MSpace.kWorld) x = MeshPoints[i].x + MeshPointNormal.x * scale y = MeshPoints[i].y + MeshPointNormal.y * scale z = MeshPoints[i].z + MeshPointNormal.z * scale newMeshPoint = om.MFloatPoint(x, y, z) newMeshPoints.append(newMeshPoint) Mesh.setPoints(newMeshPoints, om.MSpace.kWorld)
def create(verts, faces, merge=True): ''' Given a list of vertices (iterables of floats) and a list of faces (iterable of integer vert indices), creates and returns a maya Mesh ''' cmds.select(cl=True) outputMesh = OpenMaya.MObject() # point array of mesh vertex local positions points = OpenMaya.MFloatPointArray() for eachVt in verts: p = OpenMaya.MFloatPoint(eachVt[0], eachVt[1], eachVt[2]) points.append(p) # vertex connections per poly face in one array of indexs into point array given above faceConnects = OpenMaya.MIntArray() for eachFace in faces: for eachCorner in eachFace: faceConnects.append(int(eachCorner)) # an array to hold the total number of vertices that each face has in this case quads so 4 faceCounts = OpenMaya.MIntArray() # python lists can be multiplied to duplicate faceCounts = [4] * len(faces) # get a mesh function set meshFN = OpenMaya.MFnMesh() # create mesh object using arrays above meshFN.create(points, faceCounts, faceConnects, parent=outputMesh) # now grab the name of the mesh nodeName = meshFN.name() cmds.sets(nodeName, add='initialShadingGroup') cmds.select(nodeName) meshFN.updateSurface() # this is useful because it deletes stray vertices (ie, those not used in any faces) cmds.polyMergeVertex(nodeName, ch=0) meshFN.updateSurface() return nodeName
def _importCtm(self, fileName, importOptions): verbose = importOptions.get('verbose', False) context = openctm.ctmNewContext(openctm.CTM_IMPORT) # Extract file openctm.ctmLoad(context, fileName) e = openctm.ctmGetError(context) if e != 0: s = openctm.ctmErrorString(e) print(s) openctm.ctmFreeContext(context) raise Exception(s) # Extract indices triCount = openctm.ctmGetInteger(context, openctm.CTM_TRIANGLE_COUNT) ctmIndices = openctm.ctmGetIntegerArray(context, openctm.CTM_INDICES) polyCount = [3] * triCount # Extract vertices vertCount = openctm.ctmGetInteger(context, openctm.CTM_VERTEX_COUNT) ctmVertices = openctm.ctmGetFloatArray(context, openctm.CTM_VERTICES) vertices = OpenMaya.MFloatPointArray() vertices.setLength(vertCount) # Extract Normals ctmVertNormals = None vertNormals = OpenMaya.MFloatPointArray() hasNormals = openctm.ctmGetInteger( context, openctm.CTM_HAS_NORMALS) == openctm.CTM_TRUE if hasNormals: ctmVertNormals = openctm.ctmGetFloatArray(context, openctm.CTM_NORMALS) vertNormals.setLength(vertCount) # Extract UVs hasUVs = openctm.ctmGetInteger(context, openctm.CTM_UV_MAP_COUNT) > 0 ctmTexCoords = None uCoords = OpenMaya.MFloatArray() vCoords = OpenMaya.MFloatArray() if hasUVs: ctmTexCoords = openctm.ctmGetFloatArray(context, openctm.CTM_UV_MAP_1) uCoords.setLength(vertCount) vCoords.setLength(vertCount) textureFilename = openctm.ctmGetUVMapString( context, openctm.CTM_UV_MAP_1, openctm.CTM_FILE_NAME) # TODO: Load texture file if textureFilename: pass # Extract colors colorAttrib = openctm.ctmGetNamedAttribMap(context, "Color") hasVertexColors = colorAttrib != openctm.CTM_NONE ctmColors = None vertexColors = OpenMaya.MColorArray() if hasVertexColors: ctmColors = openctm.ctmGetFloatArray(context, colorAttrib) vertexColors.setLength(vertCount) pointToIndex = {} ctmVertIndexToUniqueIndex = {} nrSkippedVertices = 0 for i in range(vertCount): ctmVertIndex = i * 3 p = (float(ctmVertices[ctmVertIndex]), float(ctmVertices[ctmVertIndex + 1]), float(ctmVertices[ctmVertIndex + 2])) if p not in pointToIndex: index = i - nrSkippedVertices pointToIndex[p] = index ctmVertIndexToUniqueIndex[i] = index vertices[index].x = p[0] vertices[index].y = p[1] vertices[index].z = p[2] if hasNormals: vertNormals[index].x = float(ctmVertNormals[ctmVertIndex]) vertNormals[index].y = float(ctmVertNormals[ctmVertIndex + 1]) vertNormals[index].z = float(ctmVertNormals[ctmVertIndex + 2]) if hasUVs: ctmUVIndex = i * 2 uCoords[index] = float(ctmTexCoords[ctmUVIndex]) vCoords[index] = float(ctmTexCoords[ctmUVIndex + 1]) if hasVertexColors: ctmColIndex = i * 4 vertexColors[index].r = float(ctmColors[ctmColIndex]) vertexColors[index].g = float(ctmColors[ctmColIndex + 1]) vertexColors[index].b = float(ctmColors[ctmColIndex + 2]) vertexColors[index].a = float(ctmColors[ctmColIndex + 3]) else: ctmVertIndexToUniqueIndex[i] = pointToIndex[p] nrSkippedVertices += 1 uniqVertCount = len(pointToIndex) vertices.setLength(uniqVertCount) vertNormals.setLength(uniqVertCount) indices = [ ctmVertIndexToUniqueIndex[ctmIndices[i]] for i in range(3 * triCount) ] if hasUVs: uCoords.setLength(uniqVertCount) vCoords.setLength(uniqVertCount) if hasVertexColors: vertexColors.setLength(uniqVertCount) if verbose: method = openctm.ctmGetInteger(context, openctm.CTM_COMPRESSION_METHOD) if method == openctm.CTM_METHOD_RAW: methodStr = "RAW" elif method == openctm.CTM_METHOD_MG1: methodStr = "MG1" elif method == openctm.CTM_METHOD_MG2: methodStr = "MG2" else: methodStr = "Unknown" print("File: %s" % fileName) print("Comment: %s" % str(openctm.ctmGetString(context, openctm.CTM_FILE_COMMENT))) print("Compression Method: %s" % methodStr) print("Vertices Count : %d" % vertCount) print("Unique Vertices Count : %d" % uniqVertCount) print("Triangles Count: %d" % triCount) print("Has normals: %r" % hasNormals) print("Has UVs: %r" % hasUVs) print("Has Vertex Colors: %r" % hasVertexColors) fnMesh = OpenMaya.MFnMesh() newMesh = fnMesh.create(vertices, polyCount, indices, uCoords, vCoords) if hasNormals: fnMesh.setVertexNormals(vertNormals, range(len(vertices))) if hasVertexColors: fnMesh.setVertexColors(vertexColors, range(len(vertices))) fnMesh.updateSurface() # Assign initial shading group slist = OpenMaya.MGlobal.getSelectionListByName("initialShadingGroup") initialSG = slist.getDependNode(0) fnSG = OpenMaya.MFnSet(initialSG) if fnSG.restriction() == OpenMaya.MFnSet.kRenderableOnly: fnSG.addMember(newMesh)
def read_gmc_data(scale_rate, gmc_path, mesh_name): # first read, get object section file = open(gmc_path, "r") line_num = -1 line_nums = [] line = file.readline() line_num += 1 while True: line = file.readline() line_num += 1 if not line: break line = strip_space_line(line) if line.find("Object") == 0: line_nums.append(line_num) print line_nums file.close() # second read,read section 1 vertexArray = OpenMaya.MFloatPointArray() uArray = OpenMaya.MFloatArray() vArray = OpenMaya.MFloatArray() polygonCounts = OpenMaya.MIntArray() polygonConnects = OpenMaya.MIntArray() material_num = 0 material_sets = [] file = open(gmc_path, "r") line_num = -1 line = file.readline() line_num += 1 while True: line = file.readline() line_num += 1 if not line: break line = strip_space_line(line) if line_num >= line_nums[0] and line_num < line_nums[1]: if line.find("Vertices") == 0: print line elif line.find("v") == 0: vertex_line = re.split("v|n|c|t", line) vertex_data = [] vertex_data.append(parse_mesh_element(vertex_line[1])) vertex_data.append(parse_mesh_element(vertex_line[4])) pos = vertex_data[0] pos[0] *= scale_rate pos[1] *= scale_rate pos[2] *= scale_rate v = OpenMaya.MFloatPoint(pos[0], pos[1], pos[2]) vertexArray.append(v) uv = vertex_data[1] uArray.append(uv[0]) vArray.append(uv[1]) elif line.find("f") == 0: face_line = line[1:] face_data = [] face_data = parse_mesh_element(face_line) print face_data polygonCounts.append(3) polygonConnects.append(int(face_data[1])) polygonConnects.append(int(face_data[2])) polygonConnects.append(int(face_data[3])) mFn_Mesh = OpenMaya.MFnMesh() m_DagMod = OpenMaya.MDagModifier() new_object = m_DagMod.createNode('transform') mFn_Mesh.create(vertexArray, polygonCounts, polygonConnects, uArray, vArray, new_object) mFn_Mesh.setName(mesh_name) m_DagMod.doIt() new_mesh = pmc.PyNode(mesh_name) new_transform = pmc.listRelatives(new_mesh, type='transform', parent=True)[0] mFn_Mesh.assignUVs(polygonCounts, polygonConnects, 'map1') node_name = mesh_name + "_mesh" pmc.select(new_transform) pmc.rename(new_transform, node_name) file.close()
def read_skc_file(scale_rate, skc_path, mesh_name): file = open(skc_path, "r") line = file.readline() vertexArray = OpenMaya.MFloatPointArray() uArray = OpenMaya.MFloatArray() vArray = OpenMaya.MFloatArray() polygonCounts = OpenMaya.MIntArray() polygonConnects = OpenMaya.MIntArray() vertexWeights = [] material_num = 0 material_sets = [] while True: line = file.readline() if not line: break line = strip_space_line(line) if line.find("Materials") != -1: line = strip_space_line(line) material_num = int(line.split(":")[1]) for i in range(0, int(material_num)): material_sets.append(0) elif line.find("Vertices") != -1: print line elif line[0] == "v": vertex_data = parse_pos_uv_weight(line) pos = vertex_data[0] pos[0] *= scale_rate pos[1] *= scale_rate pos[2] *= scale_rate v = OpenMaya.MFloatPoint(pos[0], pos[1], pos[2]) vertexArray.append(v) uv = vertex_data[1] uArray.append(uv[0]) vArray.append(uv[1]) # bone weights skin_data = vertex_data[2] weight_num = skin_data[0] weights = [] for bi in range(0, int(weight_num)): tmp_bone_idx = skin_data[int(1 + 2 * bi)] tmp_bone_name = bone_name_list[int(tmp_bone_idx)] tmp_bone_weight = skin_data[int(2 + 2 * bi)] key_value = (tmp_bone_name, tmp_bone_weight) weights.append(key_value) vertexWeights.append(weights) elif line.find("Triangles") != -1: print line elif line[0] == "f": face_data = parse_face(line) polygonCounts.append(3) polygonConnects.append(int(face_data[2])) polygonConnects.append(int(face_data[3])) polygonConnects.append(int(face_data[4])) # assign material material_sets[int(face_data[1])] += 1 mFn_Mesh = OpenMaya.MFnMesh() m_DagMod = OpenMaya.MDagModifier() new_object = m_DagMod.createNode('transform') mFn_Mesh.create(vertexArray, polygonCounts, polygonConnects, uArray, vArray, new_object) mFn_Mesh.setName(mesh_name) m_DagMod.doIt() new_mesh = pmc.PyNode(mesh_name) new_transform = pmc.listRelatives(new_mesh, type='transform', parent=True)[0] mFn_Mesh.assignUVs(polygonCounts, polygonConnects, 'map1') node_name = mesh_name + "_mesh" pmc.select(new_transform) pmc.rename(new_transform, node_name) # skin cluster pmc.select(bone_name_list[0], add=True) skin_cluster = pmc.skinCluster(bindMethod=0, skinMethod=1, normalizeWeights=0, maximumInfluences=4, obeyMaxInfluences=True) pmc.select(node_name, r=True) pmc.skinPercent(skin_cluster, node_name, normalize=False, pruneWeights=100) for v in range(0, len(vertexWeights)): pmc.skinPercent(skin_cluster, "{0}.vtx[{1}]".format(node_name, v), transformValue=vertexWeights[v], normalize=True) #create material #pCylinder1.f[14:17] _mesh.f[{0}:{1}].format() material_starts = [] material_ends = [] mesh_selcte_sets = [] material_sets = filter(lambda x: x != 0, material_sets) print material_sets material_starts.append(0) material_ends.append(material_sets[0] - 1) mesh_selcte_sets.append( node_name + ".f[{0}:{1}]".format(int(material_starts[0]), int(material_ends[0]))) for i in range(1, len(material_sets)): material_starts.append(material_ends[int(i - 1)] + 1) material_ends.append(material_ends[int(i - 1)] + material_sets[i]) mesh_selcte_sets.append(node_name + ".f[{0}:{1}]".format( int(material_starts[i]), int(material_ends[i]))) print mesh_selcte_sets # 没有这一句会出错,必须将以前的选择清理掉 pmc.select(clear=True) for i in range(0, len(mesh_selcte_sets)): shader_name = "p_shader{0}".format(int(i)) new_shader = pmc.shadingNode("lambert", asShader=True, name=shader_name) new_shadinggroup = pmc.sets(renderable=True, noSurfaceShader=True, empty=True, name='{}_SG'.format(shader_name)) pmc.connectAttr(new_shader.outColor, new_shadinggroup.surfaceShader) pmc.select(mesh_selcte_sets[i]) pmc.hyperShade(assign=new_shadinggroup) pmc.select(clear=True)
import pymel.core as pmc import pymel.core.datatypes as pmdt import maya.api.OpenMaya as OpenMaya vertexArray = OpenMaya.MFloatPointArray() v = OpenMaya.MFloatPoint(0.0, 0.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(0.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(1.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(1.0, 0.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(2.0, 1.0, 0.0) vertexArray.append(v) v = OpenMaya.MFloatPoint(2.0, 0.0, 0.0) vertexArray.append(v) polygonCounts = OpenMaya.MIntArray() polygonCounts.append(3) polygonCounts.append(3) polygonCounts.append(3) polygonCounts.append(3) polygonConnects = OpenMaya.MIntArray() polygonConnects.append(0) polygonConnects.append(2) polygonConnects.append(1) polygonConnects.append(0) polygonConnects.append(3) polygonConnects.append(2)
def FLDSMDFR(self, file_gpu, grp): file_gpu.seek(self.mesh_header.mesh_dataStart, 0) self.byte_count = self.mesh_header.vertexCount * self.m0.stride ti_0 = np.fromfile(file_gpu, dtype='B', count=self.byte_count).reshape( (self.mesh_header.vertexCount, self.m0.stride)) for x in cat_list: cat(self.m0.data, x) for p in self.m0.data: g = self.m0.data[p] chunc = data_paver(g["start"], g["end"], self.mesh_header.vertexCount, g["item_subCount"], g["d_type"], ti_0) if p == "POSITION0": self.VA = om2.MFloatPointArray(chunc.tolist()) elif p == "BLENDINDICES": self.bone_ids = chunc.tolist() elif p == "BLENDWEIGHTS": self.weights = chunc.tolist() chunk2_start = self.mesh_header.mesh_dataStart + self.m1.offset byteCount2 = self.mesh_header.vertexCount * self.m1.stride file_gpu.seek(chunk2_start, 0) ti_1 = np.fromfile(file_gpu, dtype='B', count=byteCount2).reshape( (self.mesh_header.vertexCount, self.m1.stride)) for j in self.m1.data: z = self.m1.data[j] chunc = data_paver(z["start"], z["end"], self.mesh_header.vertexCount, z["item_subCount"], z["d_type"], ti_1) if j == "NORMAL0": Normal_Array0 = chunc[:, 0:3].reshape( (self.mesh_header.vertexCount, 3)) Normal_Array = Normal_Array0.tolist() elif j == "TANGENT0": pass elif j == "TEXCOORD0": chunc[:, 1:2] *= -1 chunc[:, 1:2] += 1 uvData0 = chunc.tolist() u0 = zip(*uvData0)[0] v0 = zip(*uvData0)[1] self.uArray0.copy(u0) self.vArray0.copy(v0) elif j == "TEXCOORD1": uvData1 = chunc.tolist() u1 = zip(*uvData1)[0] v1 = zip(*uvData1)[1] self.uArray1.copy(u1) self.vArray1.copy(v1) elif j == "TEXCOORD2": uvData2 = chunc.tolist() u2 = zip(*uvData2)[0] v2 = zip(*uvData2)[1] self.uArray2.copy(u2) self.vArray2.copy(v2) elif j == "TEXCOORD3": uvData3 = chunc.tolist() u3 = zip(*uvData3)[0] v3 = zip(*uvData3)[1] self.uArray3.copy(u3) self.vArray3.copy(v3) elif j == "NORMAL4FACTORS0": pass elif j == "NORMAL2FACTORS0": pass mesh = om2.MFnMesh() ShapeMesh = cmds.group(em=True) parentOwner = get_mobject(ShapeMesh) meshMObj = mesh.create(self.VA, self.pCounts, self.faces, uValues=self.uArray0, vValues=self.vArray0, parent=parentOwner) cmds.sets(ShapeMesh, e=True, forceElement='initialShadingGroup') defaultUVSetName = '' defaultUVSetName = mesh.currentUVSetName(-1) mesh.setUVs(self.uArray0, self.vArray0, defaultUVSetName) mesh.assignUVs(self.pCounts, self.faces, defaultUVSetName) if len(self.uArray1) > 1: mesh.createUVSet('map2') mesh.setUVs(self.uArray1, self.vArray1, 'map2') mesh.assignUVs(self.pCounts, self.faces, 'map2') if len(self.uArray2) > 1: mesh.createUVSet('map3') mesh.setUVs(self.uArray2, self.vArray2, 'map3') mesh.assignUVs(self.pCounts, self.faces, 'map3') if len(self.uArray3) > 1: mesh.createUVSet('map4') mesh.setUVs(self.uArray3, self.vArray3, 'map4') mesh.assignUVs(self.pCounts, self.faces, 'map4') vertexIds = range(self.mesh_header.vertexCount) self.NA = om2.MVectorArray(Normal_Array) mesh.setVertexNormals(self.NA, vertexIds, space=om2.MSpace.kWorld) cmds.rename(self.name) s1 = cmds.ls(sl=1) self.s2 = s1[0] if cmds.objExists(self.file_name): cmds.parent(self.s2, self.file_name) else: cmds.group(em=True, name=self.file_name) if cmds.objExists(grp): cmds.parent(self.file_name, grp) cmds.parent(self.s2, self.file_name) self.shapeName = self.s2.encode('ascii', 'ignore')
def moveVtx(self): mfnMesh = Om2.MFnMesh(self.mDag) array = Om2.MFloatPointArray() for k in sorted(self.vtxPositionsNew): array.append(Om2.MFloatPoint(self.vtxPositionsNew[k])) mfnMesh.setPoints(array , space=Om2.MSpace.kWorld)
def readFile(filepath): files = path_wrangler(filepath) files.get_files() md = open(files.data['uexp'], 'rb') ua = open(files.data['uasset'], 'rb') meshName = files.data['meshName'] submesh_name = files.data['submesh_name'] arm = False weightData = {} Weight_array = [] vertexArray = [] NA = [] normal_array = [] faces = [] U0 = om2.MFloatArray() V0 = om2.MFloatArray() U1 = om2.MFloatArray() V1 = om2.MFloatArray() U2 = om2.MFloatArray() V2 = om2.MFloatArray() U3 = om2.MFloatArray() V3 = om2.MFloatArray() U4 = om2.MFloatArray() V4 = om2.MFloatArray() U5 = om2.MFloatArray() V5 = om2.MFloatArray() t1 = time.time() names = readUasset(ua) pattern0 = re.compile(b'\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00........') for x in xrange(20000): s1 = struct.unpack("18s", md.read(18))[0] if pattern0.match(s1): c0 = struct.unpack("<L", md.read(4))[0] c1 = struct.unpack("<L", md.read(4))[0] c2 = struct.unpack("<L", md.read(4))[0] c3 = struct.unpack("<L", md.read(4))[0] c4 = struct.unpack("<L", md.read(4))[0] if (c0 and c1 and c2 and c3 and c4 > 1000000000): break else: md.seek(-20, 1) md.seek(-17, 1) materialCount = struct.unpack("<L", md.read(4))[0] materials = {} for m in xrange(materialCount): materials[m] = {} materials[m]['val0'] = struct.unpack("<l", md.read(4))[0] stringIndex = struct.unpack("<L", md.read(4))[0] unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("<L", md.read(4))[0] unk2 = struct.unpack("<L", md.read(4))[0] unk3 = struct.unpack("<f", md.read(4))[0] unk4 = struct.unpack("<f", md.read(4))[0] unk5 = struct.unpack("<L", md.read(4))[0] unk6 = struct.unpack("<L", md.read(4))[0] materials[m]['name'] = names[stringIndex] boneCount = struct.unpack("<L", md.read(4))[0] joint_data = {} bt = np.empty([1, boneCount], dtype='U32') for i in xrange(boneCount): string_index = struct.unpack("<L", md.read(4))[0] jName = names[string_index] unk = struct.unpack("<L", md.read(4))[0] parent = struct.unpack("<l", md.read(4))[0] joint_data[i] = {"name": jName, "parent": parent} bt[0, i] = jName boneCount2 = struct.unpack("<L", md.read(4))[0] bone_list = [] boneArray = [] for k in xrange(boneCount2): m1 = struct.unpack("<10f", md.read(40)) boneName = joint_data[k]["name"] BNparent = joint_data[k]["parent"] boneArray.append(boneName) BNps = om.MVector(-m1[5], -m1[6], m1[4]) BNrt = om.MQuaternion(m1[1], m1[2], -m1[0], -m1[3]) BNsc = om.MVector(-m1[8], -m1[9], -m1[7]) if BNparent == -1: cmds.select(clear=True) else: pm.select(bone_list[BNparent]) newBone = pm.joint(p=(0, 0, 0), name=boneName, radius=0.1) newBone.setTranslation(BNps) newBone.setOrientation(BNrt) newBone.setScale(BNsc) bone_list.append(newBone) arm = True boneCount3 = struct.unpack("<L", md.read(4))[0] md.seek(boneCount3 * 12, 1) vertexGroups = {} unk0 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("B", md.read(1))[0] unk2 = struct.unpack("B", md.read(1))[0] groupCount = struct.unpack("<L", md.read(4))[0] for m in xrange(groupCount): z1 = struct.unpack("<H", md.read(2))[0] ID = struct.unpack("<H", md.read(2))[0] md.seek(24, 1) vertexGroups[ID] = {'range': 0, 'bones': []} # pragma region bone palette start = struct.unpack("<L", md.read(4))[0] count = struct.unpack("<L", md.read(4))[0] bt = np.empty([1, count], dtype='U32') for bn in xrange(count): bid = struct.unpack("<H", md.read(2))[0] vertexGroups[ID]['bones'].append(bid) bt[0, bn] = joint_data[bid]["name"] # pragma endregion bone palette size = struct.unpack("<L", md.read(4))[0] stop = start + size vertexGroups[ID]['range'] = range(start, stop) vertexGroups[ID]["start"] = start vertexGroups[ID]["stop"] = stop vertexGroups[ID]["size"] = size vertexGroups[ID]["names"] = bt md.seek(34, 1) FFx4 = readHexString(md, 4) flag = struct.unpack("<L", md.read(4))[0] if flag: # extra data for this group count = struct.unpack("<L", md.read(4))[0] md.seek(count * 16, 1) else: null = struct.unpack("<L", md.read(4))[0] unk = struct.unpack("B", md.read(1))[0] checkHere = md.tell() stride = struct.unpack("<L", md.read(4))[0] fCount = struct.unpack("<L", md.read(4))[0] faceByteCount = fCount * stride fi = np.fromfile(md, dtype='B', count=faceByteCount) if stride == 4: fi_0 = fi.view(dtype='<L').reshape(fCount // 3, 3) elif stride == 2: fi_0 = fi.view(dtype='<H').reshape(fCount // 3, 3) fi_1 = fi_0.ravel() faces = tuple(fi_1) pCounts = [3] * (len(faces) // 3) gh = pCounts[0] unkCount = struct.unpack("<L", md.read(4))[0] md.seek(unkCount * 2, 1) unk = struct.unpack("<L", md.read(4))[0] vertexCount = struct.unpack("<L", md.read(4))[0] boneCount = struct.unpack("<L", md.read(4))[0] md.seek(boneCount * 2, 1) null0 = struct.unpack("<L", md.read(4))[0] null1 = struct.unpack("<L", md.read(4))[0] uv_count = struct.unpack("<L", md.read(4))[0] unk0 = struct.unpack("<H", md.read(2))[0] uv_count2 = struct.unpack("<L", md.read(4))[0] null2 = struct.unpack("<L", md.read(4))[0] unk1 = struct.unpack("<f", md.read(4))[0] unk2 = struct.unpack("<f", md.read(4))[0] unk3 = struct.unpack("<f", md.read(4))[0] null3 = struct.unpack("<L", md.read(4))[0] null4 = struct.unpack("<L", md.read(4))[0] null5 = struct.unpack("<L", md.read(4))[0] vStride = struct.unpack("<L", md.read(4))[0] vCount = struct.unpack("<L", md.read(4))[0] byteCount = vCount * vStride vi = np.fromfile(md, dtype='B', count=byteCount).reshape((vCount, vStride)) pos = vi[:, 8:20].ravel().view(dtype='<f').reshape((vCount, 3)) pos[:, [0, 2]] = pos[:, [2, 0]] pos[:, [0, 1]] = pos[:, [1, 0]] pos[:, [2]] *= -1 positions = pos.tolist() VA = om2.MFloatPointArray(positions) if uv_count > 0: uvData_ = vi[:, 20:24].ravel().view(dtype='<f2').reshape((vCount, 2)) uvData_[:, 1:2] *= -1 uvData_[:, 1:2] += 1 uvData = tuple(map(tuple, uvData_)) u = zip(*uvData)[0] v = zip(*uvData)[1] U0.copy(u) V0.copy(v) if uv_count > 1: uvData_ = vi[:, 24:28].ravel().view(dtype='<f2').reshape((vCount, 2)) uvData_[:, 1:2] *= -1 uvData_[:, 1:2] += 1 uvData = tuple(map(tuple, uvData_)) u = zip(*uvData)[0] v = zip(*uvData)[1] U1.copy(u) V1.copy(v) if uv_count > 2: uvData_ = vi[:, 28:32].ravel().view(dtype='<f2').reshape((vCount, 2)) uvData_[:, 1:2] *= -1 uvData_[:, 1:2] += 1 uvData = tuple(map(tuple, uvData_)) u = zip(*uvData)[0] v = zip(*uvData)[1] U2.copy(u) V2.copy(v) if uv_count > 3: uvData_ = vi[:, 32:36].ravel().view(dtype='<f2').reshape((vCount, 2)) uvData_[:, 1:2] *= -1 uvData_[:, 1:2] += 1 uvData = tuple(map(tuple, uvData_)) u = zip(*uvData)[0] v = zip(*uvData)[1] U3.copy(u) V3.copy(v) if uv_count > 4: uvData_ = vi[:, 36:40].ravel().view(dtype='<f2').reshape((vCount, 2)) uvData_[:, 1:2] *= -1 uvData_[:, 1:2] += 1 uvData = tuple(map(tuple, uvData_)) u = zip(*uvData)[0] v = zip(*uvData)[1] U4.copy(u) V4.copy(v) mesh = om2.MFnMesh() ShapeMesh = cmds.group(em=True) parentOwner = get_mobject(ShapeMesh) meshMObj = mesh.create(VA, pCounts, faces, uValues=U0, vValues=V0, parent=parentOwner) cmds.sets(ShapeMesh, e=True, forceElement='initialShadingGroup') cmds.polyUVSet(rename=True, newUVSet='map_0', uvSet=mesh.currentUVSetName(-1)) mesh.setUVs(U0, V0, 'map_0') mesh.assignUVs(pCounts, faces, 'map_0') cmds.rename(meshName) s1 = cmds.ls(sl=1) s2 = s1[0] shapeName = s2.encode('ascii', 'ignore') if uv_count > 1: mesh.createUVSet('map_1') mesh.setUVs(U1, V1, 'map_1') mesh.assignUVs(pCounts, faces, 'map_1') if uv_count > 2: mesh.createUVSet('map_2') mesh.setUVs(U2, V2, 'map_2') mesh.assignUVs(pCounts, faces, 'map_2') if uv_count > 3: mesh.createUVSet('map_3') mesh.setUVs(U3, V3, 'map_3') mesh.assignUVs(pCounts, faces, 'map_3') if uv_count > 4: mesh.createUVSet('map_4') mesh.setUVs(U4, V4, 'map_4') mesh.assignUVs(pCounts, faces, 'map_4') unkS = struct.unpack("<H", md.read(2))[0] extraBoneWeights = struct.unpack("<L", md.read(4))[0] wCount = struct.unpack("<L", md.read(4))[0] stride = struct.unpack("<L", md.read(4))[0] wCount2 = struct.unpack("<L", md.read(4))[0] subStride = int(stride / 2) clusterName = shapeName + '_' + 'skinCluster' pm.skinCluster(boneArray[:], shapeName, sm=1, mi=8, omi=1, n=clusterName) skin = mm.eval('findRelatedSkinCluster "' + s2 + '"') sel = om.MSelectionList() sel.add(shapeName) meshMObject = om.MObject() sel.getDependNode(0, meshMObject) sel2 = om.MSelectionList() sel2.add(skin) skinMObject = om.MObject() sel2.getDependNode(0, skinMObject) FnSkin = oma.MFnSkinCluster(skinMObject) dag_path, skinMObject = get_skin_dag_path_and_mobject(FnSkin) weights = om.MDoubleArray() influence_paths = om.MDagPathArray() influence_count = FnSkin.influenceObjects(influence_paths) components_per_influence = weights.length() / influence_count # influences unused_influences = list() influences = [ influence_paths[inf_count].partialPathName() for inf_count in xrange(influence_paths.length()) ] wSize = vCount * influence_count weights = om.MDoubleArray(wSize, 0.0) w_byteCount = wCount * stride wi = np.fromfile(md, dtype='B', count=w_byteCount).reshape( (wCount, stride)) wi_b = wi[:, :subStride].ravel().view().reshape((wCount, subStride)) wi_w = wi[:, subStride:stride].ravel().view().reshape( (wCount, subStride)).astype(np.float64) wi_w /= 255.0 def do_stuff(n): fg = influences.index(L[n]) idx = fg + (j * influence_count) weights[idx] = W[n] for h in xrange(len(vertexGroups)): crnt_grp = vertexGroups[h] g_names = crnt_grp["names"] g_range = crnt_grp["range"] for j in g_range: Wt = np.trim_zeros(wi_w[j], 'b') W = tuple(Wt) a = Wt.shape[0] ids = wi_b[j, :a] L = tuple(g_names[0, ids]) map(do_stuff, range(len(L))) influence_array = om.MIntArray(influence_count) m_util.createIntArrayFromList(range(influence_count), influence_array) FnSkin.setWeights(dag_path, skinMObject, influence_array, weights, False) createMaterials(files, vertexGroups, materials, shapeName) pm.select(shapeName) cmds.viewFit() elapsed = time.time() - t1 return elapsed md.close() ua.close()
def mesh_generator(source_verts, source_polys, source_norms, materials, source_bones, gen_bones, settings): vertex_count = len(source_verts) face_count = len(source_polys) vertices = OpenMaya.MFloatPointArray() for i in range(len(source_verts)): vert = source_verts[i] vertices.append(OpenMaya.MFloatPoint(vert.x, vert.y, vert.z)) face_vertexes = OpenMaya.MIntArray() vertex_indexes = OpenMaya.MIntArray() for i in range(len(source_polys)): poly = source_polys[i] face_vertexes.append(poly.numVertex) vertex_indexes += poly.vertex mesh_object = OpenMaya.MObject() mesh = OpenMaya.MFnMesh() mesh.create(vertices, face_vertexes, vertex_indexes, [], [], mesh_object) mesh.updateSurface() py_obj = pm.ls(mesh.name())[0] if settings.use_palette: face_list = [] for i in range(len(materials)): faces = [materials[i]] for j in range(face_count): if source_polys[j].colour == materials[i]: faces.append(j) if len(faces) > 0: face_list.append(faces) for i in range(len(face_list)): if len(face_list[i]) == 1: continue m_faces = [] for j in range(len(face_list[i])): if j == 0: continue m_faces.append(py_obj.f[face_list[i][j]]) sg = "paletteSG" + str(face_list[i][0]) pm.sets(sg, edit=True, forceElement=m_faces) else: pm.sets("initialShadingGroup", edit=True, forceElement=py_obj) space = OpenMaya.MSpace.kObject for i in range(len(source_norms)): norm = source_norms[i] normal = OpenMaya.MVector(norm.x, norm.y, norm.z) mesh.setVertexNormal(normal, i, space) if settings.use_rigging: cluster = pm.skinCluster(gen_bones[0], py_obj, tsb=True, mi=1, hmf=1.0, dr=10, nw=0) # create vertex groups vertex_groups = [] for i in range(len(source_bones)): if i != 0: pm.skinCluster(cluster, edit=True, ai=gen_bones[i], tsb=True, hmf=1.0, dr=10, wt=0) group = [] for j in range(vertex_count): if source_verts[j].bone == i: group.append(j) vertex_groups.append(group) # set influences transform_zeros = [] for i in range(len(source_bones)): value = [gen_bones[i], 0] transform_zeros.append(value) for i in range(len(vertex_groups)): group = vertex_groups[i] pm.select(clear=True) # select vertices for j in range(len(group)): pm.select(py_obj.vtx[group[j]], add=True) for j in range(len(transform_zeros)): transform_zeros[j][1] = 1 if i == j else 0 pm.skinPercent(cluster, transformValue=transform_zeros, nrm=True) return mesh.name()
def addUIDrawables(self, objPath, drawManager, frameContext, data): DEBUG_C = 1 if (DEBUG_C): print( "glDrawDrawOverride________________________________________addUIDrawables - GET DATA" ) #glDrawData* data = (glDrawData*)dataRaw; #if (!data) { return; } cameraFn = ompy.MFnCamera(data.cameraPath) cameraTrsf = ompy.MFnDagNode(cameraFn.parent(0)) camMatrix = MMatrixToMFloatMatrix(cameraTrsf.transformationMatrix()) camPlaneNearDistance = cameraFn.nearClippingPlane camPlaneFarDistance = cameraFn.farClippingPlane if (DEBUG_C): print( "glDrawDrawOverride________________________________________addUIDrawables - DRAW" ) drawManager.beginDrawable() iCoords = 0 exitDrawing = False for i in range(0, len(data.shapes)): #________________________________________GET COORDS FOR BUILDING ONE SHAPE nbrElementForBuild = self.shapeToNbrElemForBuild[data.shapes[i]] coordsForBuild = ompy.MFloatPointArray() ssOffsetsForBuild = ompy.MFloatVectorArray() for j in range(0, nbrElementForBuild): if (len(data.coords) <= iCoords): exitDrawing = True break coordsForBuild.append(data.coords[iCoords]) ssOffsetsForBuild.append(data.screenSpaceOffsets[iCoords]) iCoords += 1 if (exitDrawing == True): break #________________________________________DRAW BUILD CONVERT COORDS distIncr = 0.001 foregroundDist = camPlaneNearDistance + 0.02 backgroundDist = camPlaneFarDistance - 0.02 coords = ompy.MFloatPointArray() size = 1.0 thickness = 1.0 if ((data.drawPlaneMode == 1) and (0 < coordsForBuild.length())): #FOREGROUND coords = snapCoordsOnCameraPlane(camMatrix, foregroundDist, coordsForBuild) size = snapLengthOnCameraPlane(camMatrix, foregroundDist, coordsForBuild[0], data.sizes[i]) #thickness = data.thicknesses[i] foregroundDist += distIncr elif ((data.drawPlaneMode == 2) and (0 < coordsForBuild.length())): #sBACKGROUND coords = snapCoordsOnCameraPlane(camMatrix, backgroundDist, coordsForBuild) size = snapLengthOnCameraPlane(camMatrix, backgroundDist, coordsForBuild[0], data.sizes[i]) #thickness = data.thicknesses[i] backgroundDist -= distIncr else: coords = coordsForBuild size = data.sizes[i] #thickness = data.thicknesses[i] ssOffsets = ompy.MFloatVectorArray(ssOffsetsForBuild) #________________________________________DRAW SHAPE if (self.shapesNames[data.shapes[i]] == "segment"): glDrawSegments(drawManager, camMatrix, coords, ssOffsets, data.colors[i], 0, 1.0) elif (self.shapesNames[data.shapes[i]] == "triangle"): pass #glDrawTriangles( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.pColors[i]) elif (self.shapesNames[data.shapes[i]] == "pointTriangle"): pass #glDrawPointTriangle( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "pointSquare"): pass #glDrawPointSquare( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "pointCircle"): pass #glDrawPointCircle( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "pointStar"): pass #glDrawPointStar( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "pointCross"): pass #glDrawPointCross( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "vector"): pass #glDrawVector( drawManager, camMatrix, coords, ssOffsets, data.colors[i], data.fills[i], size, thickness) elif (self.shapesNames[data.shapes[i]] == "text"): glDrawText(drawManager, camMatrix, coords, ssOffsets, data.names[i], data.colors[i], True, size, 1.0) drawManager.endDrawable()