def group_all_proxies(self):
self.proxy_group_name = 'proxies_grp'
try:
om.MGlobal.getSelectionListByName(self.proxy_group_name)
dg_mod = om.MDagModifier()
dg_mod.commandToExecute('parent ' + self.proxy_groups + ' ' + self.proxy_group_name)
dg_mod.doIt()
except:
dg_mod = om.MDagModifier()
dg_mod.commandToExecute('group -w -n ' + self.proxy_group_name + ' ' + self.proxy_groups)
dg_mod.doIt()
def undoIt(self):
if self._testNode is None:
raise ValueError("failed to undo")
mod = om2.MDagModifier()
mod.deleteNode(self._testNode.object())
mod.doIt()
self._testNode = None
def setParent(child, newParent, maintainOffset=False):
"""Sets the parent for the given child
:param child: the child node which will have its parent changed
:type child: om2.MObject
:param newParent: The new parent for the child
:type newParent: om2.MObject
:param maintainOffset: if True then the current transformation is maintained relative to the new parent
:type maintainOffset: bool
:rtype bool
"""
newParent = newParent or om2.MObject.kNullObj
if child == newParent:
return False
dag = om2.MDagModifier()
if maintainOffset:
if newParent == om2.MObject.kNullObj:
offset = getWorldMatrix(child)
else:
start = getWorldMatrix(newParent)
end = getWorldMatrix(child)
offset = end * start.inverse()
dag.reparentNode(child, newParent)
dag.doIt()
if maintainOffset:
setMatrix(child, offset)
return True
def create(self):
self._segments = []
if self._modifier is None:
self._modifier = om.MDagModifier()
if self._qtm_settings is None and self._qtm.connected:
self._qtm_settings = self._qtm.get_settings("skeleton")
if (self._qtm_settings is not None
and self._qtm_settings.get("Skeletons", None) is not None):
self._skeletons = self._qtm_settings["Skeletons"].get(
"Skeleton", [])
if type(self._skeletons) != type([]):
self._skeletons = [self._skeletons]
for skeleton_index, skeleton in enumerate(self._skeletons):
if not cmds.namespace(exists=skeleton["@Name"]):
cmds.namespace(add=skeleton["@Name"])
self._segments.append({})
self.add_segment(skeleton_index,
skeleton["Segments"]["Segment"], None)
self._modifier.doIt()
def create(self):
modifier = om.MDagModifier()
if self._marker_groups is not None:
for group_name, marker_group in self._marker_groups.items():
parent = MayaUtil.get_node_by_name(group_name)
if parent is None:
parent = modifier.createNode("transform")
modifier.renameNode(parent, group_name)
modifier.doIt()
for i, marker in enumerate(marker_group):
locator = MayaUtil.get_node_by_name(marker["Name"])
if locator is None:
locator = modifier.createNode("locator")
modifier.renameNode(locator, marker["Name"])
modifier.reparentNode(locator, parent)
modifier.doIt()
transformFn = om.MFnTransform(locator)
self._markers[marker["Index"]]["locator"] = locator
self._markers[marker["Index"]]["transformFn"] = transformFn
def undoIt(self):
dg_mod = om.MDagModifier()
if self.proxy_group_name != '':
dg_mod.commandToExecute('delete ' + self.proxy_group_name)
dg_mod.doIt()
om.MGlobal.setActiveSelectionList(self.selection_prev,
om.MGlobal.kReplaceList)
def parentAPI(source, target, absolute=True):
# TODO: implement undo
mSource = nodeToMObject(source)
if absolute:
srcFnDependencyNode = om.MFnDependencyNode(mSource)
worldMatrixPlug = srcFnDependencyNode.findPlug('worldMatrix', False).elementByLogicalIndex(0)
matrixMObj = worldMatrixPlug.asMObject()
fnMatrixData = om.MFnMatrixData(matrixMObj)
srcWMtx = fnMatrixData.transformation()
mDagMod = om.MDagModifier()
if target:
mTarget = nodeToMObject(target)
mDagMod.reparentNode(mSource, mTarget)
else:
mDagMod.reparentNode(mSource)
mDagMod.doIt()
fnDagNode = om.MFnDagNode(mSource)
if absolute:
srcFnTransform = om.MFnTransform(fnDagNode.getPath())
# srcFnTransform = om.MFnTransform(mSource)
# noinspection PyUnboundLocalVariable
srcFnTransform.setTranslation(srcWMtx.translation(om.MSpace.kWorld), om.MSpace.kWorld)
srcFnTransform.setRotation(srcWMtx.rotation(asQuaternion=True), om.MSpace.kWorld)
srcFnTransform.setScale(srcWMtx.scale(om.MSpace.kWorld))
srcFnTransform.setShear(srcWMtx.shear(om.MSpace.kWorld))
return fnDagNode.fullPathName()
def groupProxies(self,node):
dgMod = om.MDagModifier()
proxiesString = ''
for proxy in self.proxyInfluencePairs.keys():
proxiesString = proxiesString + proxy.partialPathName() + ' '
dgMod.commandToExecute('group -w -n ' + node.partialPathName() + '_proxies_grp ' + proxiesString)
dgMod.doIt()
self.proxyGroups = self.proxyGroups + node.partialPathName() + '_proxies_grp '
def create(dagtype = "transform", name = "default"): mdagmod = om.MDagModifier() mobj = mdagmod.createNode(dagtype) mdagmod.doIt() dagnode = DagNode(mobj) dagnode.setName(name) return dagnode
def create_proxy_group(self, node):
dg_mod = om.MDagModifier()
# build a string containing all the proxy names to be used for grouping
proxies_str = ''
for proxy in self.proxy_influence_pairs.keys():
proxies_str = proxies_str + proxy + ' '
dg_mod.commandToExecute('group -w -n ' + node.partialPathName() + '_proxies_grp ' + proxies_str)
dg_mod.doIt()
self.proxy_groups = self.proxy_groups + node.partialPathName() + '_proxies_grp '
def __init__(self):
om2.MPxCommand.__init__(self)
self.dagModifier = om2.MDagModifier()
self.dgModifier = om2.MDGModifier()
self.selList = om2.MSelectionList()
self.matchScale = True
self.matchRotation = True
self.matchTranslation = True
self.origTransforms = []
def undoIt(self): dgModifier = om.MDGModifier() dagModifier = om.MDagModifier() dgModifier.deleteNode(self.caveNode) dgModifier.deleteNode(self.loftNode) dgModifier.deleteNode(self.loftTessellateNode) dgModifier.deleteNode(self.planarNode) dgModifier.deleteNode(self.planarTesselateNode) dagModifier.deleteNode(self.loftMeshTransformNode) dgModifier.doIt() dagModifier.doIt()
def createDAGNode(dagNodeType, nodeName="newDAGNode"):
"""
Create a new new DAG node of type with name
:param createNodeType: str - node type
:param nodeName: str
:return: MObject - new node MObject
"""
dagMod = om2.MDagModifier()
newDAGNode = dagMod.createNode(dagNodeType)
dagMod.renameNode(newDAGNode, nodeName + "_" + dagNodeType)
dagMod.doIt()
return newDAGNode
def delete(node):
"""Delete the given nodes
:param node:
"""
if not isValidMObject(node):
return
lockNode(node, False)
unlockedAndDisconnectConnectedAttributes(node)
mod = om2.MDagModifier()
mod.deleteNode(node)
mod.doIt()
def create(self):
if self._bodies == None:
return
modifier = om.MDagModifier()
for body in self._bodies:
parent = MayaUtil.get_node_by_name(body["Name"])
if parent is None:
parent = modifier.createNode("transform")
modifier.renameNode(parent, body["Name"])
modifier.doIt()
transformFn = om.MFnTransform(parent)
for i, point in enumerate(body["Point"]):
point_name = body["Name"] + "_" + str(i)
locator = MayaUtil.get_node_by_name(point_name)
if locator is None:
locator = modifier.createNode("locator")
modifier.renameNode(locator, point_name)
modifier.reparentNode(locator, parent)
modifier.doIt()
pointTransformFn = om.MFnTransform(locator)
translation = None
if self._up_axis == "y":
translation = om.MVector(
-float(point["X"]) * self._unit_conversion,
float(point["Z"]) * self._unit_conversion,
float(point["Y"]) * self._unit_conversion,
)
else:
translation = om.MVector(
float(point["X"]) * self._unit_conversion,
float(point["Y"]) * self._unit_conversion,
float(point["Z"]) * self._unit_conversion,
)
pointTransformFn.setTranslation(translation,
om.MSpace.kTransform)
self._bodies[body["Index"]].update({
"transform": parent,
"transformFn": transformFn
})
def groupAllProxies(self):
rigNode = self.getDagPath('*RIG')
proxyGroupName = ''
if rigNode:
proxyGroupName = rigNode.partialPathName()
if proxyGroupName != '':
proxyGroupName += '_proxies_grp'
else:
proxyGroupName = 'proxies_grp'
dgMod = om.MDagModifier()
dgMod.commandToExecute('group -w -n ' + proxyGroupName +' ' + self.proxyGroups)
dgMod.doIt()
def _initialize(self):
char_instance = om2.MFnTransform().create(om2.MObject.kNullObj)
deform_instance = om2.MFnTransform().create(om2.MObject.kNullObj)
globalTransform_instance = om2.MFnTransform().create(
om2.MObject.kNullObj)
geometry_instance = om2.MFnTransform().create(om2.MObject.kNullObj)
dagMod = om2.MDagModifier()
dagMod.renameNode(char_instance, "%s_char" % self._createName)
dagMod.renameNode(deform_instance, "deform_hrc")
dagMod.renameNode(globalTransform_instance, "globalTransform_hrc")
dagMod.renameNode(geometry_instance, "geometry_hrc")
dagMod.reparentNode(deform_instance, char_instance)
dagMod.reparentNode(globalTransform_instance, char_instance)
dagMod.reparentNode(geometry_instance, char_instance)
dagMod.doIt()
cmds.setAttr(
'%s.useOutlinerColor' %
om2.MDagPath.getAPathTo(char_instance).fullPathName(), True)
cmds.setAttr(
'%s.outlinerColor' %
om2.MDagPath.getAPathTo(char_instance).fullPathName(), 0.0, 1.0,
0.0)
self._data["CharName"] = self._createName
self._data["Instance"] = char_instance
self._data["Content"] = collections.OrderedDict()
self._data["Content"]["Deform"] = collections.OrderedDict()
self._data["Content"]["Deform"]["Instance"] = deform_instance
self._data["Content"]["Deform"][
"DeformationLayers"] = collections.OrderedDict()
self._data["Content"]["GlobalTransform"] = collections.OrderedDict()
self._data["Content"]["GlobalTransform"][
"Instance"] = globalTransform_instance
self._data["Content"]["Geometry"] = collections.OrderedDict()
self._data["Content"]["Geometry"]["Instance"] = geometry_instance
self._data["Info"] = collections.OrderedDict()
self._data["Info"]["Created"] = datetime.datetime.now().strftime(
"%b %d, %Y - %I:%M:%S %p")
self._data["Info"]["LastModified"] = datetime.datetime.now().strftime(
"%b %d, %Y - %I:%M:%S %p")
# self._data["Info"]["UseCustomTech"] = self.useCustomTech
self._deformData = self._data["Content"]["Deform"]
self._globalTransformData = self._data["Content"]["GlobalTransform"]
self._geometryData = self._data["Content"]["Geometry"]
return True
def redoIt(self):
# Create a dg and dag modifier
dgModifier = om.MDGModifier()
dagModifier = om.MDagModifier()
# Create the boolean node
self.booleanNode = dgModifier.createNode("polyCBoolOp")
dgModifier.renameNode(self.booleanNode, self.name)
# Get the name of the node
dgModifier.doIt()
nodeName = om.MFnDependencyNode(self.booleanNode).name()
# Connect the attributes
numShapes = len(self.shapeNames)
for i in range(numShapes):
mc.connectAttr(self.shapeNames[i] + ".outMesh", nodeName + ".inputPoly[" + str(i) + "]", f=True)
mc.connectAttr(self.shapeNames[i] + ".worldMatrix[0]", nodeName + ".inputMat[" + str(i) + "]", f=True)
def create(self):
modifier = om.MDagModifier()
self._segments = {}
if self._qtm_settings is None and self._qtm.connected:
self._qtm_settings = self._qtm.get_settings("skeleton")
if (
self._qtm_settings is not None
and self._qtm_settings.get("Skeletons", None) is not None
):
self._skeletons = self._qtm_settings["Skeletons"].get("Skeleton", [])
if type(self._skeletons) != type([]):
self._skeletons = [self._skeletons]
for skeleton in self._skeletons:
create = True
for segment in skeleton["Segment"]:
segment_name = skeleton["@Name"] + "_" + segment["@Name"]
j = MayaUtil.get_node_by_name(segment_name)
if j is None:
j = modifier.createNode("joint")
modifier.renameNode(j, segment_name)
else:
create = False
transformFn = om.MFnTransform(j)
self._segments[int(segment["@ID"])] = {
"MObject": j,
"transformFn": transformFn,
}
if "@Parent_ID" in segment:
modifier.reparentNode(
j, self._segments[int(segment["@Parent_ID"])]["MObject"]
)
if create:
self._assume_t_pose(segment)
modifier.doIt()
def rename_mobj(mobj, name):
"""Rename the given MObject.
Note:
This is currently NOT undoable!!! Therefore be careful!
Args:
mobj (MObject): Node to be renamed.
name (str): New name for the node.
Returns:
str: New name of renamed mobj
"""
dag_modifier = OpenMaya.MDagModifier()
dag_modifier.renameNode(mobj, name)
dag_modifier.doIt()
return get_name_of_mobj(mobj)
def renameChar(self, name):
"""
Signature: <Character>.renameChar(name)
Parameters: name - string
Returns:
Description: Change the name of a Character class instance.
"""
if _checkObjectExists(self._data["Instance"]):
dagMod = om2.MDagModifier()
dagMod.renameNode(self._data["Instance"], "%s_char" % name)
dagMod.doIt()
self._data["CharName"] = name
return True
else:
om2.MGlobal.displayError("Cannot find character node.")
return
def createLocAtSelection():
selList = om2.MGlobal.getActiveSelectionList()
mObjs = [selList.getDependNode(idx) for idx in range(selList.length())]
mDagMod = om2.MDagModifier()
for mObj in mObjs:
mObjHandle = om2.MObjectHandle(mObj)
mFn = om2.MFnDependencyNode(mObj)
locMObj = createNode("locator", "{}_LOC".format(mFn.name()), mDagMod)
locMObjHandle = om2.MObjectHandle(locMObj)
mPlug = findPlug(mObjHandle, "worldMatrix")
if mPlug.isArray:
mtxIdxZero = mPlug.elementByLogicalIndex(0)
plugMObj = mtxIdxZero.asMObject()
mFnMtxData = om2.MFnMatrixData(plugMObj)
mMtx = mFnMtxData.matrix()
setAtters(locMObjHandle, mMtx)
def redoIt(self):
# Create a dg and dag modifier
dgModifier = om.MDGModifier()
dagModifier = om.MDagModifier()
# Create the sculpt layer node
self.sculptLayerNode = dgModifier.createNode("SculptLayerNode")
dgModifier.renameNode(self.sculptLayerNode, self.name)
# Get the name of the node
dgModifier.doIt()
nodeName = om.MFnDependencyNode(self.sculptLayerNode).name()
# Set the parameters
mc.setAttr(nodeName + ".sculptStrength", self.sculptStrength)
mc.setAttr(nodeName + ".curveOffset", self.curveOffset)
mc.setAttr(nodeName + ".maxProjectionDistance", self.maxProjection)
# Connect the attributes
mc.connectAttr(self.curveMask + ".worldSpace[0]",
nodeName + ".curveMask")
mc.connectAttr(self.sculptedMesh + ".worldMesh[0]",
nodeName + ".sculptedMesh")
mc.connectAttr(self.terrain + ".worldMesh[0]", nodeName + ".terrain")
def run(child, parent=None, *args, **kwargs):
"""Parent an object to another
:param child: MObject of the child node.
:type child: MObject or str
:param parent: MObject of the parent node.
:type parent: MObject or str or None
"""
dag_mod = om.MDagModifier()
if parent is None:
parent = om.MObject.kNullObj
elif isinstance(parent, str):
parent = get_mobject.run(parent)
if isinstance(child, str):
child = get_mobject.run(child)
dag_mod.reparentNode(child, newParent=parent)
dag_mod.doIt()
def createDagNode(name, nodeType, parent=None):
"""Create's a new dag node and if theres a parent specified then parent the new node
:param name: The new name of the created node
:type name: str
:param nodeType: The node type to create
:type nodeType: str
:param parent: The node the parent the new node to, if the parent is none or MObject.kNullObj then it will parent
to the world, defaults to world
:type parent: MObject or MObject.kNullObj
:return:The newly create nodes mobject
:rtype: MObject
"""
if parent is None or parent.isNull() or parent.apiType() in (om2.MFn.kInvalid, om2.MFn.kWorld):
parent = om2.MObject.kNullObj
command = om2.MDagModifier()
node = command.createNode(nodeType)
command.renameNode(node, name)
command.reparentNode(node, parent)
command.doIt()
return node
def createDeformationLayer(self, name):
"""
Signature: <Character>.createDeformationLayer(name)
Parameters: name - string
Returns:
Description: Create a deformation layer node in the character hierarchy.
"""
if _checkObjectExists(self._deformData["Instance"]):
defLyr = om2.MFnTransform().create(om2.MObject.kNullObj)
dagMod = om2.MDagModifier()
dagMod.renameNode(defLyr, "%s_defLyr" % name)
dagMod.reparentNode(defLyr, self._deformData["Instance"])
dagMod.doIt()
self._deformData["DeformationLayers"][
name] = collections.OrderedDict()
self._deformData["DeformationLayers"][name]["Instance"] = defLyr
self._deformData["DeformationLayers"][name][
"Components"] = collections.OrderedDict()
return True
else:
om2.MGlobal.displayError("Cannot find character deform node.")
return
transX = locMFn.findPlug("translateX", False)
transY = locMFn.findPlug("translateY", False)
transZ = locMFn.findPlug("translateZ", False)
transX.setFloat(trans.x)
transY.setFloat(trans.y)
transZ.setFloat(trans.z)
rotX = locMFn.findPlug("rotateX", False)
rotY = locMFn.findPlug("rotateY", False)
rotZ = locMFn.findPlug("rotateZ", False)
rotX.setFloat(rot.x)
rotY.setFloat(rot.y)
rotZ.setFloat(rot.z)
polyIter.next()
iter.next()
print("Done! Face locator/s created and placed!")
selList = om2.MGlobal.getActiveSelectionList()
componentIDs, typeID = geIDsAndTypes(selList)
mDagMod = om2.MDagModifier()
if typeID == om2.MFn.kMeshVertComponent:
for componentID in componentIDs:
createLocAtVertex(selList, componentID, mDagMod)
elif typeID == om2.MFn.kMeshPolygonComponent:
createLocAtFace(selList, mDagMod)
else:
print("Please select an polygon")
def create_proxies(self, node, mesh_fn, skin_fn):
components = om.MFnSingleIndexedComponent()
try:
skin_influences = skin_fn.influenceObjects()
except:
sys.stderr.write('Object has no influences')
return
self.reset_attr()
num_faces = mesh_fn.numPolygons
poly_iter = om.MItMeshPolygon(node)
# iterates through all the selected mesh faces
computation = om1.MComputation()
computation.beginComputation(True, False)
computation.setProgressRange(0, poly_iter.count())
computation.setProgress(0)
progress_amount = 0
while not poly_iter.isDone():
# initialize average_weights as a zero list with the length of number of influences
self.average_weights = [0] * len(skin_influences)
face_verts = poly_iter.getVertices()
vert_comp = components.create(om.MFn.kMeshVertComponent)
components.addElements(face_verts)
vert_iter = om.MItMeshVertex(node, vert_comp)
# iterates through all the face vertices, computes the max influence per face
while not vert_iter.isDone():
weights, inf_index = skin_fn.getWeights(
node, vert_iter.currentItem())
self.average_face_weights(weights)
vert_iter.next()
self.set_face_weights(poly_iter.index(), self.average_weights,
skin_influences)
computation.setProgress(poly_iter.index())
poly_iter.next(None)
# list holding the num faces, will be used to get the faces that need to be deleted
faces_list = [i for i in range(num_faces)]
computation.endComputation()
for inf, faces in self.faces_weights.iteritems():
mesh_name = node.partialPathName()
proxy_name = mesh_name.split('|')[-1] + '_' + inf + '_proxy'
dg_mod = om.MDagModifier()
dg_mod.commandToExecute('duplicate -n ' + proxy_name + ' ' +
mesh_name)
dg_mod.commandToExecute('parent -w ' + proxy_name)
dg_mod.doIt()
# duplicates the skinned mesh, named as above
mesh_duplicate_dag = self.get_object_path(proxy_name)
self.unlock_channels(mesh_duplicate_dag)
mesh_duplicate_fn = om.MFnMesh(mesh_duplicate_dag)
# faces is read from the self.faces_weights attribute, holds the indexes of the faces that will be kept
faces_to_delete = list(set(faces_list) - set(faces))
if len(faces_to_delete) > 0:
mesh_duplicate_fn.extractFaces(faces_to_delete)
mesh_duplicate_fn.collapseFaces(faces_to_delete)
mesh_duplicate_fn.updateSurface()
# sets the proxy pivot based on the joint position / rotation
self.set_proxy_pivot(mesh_duplicate_dag, inf)
self.proxy_influence_pairs[mesh_duplicate_dag.partialPathName(
)] = self.get_object_path(inf)
self.proxies.append(proxy_name)
self.animate_proxy()
self.create_proxy_group(node)
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)