def cameraFrustum_build(cam_shape):
#make sure a camera is loaded
if cam_shape==0:
cmds.error('no camera loaded...select a camera and load')
else:
#create frustum only if one doesnt already exist
selCamXform = cmds.listRelatives(cam_shape[0], p=1)
prefix = 'frust_'
frustumGrpName = prefix + 'camera_frustum_all_grp'
if cmds.objExists(frustumGrpName)==0:
#create main grp
frustumMainGrp = cmds.group(em=1, n=frustumGrpName);
cmds.setAttr(frustumGrpName + '.tx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ty', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.tz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ry', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sy', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.v', lock=1, keyable=0, channelBox=0)
#create frustum geo
frustumGeo = cmds.polyCube(w=2, h=2, d=2, n=prefix + 'camera_frustum_geo')
cmds.delete(frustumGeo[0], constructionHistory=True)
cmds.parent(frustumGeo[0], frustumMainGrp)
#load plugin "nearestPointOnMesh.mll" if needed and connect
plugin = cmds.pluginInfo('nearestPointOnMesh.mll', q=1, l=1)
if plugin==0:
cmds.loadPlugin('nearestPointOnMesh.mll')
nearNodeName = prefix + 'npomNode'
npomNode = cmds.createNode('nearestPointOnMesh', n=nearNodeName)
cmds.connectAttr(frustumGeo[0] + '.worldMesh', npomNode + '.inMesh')
#create clusters
cmds.select(frustumGeo[0] + '.vtx[4:7]', r=1)
nearCluster = cmds.cluster(n=prefix + 'camera_nearFrustum_cluster')
cmds.select(frustumGeo[0] + '.vtx[0:3]', r=1)
farCluster = cmds.cluster(n=prefix + 'camera_farFrustum_cluster')
#create near/far/camera locs
cameraLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_loc')
cmds.parent(cameraLoc[0], frustumMainGrp)
nearLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_nearFrustum_loc')
cmds.move(0, 0, -1)
farLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_farFrustum_loc')
cmds.move(0, 0, 1)
#parent clusters under loc -- parent locs under camera loc
cmds.parent(nearCluster[1], nearLoc[0])
cmds.parent(farCluster[1], farLoc[0])
cmds.parent(nearLoc[0], cameraLoc[0])
cmds.parent(farLoc[0], cameraLoc[0])
#constrain camera loc to camera
cmds.parentConstraint(selCamXform, cameraLoc, weight=1)
return frustumGeo[0]
def __init__(self, objs = [], vertices = []): self.objs = objs self.vertices = vertices #lattice -divisions 2 3 2 -objectCentered true -ol 1; #mc.select( self.objs, self.vertices ) #CREATION grp = mn.Node( mc.group( n = "head_toon_GRP", em = True ) ) deGrp = mn.Node( mc.group( n = "head_toon_deformer_GRP", em = True ) ) deGrp.parent = grp deGrp.a.v.v = False deGrp.a.v.locked = True latNods = mc.lattice( self.objs, self.vertices, divisions = [ 2,3,2], objectCentered = True, ol = 1, n = 'head_toon_LAT' ) latBase = mn.Node( latNods[2] ) latBase.parent = deGrp lat = mn.Node( latNods[1] ) lat.parent = deGrp #mc.select( lat + ".pt[0:1][2][0]", lat + ".pt[0:1][2][1]" ) topClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][2][0]", lat.shape.name + ".pt[0:1][2][1]", n = 'top_face_toon_CLU' )[1] ) topClus.a.v.v = False topClus.a.v.locked = True #mc.select( lat + ".pt[0:1][1][0]", lat + ".pt[0:1][1][1]" ) midClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][1][0]", lat.shape.name + ".pt[0:1][1][1]", n = 'mid_face_toon_CLU' )[1] ) #mc.select( lat + ".pt[0:1][0][0]", lat + ".pt[0:1][0][1]" ) lowClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][0][0]", lat.shape.name + ".pt[0:1][0][1]", n = 'low_face_toon_CLU' )[1] ) ctl = crv.Curve( "head_toon_CTL" ) ctl = ctl.create( "sphere" ) ctl.a.t.v = topClus.worldPosition mc.makeIdentity( ctl.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) topClus.parent = ctl midClus.parent = deGrp lowClus.parent = deGrp ctl.parent = grp #CONSTRAINS midClus.a.r >> topClus.a.r mc.pointConstraint( topClus.name, lowClus.name, midClus.name, mo = True ) #SCALE FOR MID CLUSTER dist = mn.createNode( 'distanceBetween', n = 'head_toon_DIS' ) ctl.a.worldMatrix >> dist.a.inMatrix1 ctl.a.rp >> dist.a.point1 lowClus.a.worldMatrix >> dist.a.inMatrix2 lowClus.a.rp >> dist.a.point2 mul = mn.createNode( 'multiplyDivide', n = 'head_toon_scale_MUL' ) mul.a.input1.v = [dist.a.distance.v]*3 mul.a.operation.v = 2 dist.a.distance >> mul.a.input2X dist.a.distance >> mul.a.input2Y dist.a.distance >> mul.a.input2Z mul.a.output >> midClus.a.s #AIM CONSTRAINT upLocGrp = mn.Node( mc.group( n = "head_upVector_GRP", em = True ) ) upLocGrp.a.t.v = midClus.worldPosition mc.makeIdentity( upLocGrp.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) upLocGrp.parent = deGrp mc.orientConstraint( ctl.name, lowClus.name, upLocGrp.name, mo = True ) upLoc = mn.Node( mc.spaceLocator( n = 'head_upVector_LOC' )[0] ) upLoc.a.t.v = midClus.worldPosition upLoc.a.tz.v = upLoc.a.tz.v + 5 mc.aimConstraint( topClus.name, midClus.name, mo = True, weight = 1, aimVector = [1, 0, 0], upVector = [0, 1, 0], worldUpType = "object", worldUpObject = upLoc.name ) upLoc.parent = upLocGrp mc.pointConstraint( topClus.name, lowClus.name, upLoc.name, mo = True )
def autoEyebrowGuidePosition(side = None, guideName = None):
objectName = side + "_" + guideName
sel = cmds.ls(os = 1, flatten = 1)
pos = []
cluster = []
# check which type of component is selected and store the position
for t in sel:
i = t
selType = t.split(".")[1][0]
if selType == "e":
vtx = cmds.polyListComponentConversion(i, fe = 1, tv = 1)
cmds.select(vtx)
cls = cmds.cluster()
clsPos = cmds.xform(cls, query = 1, rotatePivot = 1, worldSpace = 1)
pos.append(clsPos)
cluster.append(cls)
elif selType == "f":
vtx = cmds.polyListComponentConversion(i, ff = 1, tv = 1)
cmds.select(vtx)
cls = cmds.cluster()
clsPos = cmds.xform(cls, query = 1, rotatePivot = 1, worldSpace = 1)
pos.append(clsPos)
cluster.append(cls)
elif selType == "v":
cmds.warning("Select in another component mode! We are out of verts dude!!!")
else:
cmds.warning("No components selected dude!!!")
# check if guide group exists
if cluster:
if cmds.objExists(objectName + "_TRN"):
cmds.delete(objectName + "_TRN")
# create the guides
guides = defGuideCmds.defGuideCrv()
guides.__init__(nSpans = len(cluster)-1, curveDegree = 1, offset =.2, offsetVector = [1,0,0], side = side, name = guideName, startPosition = [0,0,0], ctlSize = 10)
cmds.delete("C_curve_TRN")
# delete the cluster
for c in cluster:
cmds.delete(c)
# list all the guides inside the guideName group except the curve
loc = cmds.listRelatives(objectName + "_TRN", allDescendents = 1, type = "transform")[:-1]
# reposition the guides at the vertices place
for i, p in zip(loc, pos):
cmds.xform(i, translation = p, worldSpace = 1)
# mirror the guides
cmds.select(loc)
guides.createMirror()
def __createPoleVectorCtl(self, ankleHandle):
poleVectorCtl = self.importCtl('pole_vector_Ctl')
poleVectorGrp = self.uuid('pole_vector_Grp')
mc.rename('pole_vector_Grp', poleVectorGrp)
theta = 0.4
if '_F_' in self._rootJointShortName or '_M_' in self._rootJointShortName:
mc.setAttr(poleVectorCtl + '.scaleZ', -1)
mc.makeIdentity(poleVectorCtl,
apply=True,
t=True,
r=True,
s=True,
normal=0,
preserveNormals=True)
theta = 0.8
# make sure the poleVectorCtl on the same plane of ankle joint chain
p0 = om.MVector(mc.xform(self._jointChain[0], q=True, t=True, ws=True))
p1 = om.MVector(mc.xform(self._jointChain[1], q=True, t=True, ws=True))
p2 = om.MVector(mc.xform(self._jointChain[2], q=True, t=True, ws=True))
d0 = om.MVector(p1 - p0).normal()
d1 = om.MVector(p1 - p2).normal()
pos = p2 + (d0 + d1) * theta
self._move(poleVectorGrp, [pos.x, pos.y, pos.z], False)
# link pole vector start point to the ankle joint
curveCtl = self.uuid('curveCtl')
mc.curve(n=curveCtl, degree=1, p=[(0, 0, 0), (0, 0, 0)])
clusterStartHandle = mc.cluster('%s.cv[0]' % curveCtl,
n=self.uuid('clusterStart'),
envelope=1)
mc.pointConstraint(ankleHandle,
clusterStartHandle,
offset=(0, 0, 0),
weight=1.0)
clusterEndHandle = mc.cluster('%s.cv[1]' % curveCtl,
n=self.uuid('clusterEnd'),
envelope=1)
mc.pointConstraint(poleVectorCtl,
clusterEndHandle,
offset=(0, 0, 0),
weight=1.0)
mc.makeIdentity(poleVectorGrp,
apply=True,
t=True,
r=True,
s=True,
normal=0,
preserveNormals=True)
mc.parent(clusterStartHandle, clusterEndHandle, curveCtl,
poleVectorGrp)
return poleVectorCtl, poleVectorGrp
def RMCreateClustersOnCurve(self , curve = None):
if curve.__class__ in [str,unicode]:
masterCurve = curve
mode = "single"
#print ("degree:%s",degree)
#print ("spans:%s",spans)
#print ("form:%s",form)
elif curve.__class__ == list:
masterCurve = curve[0]
mode = "multi"
degree = cmds.getAttr (masterCurve + ".degree")
spans = cmds.getAttr (masterCurve + ".spans")
form = cmds.getAttr (masterCurve + ".form")
# Form (open = 0, closed = 1, periodic = 2)
clusterList=[]
if form == 0 or form ==1:
#print "Open Line"
for i in range(0 , (degree + spans)):
cluster = cmds.cluster(masterCurve + ".cv["+str(i)+"]",name=self.NameConv.RMUniqueName ("Character_MD_ClusterOnCurve_cls_rig"))
if mode == "multi":
self.RMAddToCluster(i , curve[1:],cluster)
clusterList.append(cluster[1])
cmds.setAttr(cluster[1]+".visibility",0)
##cmds.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]")
if form == 2:
#print "periodic Line"
for i in range(0,spans):
cluster = cmds.cluster(masterCurve+".cv["+str(i)+"]" ,name = self.NameConv.RMUniqueName ("Character_MD_ClusterOnCurve_cls_rig"))
if mode == "multi":
self.RMAddToCluster(i , curve[1:], cluster)
clusterList.append(cluster[1])
cmds.setAttr(cluster[1]+".visibility",0)
#cmds.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]")
return clusterList
def curveBetweenPoints( pointA, pointB, prefix = 'new', constrainCurve = False ):
'''
creates curve from between two transform nodes or [ x,y,z ]
@param pointA: str, name of transform node or [linear, linear, linear]
@param pointB: str, name of transform node or [linear, linear, linear]
@param prefix: str, prefix for naming objects
@param contrainCurve: bool, constrain the curve with weighted cluster
@return: list(str), curve object
'''
xforms = [ pointA, pointB ]
for xform in xforms:
if len( xform ) > 3:
xform = mc.xform( xform, q = 1, t = 1, ws = 1 )
abCurve = mc.curve( n = prefix + '_crv',d =1, p = [xforms[0],xforms[1]] )
if constrainCurve:
mc.cluster(abCurve + '.cv[0]', n = prefix + 'crvPointA_cls', wn = [pointA, pointA], bs =1)
mc.cluster(abCurve + '.cv[1]', n = prefix + 'crvPointB_cls', wn = [pointB, pointB], bs =1)
return abCurve
def ikSpline_transfer(first, second, up_src_jnt, low_src_jnt):
"""
Create a spline Ik-Handle with the Ik-SplineHandleTool from the supplied spine joints.
It will create 2 cluster paired to the cvs of the driving crv, these clusters will get contrained
to the given src_jnts. One for the upper cluster and one for the lower.
Args:
irst ([Str]): Start joint.
second ([Str]): End joint.
up_src_jnt ([Str]): Src joint to drive upper cluster.
low_src_jnt ([Str]): Src joint to drive lower cluster.
"""
# create ik spline handle
res = cmds.ikHandle(sj=first, ee=second,
sol="ikSplineSolver", pcv=False, ns=4)
sp_handle, sp_effector, sp_curve = res
deg = cmds.getAttr('{0}.degree'.format(sp_curve))
spans = cmds.getAttr('{0}.spans'.format(sp_curve))
cmds.select("{0}.cv[0:{1}]".format(sp_curve, deg))
cmds.select("{0}.cv[{1}:]".format(sp_curve, spans))
# create cluster for upper and lower region
low_cl_name, low_cl_handle = cmds.cluster(
"{0}.cv[0:{1}]".format(sp_curve, deg))
up_cl_name, up_cl_handle = cmds.cluster(
"{0}.cv[{1}:]".format(sp_curve, spans))
# contraint ik spline to joints
for jnt, hndl in [(up_src_jnt, up_cl_handle), (low_src_jnt, low_cl_handle)]:
cmds.parentConstraint(jnt, hndl, mo=True)
cmds.parentConstraint(up_src_jnt, up_cl_handle, mo=True)
cmds.parentConstraint(low_src_jnt, low_cl_handle, mo=True)
def transferCluster(source, target, deformer, handle=False, surfaceAssociation="closestPoint", createNew=True):
'''
This will transfer cluster from one mesh to another. If the target doesn't have a
cluster on it, it will create a new cluster. Then once there is a cluster
We will copy weights over.
:param source: The geomertry you are transfer from
:type source: str
:param target: The geometry you want to transfer to
:type target: str | list
:param surfaceAssociation: How to copy the weights from source to target available values
are "closestPoint", "rayCast", or "closestComponent"
:type surfaceAssociation: str
'''
# do some error checking
if not mc.objExists(source):
raise RuntimeError('The source mesh "{}" does not exist in the current Maya session.'.format(source))
if not isinstance(surfaceAssociation, basestring):
raise TypeError('The surfaceAssociation argument must be a string.')
if deformer:
if not mc.objExists(deformer):
raise RuntimeError("{} doesn't exist in the current Maya session!".format(deformer))
# first we will turn the target into a list if it's not already a list
meshList = rigrepo.libs.common.toList(target)
# make sure we have a cluster on the source mesh
clusterList = list()
for mesh in meshList:
if not mc.objExists(mesh):
mc.warning('The target mesh "{}" does not exist in the current Maya session.'.format(target))
continue
# check to see if there is a cluster already on the target mesh
hist = [node for node in mc.listHistory(mesh, pdo=True, lv=1) if mc.nodeType(node) == "cluster"]
# if there is no cluster, we will create one.
newDeformer = "{}__{}".format(mesh, deformer)
if deformer not in hist and not createNew:
mc.sets(mc.ls("{}.cp[*]".format(mesh))[0], e=True, add="{}Set".format(deformer))
newDeformer = deformer
elif createNew:
if not newDeformer in hist:
if handle:
clsHandle = mc.cluster(deformer, q=True, wn=True)
mc.cluster(mesh, name=newDeformer, wn=[clsHandle, clsHandle], bs=True)
else:
mc.cluster(mesh, name=newDeformer, bs=True)
else:
newDeformer = deformer
clusterList.append(newDeformer)
# now we will transfer the wts
mc.copyDeformerWeights(ss=source, ds=mesh, sd=deformer, dd=newDeformer,
sa=surfaceAssociation, noMirror=True)
return clusterList
def create_line(obj_from="", obj_to="", prefix="", rigModule=None):
"""
Create a template line between two objects
@param obj_from: str, object that the line should start from
@param obj_to: str, object that the line end at
@param prefix: str, prefix to name new objects
@param rigModule: instance of base.module.Module class
@return: str, name of the curve
"""
pos1 = mc.xform(obj_from, q=1, t=1, ws=1)
pos2 = mc.xform(obj_to, q=1, t=1, ws=1)
crv = mc.curve(n=prefix + 'Line_crv', d=1, p=[pos1, pos2])
cls1 = mc.cluster(crv + '.cv[0]',
n=prefix + 'Line1_cls',
wn=[obj_from, obj_from],
bs=True)
cls2 = mc.cluster(crv + '.cv[1]',
n=prefix + 'Line2_cls',
wn=[obj_to, obj_to],
bs=True)
mc.setAttr(crv + '.template', 1)
offset_grp = mc.createNode("transform", name=prefix + 'CrvOffset_grp')
mc.setAttr(offset_grp + '.inheritsTransform', 0)
mc.parent(crv, offset_grp)
mc.parent(offset_grp, rigModule.controlsGrp)
return {'crv': crv, 'grp': offset_grp}
def connect_with_line(self, start='', end=''):
'''
create a line in between 2 transforms (start and end)
'''
if start == '':
sel = cmds.ls(sl=True)
start = sel[0]
end = sel[1]
#create line
cv = self.curve_between(start=start, end=end)
cv = cmds.rename(
cv, '{}_{}{}{}'.format(start, end, nc['connected'], nc['curve']))
#create clusters on cvs 0 and 1
cmds.select('{}.cv[0]'.format(cv))
cluster_start = cmds.cluster(n='{}{}'.format(start, nc['cluster']))
cmds.select('{}.cv[1]'.format(cv))
cluster_end = cmds.cluster(n='{}{}'.format(end, nc['cluster']))
#create aprents constrains to clusters
cmds.parentConstraint(start, cluster_start)
cmds.parentConstraint(end, cluster_end)
#clean and hide cv and clusters
cmds.setAttr("{}.overrideEnabled".format(cv), 1)
cmds.setAttr("{}.overrideDisplayType".format(cv), 2)
cmds.setAttr('{}.v'.format(cluster_start[1]), 0)
cmds.setAttr('{}.v'.format(cluster_end[1]), 0)
connect_with_line_assets = [cv, cluster_start[1], cluster_end[1]]
return connect_with_line_assets
def create_polevector_follow(control, joint):
"""Creates a linear curve between a joint and a control."""
# world space
joint_world_space = cmds.xform(control, q=True, ws=True, rp=True)
control_world_space = cmds.xform(joint, q=True, ws=True, rp=True)
# create curve and clusters
curve = cmds.curve(d=1,
p=[joint_world_space, control_world_space],
n="{0}_curve".format(control))
cmds.setAttr("{0}.overrideEnabled".format(curve), 1)
cmds.setAttr("{0}.overrideDisplayType".format(curve), 1)
joint_cluster = cmds.cluster("{0}.cv[0]".format(curve),
n="{0}_cluster".format(joint))
control_cluster = cmds.cluster("{0}.cv[1]".format(curve),
n="{0}_cluster".format(control))
# set hierarchy
groupNode = cmds.group(joint_cluster,
control_cluster,
curve,
n=curve + "_grp")
cmds.parent(groupNode, "rig_grp")
cmds.parentConstraint(control, joint_cluster, mo=False)
cmds.parentConstraint(joint, control_cluster, mo=False)
# hide
cmds.hide(joint_cluster)
cmds.hide(control_cluster)
def RMCreateLineBetwenPoints (self, Point1, Point2):
Curve = cmds.curve (degree=1, p=[[0,0,0],[1,0,0]], name = "curveLineBetweenPnts")
Curve = self.NameConv.RMRenameBasedOnBaseName(Point1, Curve, NewName = Curve)
NumCVs = cmds.getAttr (Curve + ".controlPoints" , size = True)
Cluster1, Cluster1Handle = cmds.cluster (Curve+".cv[0]", relative=True, name = "clusterLineBetweenPnts")
Cluster1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1, NewName = Cluster1)
Cluster1Handle = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1Handle, NewName = Cluster1Handle)
Cluster2, Cluster2Handle = cmds.cluster (Curve+".cv[1]", relative=True, name = "clusterLineBetweenPnts")
Cluster2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2, NewName = Cluster2)
Cluster2Handle = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2Handle, NewName = Cluster2Handle)
cmds.setAttr(Curve+".overrideEnabled",1)
cmds.setAttr(Curve+".overrideDisplayType",1)
RMAlign (Point1, Cluster1Handle, 1)
RMAlign (Point2, Cluster1Handle, 1)
PointConstraint1 = cmds.pointConstraint (Point1, Cluster1Handle, name = "PointConstraintLineBetweenPnts")[0]
PointConstraint1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , PointConstraint1, NewName = PointConstraint1)
PointConstraint2 = cmds.pointConstraint (Point2, Cluster2Handle, name = "PointConstraintLineBetweenPnts")[0]
PointConstraint2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , PointConstraint2, NewName = PointConstraint2)
DataGroup = cmds.group (em = True,name = "DataLineBetweenPnts")
DataGroup = self.NameConv.RMRenameBasedOnBaseName(Point1 , DataGroup, NewName = DataGroup)
cmds.parent (Cluster1Handle, DataGroup)
cmds.parent (Cluster2Handle, DataGroup)
cmds.parent (Curve, DataGroup)
return DataGroup , Curve
def makePoleVectorLine(name, joint, poleVector):
"""
Description: make visual line to connect pv and limb
name: prefix to name
joint: limb to attach
poleVector: pv to attach, (instance of object)
return value: polevector curve to parent to X group
"""
pv_line_pos_1 = mc.xform(joint, q=True, t=True, ws=True)
pv_line_pos_2 = mc.xform(poleVector.control, q=True, t=True, ws=True)
poleVector_curve = mc.curve(n=name + '_pv_crv',
degree=1,
point=[pv_line_pos_1, pv_line_pos_2])
mc.cluster(poleVector_curve + '.cv[0]',
n=name + '_pv1_cls',
weightedNode=[joint, joint],
bindState=True)
mc.cluster(poleVector_curve + '.cv[1]',
n=name + '_pv2_cls',
weightedNode=[poleVector.control, poleVector.control],
bindState=True)
mc.setAttr(poleVector_curve + '.template', True)
mc.setAttr(poleVector_curve + '.it', False)
return poleVector_curve
def createCurveBetweenVertex():
target = mc.ls(sl=True,fl=True)
global newCurve
if(len(target)!=2):
mc.warning("Choose Two Point or Object")
else:
sourcePos = mc.xform(target[0],q=True,ws=True,t=True)
targetPos = mc.xform(target[1],q=True,ws=True,t=True)
pointCurve = mc.curve(p=(sourcePos,targetPos),ws=True,d=1)
newCurve.append(pointCurve)
cluster1 = mc.cluster(pointCurve+'.cv[0]')
newCurve.append(cluster1[1])
mc.setAttr(cluster1[1]+'.visibility',0)
cluster2 = mc.cluster(pointCurve+'.cv[1]')
newCurve.append(cluster2[1])
mc.setAttr(cluster2[1]+'.visibility',0)
mc.select(clear=True)
mc.select(target[0],cluster1[1])
mel.eval('doCreatePointOnPolyConstraintArgList 2 { "0" ,"0" ,"0" ,"1" ,"" ,"1" ,"0" ,"0" ,"0" ,"0" };')
mc.select(clear=True)
mc.select(target[1],cluster2[1])
mel.eval('doCreatePointOnPolyConstraintArgList 2 { "0" ,"0" ,"0" ,"1" ,"" ,"1" ,"0" ,"0" ,"0" ,"0" };')
def create_ik(self):
"""Ik spline"""
# Create curve
tmp_curve = curve.create_from_nodes(self.joints, name=name.set_suffix(self.name, 'ikCrv'), degree=3)
self.curve = curve.rebuild_curve(tmp_curve, 3)[0]
start_joint, end_joint = self.ik_joints[0], self.ik_joints[-1]
logger.info("Creating Ik using nodes: %s" % self.joints)
self.ik, self.effector = cmds.ikHandle(name=name.set_suffix(self.name, 'ikh'), sj=start_joint, ee=end_joint, curve=self.curve, createCurve=False, sol="ikSplineSolver", ns=3)
# Add to setups
self.setups.extend([self.ik, self.curve])
# Set attrs
cmds.setAttr("%s.dTwistControlEnable" % self.ik, 1)
cmds.setAttr("%s.dWorldUpAxis" % self.ik, 1)
cmds.setAttr("%s.dWorldUpType" % self.ik, 4)
cmds.setAttr("%s.dWorldUpVector" % self.ik, 1.0, 0.0, 0.0, type="float3")
cmds.setAttr("%s.dWorldUpVectorEnd" % self.ik, 1.0, 0.0, 0.0, type="float3")
# Turn on cvs
cmds.select(self.curve, r=True)
cmds.toggle(cv=True)
# Create clusters
clusters = OrderedDict()
clusters['bot'] = cmds.cluster(["%s.cv[0]" % self.curve, "%s.cv[1]" % self.curve])[1]
clusters['mid'] = cmds.cluster(["%s.cv[2]" % self.curve, "%s.cv[3]" % self.curve])[1]
clusters['top'] = cmds.cluster(["%s.cv[4]" % self.curve, "%s.cv[5]" % self.curve])[1]
xform.match_pivot(start_joint, clusters['bot'])
xform.match_pivot(end_joint, clusters['top'])
self.clusters = clusters
def rebuild(self):
'''
Rebuild the cluster deformer from the recorded deformerData
'''
# Check target geometry
for obj in self.deformerData.iterkeys():
if not mc.objExists(obj): raise UserInputError('Object '+obj+' does not exist!')
# Check deformer
if mc.objExists(self.deformerName):
raise UserInputError('Cluster '+self.deformerName+' already exists!')
# Rebuild deformer
cluster = None
if mc.objExists(self.handle):
cluster = mc.cluster(self.getMemberList(),n=self.deformerName,wn=(self.handle,self.handle))
else:
cluster = mc.cluster(self.getMemberList(),n=self.deformerName)
if cluster[1] != self.handle: mc.rename(cluster[1],self.handle)
deformer = cluster[0]
# Connect bindPreMatrix
if self.bindPreMatrix:
if mc.objExists(self.bindPreMatrix[0]):
mc.connectAttr(self.bindPreMatrix[0],cluster+'.bindPreMatrix')
# Connect geomMatrix
for conn in self.geomMatrix.iterkeys():
if mc.objExists(conn):
mc.connectAttr(conn+'.'+self.geomMatrix[conn][0],cluster+'.geomMatrix['+str(self.geomMatrix[conn][1])+']')
# Set cluster weights
self.loadWeights()
# Return result
return deformer
def parent_cluster(cluster_name):
cluster_parent = cmds.textField('UI_cluster_clusterName', q=True, tx=True)
cluster_parent = cluster_parent.replace (" ", "_")
cluster_parent = cmds.createNode( 'transform', n= 'trn_' + cluster_parent, ss=True)
centre = cmds.objectCenter("loc_guide_deformer", gl=True)
cmds.move(centre[0], centre[1], centre[2], cluster_parent)
cmds.cluster (name = cluster_name, bs = True, wn = (cluster_parent, cluster_parent))
cmds.delete("loc_guide_deformer")
def crvGuide( ctrl = '' , target = '' ) : # Create NURBs curve between control and target # Returns : curve and two clusters crv = pc.Dag( mc.curve( d = 1 , p = [ ( 0 , 0 , 0 ) , ( 0 , 0 , 0 ) ] ) ) clstr1 = pc.Dag( mc.cluster( '%s.cv[0]' % crv , wn = ( ctrl , ctrl ) )[ 0 ] ) clstr2 = pc.Dag( mc.cluster( '%s.cv[1]' % crv , wn = ( target , target ) )[ 0 ] ) mc.select( cl = True ) return crv , clstr1 , clstr2
def rebuild(self, overrides={}):
'''
Rebuild the cluster deformer from the recorded deformerData
@param overrides: Dictionary of data overrides to apply
@type overrides: dict
'''
# Apply Overrides
self._data.update(overrides)
# ==========
# - Checks -
# ==========
# Check target geometry
for obj in self._data['affectedGeometry']:
if not mc.objExists(obj):
raise Exception('Deformer affected object "' + obj +
'" does not exist!')
# ====================
# - Rebuild Deformer -
# ====================
# Build Cluster Deformer and Handle
if not mc.objExists(self._data['name']):
# Create New Cluster
cluster = mc.cluster(self.getMemberList(), n=self._data['name'])
self._data['name'] = cluster[0]
else:
# Check Cluster
if mc.objectType(self._data['name']) != 'cluster':
raise Exception('Object "' + self._data['name'] +
'" is not a valid cluster deformer!')
# Rebuild Deformer
result = super(ClusterData, self).rebuild(overrides)
# Restore ClusterHandle Data
if self._data['clusterHandle']:
if not mc.objExists(self._data['clusterHandle']):
raise Exception('Weighted Node "' +
self._data['clusterHandle'] +
'" does not exist!')
try:
mc.cluster(self._data['name'],
edit=True,
bindState=True,
wn=(self._data['clusterHandle'],
self._data['clusterHandle']))
except:
pass
# =================
# - Return Result -
# =================
return result
def rebuild(self, overrides={}):
"""
Rebuild the cluster deformer from the recorded deformerData
@param overrides: Dictionary of data overrides to apply
@type overrides: dict
"""
# Apply Overrides
self._data.update(overrides)
# ==========
# - Checks -
# ==========
# Check target geometry
for obj in self._data["affectedGeometry"]:
if not mc.objExists(obj):
raise Exception('Deformer affected object "' + obj + '" does not exist!')
# ====================
# - Rebuild Deformer -
# ====================
# Build Cluster Deformer and Handle
if not mc.objExists(self._data["name"]):
# Create New Cluster
cluster = mc.cluster(self.getMemberList(), n=self._data["name"])
self._data["name"] = cluster[0]
else:
# Check Cluster
if mc.objectType(self._data["name"]) != "cluster":
raise Exception('Object "' + self._data["name"] + '" is not a valid cluster deformer!')
# Rebuild Deformer
result = super(ClusterData, self).rebuild(overrides)
# Restore ClusterHandle Data
if self._data["clusterHandle"]:
if not mc.objExists(self._data["clusterHandle"]):
raise Exception('Weighted Node "' + self._data["clusterHandle"] + '" does not exist!')
try:
mc.cluster(
self._data["name"],
edit=True,
bindState=True,
wn=(self._data["clusterHandle"], self._data["clusterHandle"]),
)
except:
pass
# =================
# - Return Result -
# =================
return result
def displayLine(point1, point2, name='ctrlLine#', parent=str()):
'''
Create a display line between two points
Example:
..python
displayLine('l_uparm_sc_jnt', 'l_uparm_pv_ctrl')
#Return: 'ctrlLine1'
displayLine('l_uparm_sc_jnt', 'l_uparm_pv_ctrl', name = 'l_uparm_pv_displayLine')
#Return: 'l_uparm_pv_displayLine'
:param point1: First node to connect display line to
:type point1: str
:param point2: Second node to connect display line to
:type point2: str
:return: Display line
:rtype: str
'''
#get posiitons of first and second points
pnt1 = mc.xform(point1, q=True, ws=True, t=True)
pnt2 = mc.xform(point2, q=True, ws=True, t=True)
#create a pointList from point1 and point2 positions
pointList = (pnt1, pnt2)
#create display line from pointList
displayLine = rigrepo.libs.curve.createCurveFromPoints(pointList,
degree=1,
name=name)
#cluster the two ends of the dispay line to point1 and point2
mc.cluster('{}.cv[0]'.format(displayLine),
wn=[point1, point1],
bs=True,
name='{}_1_{}'.format(displayLine, rigrepo.libs.common.CLUSTER))
mc.cluster('{}.cv[1]'.format(displayLine),
wn=[point2, point2],
bs=True,
name='{}_2_{}'.format(displayLine, rigrepo.libs.common.CLUSTER))
#override display type of displayLine to be templated
mc.setAttr('{}.overrideEnabled'.format(displayLine), 1)
mc.setAttr('{}.overrideDisplayType'.format(displayLine), 2)
mc.setAttr('{}.inheritsTransform'.format(displayLine), 0)
if parent:
mc.parent(displayLine, parent)
return displayLine
def cvsToCLR():
type = '_CLR'
i = 1
name = 'mid'
cvs = cmd.filterExpand(ex = True, sm = 28)
for one in cvs:
cmd.select(one)
cmd.cluster(name='%s%d%s'% (name, i, type))
cmd.group(name='%s%d%sGP'% (name, i, type))
i += 1
def make_ikspline_stretchy(*args):
'''main function to make joints stretching'''
try:
#get data of IKfandle and joint
selected_ikHandle = cmds.ls(sl=True)[0]
ikJoints = cmds.ikHandle(selected_ikHandle, q=True, jl=True)
numberOfBones = len(ikJoints)
ikCurve = cmds.ikHandle(selected_ikHandle, q=True, c=True)
cmds.rebuildCurve(ikCurve, rt=0, kr=0, d=4, s=1)
curveInfo = cmds.arclen(ikCurve, ch=True)
#create Node of length
multiDivArclen = cmds.shadingNode('multiplyDivide', asUtility=True)
cmds.setAttr(multiDivArclen + '.operation', 2)
cmds.addAttr(multiDivArclen, ln="stretchy", at='double', dv=0, k=True)
#connect curve length
cmds.connectAttr(curveInfo + '.arcLength',
multiDivArclen + '.input1X',
f=True)
cmds.connectAttr(multiDivArclen + '.outputX',
multiDivArclen + '.stretchy',
f=True)
input2X = cmds.getAttr(multiDivArclen + '.input1X')
cmds.setAttr(multiDivArclen + '.input2X',
input2X) #multDivArclen.OutputX == 1
#create Node of thickness
multiDivThickness = cmds.shadingNode('multiplyDivide', asUtility=True)
cmds.setAttr(multiDivThickness + '.operation', 3)
cmds.connectAttr(multiDivArclen + '.stretchy',
multiDivThickness + '.input1X',
f=True)
cmds.setAttr(multiDivThickness + '.input2X', -0.5)
#cmds.addAttr( multiDivArclen, ln="stretchy", at='double', dv=0, k=True)
cmds.cluster(ikCurve + '.cv[3]', n="cluster_end")
cmds.cluster(ikCurve + '.cv[0]',
ikCurve + '.cv[1]',
ikCurve + '.cv[2]',
n="cluster_root")
for i in range(numberOfBones):
cmds.connectAttr(multiDivArclen + '.stretchy',
ikJoints[i] + '.scaleX',
f=True)
if i > 0 and i < numberOfBones:
cmds.connectAttr(multiDivThickness + '.outputX',
ikJoints[i] + '.scaleY',
f=True)
cmds.connectAttr(multiDivThickness + '.outputX',
ikJoints[i] + '.scaleZ',
f=True)
#cmds.connectAttr( outMultDiv+'.outputX', item+'.scaleX', f=True)
except:
print "no curve selected"
def crearLowCrvControl(curvesActual=None, cnt=True, rad=1):
# curvesActual=cmds.ls(sl=1)
for curveActual in curvesActual:
newName = curveActual
if '_' in curveActual:
newName = curveActual.split(curveActual.split('_')[-1])[0]
if curveActual:
curve = cmds.duplicate(str(curveActual),
name=newName + 'CRVLOW',
rr=1)[0]
'''if not cmds.getAttr(curve+'.minMaxValue')[0] == (0.0, 1.0):'''
curve = cmds.rebuildCurve(curve,
keepRange=0,
ch=1,
rpo=1,
rt=0,
end=0,
kcp=0,
kep=1,
kt=0,
s=3,
d=3,
tol=0.01)[0]
#cmds.delete(curve, ch = 1)
mel.eval(
"wire -gw true -en 1.000000 -ce 0.000000 -li 0.000000 -dds 0 100 -name "
+ newName + 'WIRE' + " -w " + curve + " " + curveActual + ";")
else:
cmds.warning('colocar las curvas')
if cnt:
#creo cluster and rename that
topCLR = cmds.cluster(str(curve) + '.cv[0:2]')[1]
topCLR = cmds.rename(topCLR, newName + 'TOP_CLR')
midCLR = cmds.cluster(str(curve) + '.cv[2:3]')[1]
midCLR = cmds.rename(midCLR, newName + 'MID_CLR')
endCLR = cmds.cluster(str(curve) + '.cv[3:5]')[1]
endCLR = cmds.rename(endCLR, newName + 'BOT_CLR')
#change pivot to start vertex
p1 = cmds.xform(str(curve) + '.cv[0]', q=1, t=1, ws=1)
cmds.xform(str(topCLR), piv=p1, ws=1)
p2 = cmds.xform(str(curve) + '.cv[5]', q=1, t=1, ws=1)
cmds.xform(str(endCLR), piv=p2, ws=1)
CNTS = extraControl([topCLR, midCLR, endCLR],
'ZTR',
'TRF',
'CNT',
radius=rad)
return curve, topCLR, midCLR, endCLR
def pvLine(name, icon, joint):
j = mel.eval('curve -d 1 -p 0 0 0 -p 1 0 0 -k 0 -k 1 ;')
k = cmds.rename(name)
c1 = cmds.cluster('%s.cv[0]' % k, n='%s_cluster' % k)
c2 = cmds.cluster('%s.cv[1]' % k, n='%s_cluster' % k)
cmds.parentConstraint(icon, c1, mo=0)
cmds.parentConstraint(joint, c2, mo=0)
i = cmds.group(k, c1, c2, n='%s_pad' % name)
cmds.setAttr('%sHandle.visibility' % c1[0], 0)
cmds.setAttr('%sHandle.visibility' % c2[0], 0)
cmds.setAttr('%sShape.overrideDisplayType' % k, 2)
cmds.setAttr('%sShape.overrideEnabled' % k, 1)
return i
def pvLine(name, icon, joint):
j=mel.eval('curve -d 1 -p 0 0 0 -p 1 0 0 -k 0 -k 1 ;')
k=cmds.rename(name)
c1=cmds.cluster('%s.cv[0]' % k, n='%s_cluster' % k)
c2=cmds.cluster('%s.cv[1]' % k, n='%s_cluster' % k)
cmds.parentConstraint(icon, c1, mo=0)
cmds.parentConstraint(joint, c2, mo=0)
i=cmds.group(k,c1,c2, n='%s_pad' % name)
cmds.setAttr('%sHandle.visibility' % c1[0], 0)
cmds.setAttr('%sHandle.visibility' % c2[0], 0)
cmds.setAttr('%sShape.overrideDisplayType' % k, 2)
cmds.setAttr('%sShape.overrideEnabled' % k, 1)
return i
def gpsClusterPerFace():
selectionList = cmds.ls(selection=True)
n = 0
if selectionList:
while len(selectionList) > n:
cmds.cluster(selectionList[n])
n += 1
else:
cmds.warning("Please select objects or components!")
def on_btn_Mirror_clicked(self, args=None):
if args == None: return
geo = str(self.let_Geometry.text())
src = str(self.let_Source.text())
dst = str(self.let_Targent.text())
if not mc.objExists(geo):
return
if not mc.objExists(src):
return
if not mc.objExists(dst):
return
infoNode = mc.createNode('closestPointOnMesh')
shape = mc.listRelatives(geo, s=True, path=True, type='mesh')[0]
mc.connectAttr('%s.outMesh' % shape, '%s.inMesh' % infoNode)
srcWeightListIndex = mc.listRelatives(mc.cluster(src, q=True, g=True),
p=True,
path=True).index(geo)
dstWeightListIndex = mc.listRelatives(mc.cluster(dst, q=True, g=True),
p=True,
path=True).index(geo)
vtxCounts = len(mc.ls('%s.vtx[*]' % geo, fl=True))
srcValues = mc.getAttr('%s.wl[%d].w[:%d]' %
(src, srcWeightListIndex, vtxCounts - 1))
dstValues = []
self.progressBar.setMaximum(vtxCounts)
for i, vtx in enumerate(mc.ls('%s.vtx[*]' % geo, fl=True)):
postions = mc.xform(vtx, q=True, ws=True, t=True)
mc.setAttr('%s.ipx' % infoNode, postions[0] * -1)
mc.setAttr('%s.ipy' % infoNode, postions[1] * 1)
mc.setAttr('%s.ipz' % infoNode, postions[2] * 1)
dstValues.append(srcValues[mc.getAttr('%s.vt' % infoNode)])
#-
self.progressBar.setValue(i)
mc.setAttr(
'%s.wl[%d].w[:%d]' % (dst, dstWeightListIndex, len(dstValues) - 1),
*dstValues)
mc.delete(infoNode)
#-
self.progressBar.setMaximum(1)
self.progressBar.setValue(0)
def create_line(objects, attach=True, attachParents=[], name=""):
"""
Creates a line between objects, that optionally
attaches to each
"""
if not name:
name = "line_display"
print("Attach is: {}".format(attach))
positions = get_positions(objects)
curve = create_from_points(positions, name=name, degree=1)
# Rig CVs to each object
if attach:
if not attachParents:
attachParents = objects[:]
print("Attaching...")
cvs = get_cvs(curve)
for i in range(len(objects)):
cluster = cmds.cluster(cvs[i])
cmds.parentConstraint(objects[i], cluster, maintainOffset=True)
return curve
def alignJawCtrl() : # Align jaw control to jaw joint. # Select jaw control curve then jaw joint. sels = mc.ls( sl = True ) ctrl = sels[0] jnt = sels[1] shp = mc.listRelatives( ctrl , shapes=True )[0] mc.select( shp , r=True ) fstCv = 14 scdCv = 2 fstPos = mc.xform( '%s.cv[%s]' % (shp,fstCv) , q=True , ws=True , t=True ) scdPos = mc.xform( '%s.cv[%s]' % (shp,scdCv) , q=True , ws=True , t=True ) midPos = [ (fstPos[0]+scdPos[0])/2 , (fstPos[1]+scdPos[1])/2 , (fstPos[2]+scdPos[2])/2 ] clstr = mc.cluster()[1] mc.select( clstr , r=True ) mc.move( midPos[0] , midPos[1] , midPos[2] , '%s.rotatePivot' % clstr ) mc.move( midPos[0] , midPos[1] , midPos[2] , '%s.scalePivot' % clstr ) mc.delete( mc.pointConstraint( jnt , clstr ) ) tipJnt = mc.listRelatives( jnt , type = 'joint' )[0] if tipJnt : mc.delete( mc.aimConstraint(tipJnt,clstr,aim=(0,0,1),u=(1,0,0),wut='vector',wu=(1,0,0)))
def createMasterCtrl(self, ctrl, offsetCtrl, curveShape, size, offsetScale):
cmds.file(PATH + curveShape + ".ma", i=True, rdn =True)
cmds.rename('control', ctrl)
cmds.file(PATH + "circle.ma", i=True, rdn =True)
cmds.rename('control', offsetCtrl)
cmds.xform(offsetCtrl, scale=[offsetScale, offsetScale, offsetScale ])
cmds.makeIdentity(offsetCtrl, apply=True, s=True)
cmds.parent(offsetCtrl, ctrl)
cmds.addAttr(ctrl, at='bool', ln="offsetCtrl", dv=1)
cmds.setAttr(ctrl + ".offsetCtrl", k=False, cb=True)
offsetCtrlShapes = cmds.listRelatives(offsetCtrl, shapes=True)
for offsetCtrlShape in offsetCtrlShapes:
cmds.connectAttr(ctrl+".offsetCtrl", offsetCtrlShape+".visibility")
cluster, clusterHandle = cmds.cluster(ctrl, name=ctrl+"_cluster")
cmds.setAttr(clusterHandle + '.visibility', 0)
cmds.setAttr(cluster + '.relative', 1)
cmds.parent(clusterHandle, ctrl)
cmds.addAttr(ctrl, at='double', ln="iconSize", minValue=0.1, dv=size, k=True)
cmds.setAttr(ctrl + ".iconSize", k=False, cb=True)
cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleX")
cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleY")
cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleZ")
cmds.setAttr(ctrl+".offsetCtrl", 0)
def createLine(_parents, _sceneData = False, _layer = False):
nodes = []
lineCurve = ""
firstTime = True
for obj in _parents:
pos = cmds.xform(obj, q=1, t=1, ws=1)
if firstTime:
lineCurve = cmds.curve(d=1, p=[pos])
nodes.append(lineCurve)
cmds.setAttr(lineCurve+".overrideEnabled", 1)
cmds.setAttr(lineCurve+".overrideDisplayType", 2)
cmds.setAttr(lineCurve+".inheritsTransform", 0)
firstTime = False
else:
cmds.curve(lineCurve, a=True, p=pos)
#Clusters must be added after all the cvs are created.
#Don't ask me why!
for j in range(len(_parents)):
clusterName = _parents[j]+"_CLUSTER"
clusterPoint = cmds.cluster(lineCurve+".cv["+str(j)+"]", n=clusterName)
nodes.append(clusterPoint[1])
#cmds.setAttr(clusterPoint[1]+".visibility", 0)
cmds.parent(clusterPoint[1], _parents[j], a=1)
if(_sceneData):
addToLayer(_sceneData, "hidden", nodes)
if _layer:
addToLayer(_sceneData, _layer, lineCurve)
return nodes
def use_weight_set():
cmds.select(cmds.cluster(cmds.textScrollList('UI_cluster_list', q=True, si=True)[0], q=True, g=True)[0])
mel.eval("ConvertSelectionToVertices;")
weights = cmds.percent (cmds.textScrollList('UI_cluster_list', q=True, si=True)[0], q=True, v=True)
cmds.filterExpand( ex=True, sm=31 )
elements = cmds.ls(sl=True, fl=True)
return elements, weights
def controllerResize(self):
number = float(self.ui.Do_Resize_DSB.text())
XYZ = ["X", "Y", "Z"]
sel = cmds.ls(sl=True)
for x in sel:
curveName = x
curveShape = cmds.listRelatives(curveName, s=True)[0]
cvNum = cmds.getAttr('%s.spans' % curveShape) + cmds.getAttr(
'%s.degree' % curveShape)
conPivot = cmds.xform("%s" % curveName, q=True, ws=True, rp=True)
cmds.select("%s.cv[0:%s]" % (curveName, cvNum))
cluster = cmds.cluster()
cmds.move(conPivot[0],
conPivot[1],
conPivot[2],
"%s.scalePivot" % cluster[1],
"%s.rotatePivot" % cluster[1],
absolute=True)
if number > 0:
for i in XYZ:
cmds.setAttr("%s.scale%s" % (cluster[1], i), number)
else:
nagative_number = 1 - number * (-0.1)
print nagative_number
for i in XYZ:
cmds.setAttr("%s.scale%s" % (cluster[1], i),
nagative_number)
cmds.DeleteHistory(cmds.select(sel))
def on_btn_Start_clicked(self, clicked=None):
if clicked == None:return
geometry = str(self.LET_Geometry.text())
joints = [jnt.strip() for jnt in str(self.LET_Skeleton.text()).split(',')]
joints = [jnt for jnt in joints if mc.objExists(jnt)]
self.progressBar_A.setMaximum(len(joints))
self.progressLabel_A.setText('0/%d'%len(joints))
for i, jnt in enumerate(joints):
#- create cluster
cluster = mc.cluster(geometry, rel=True)
#- copy weights
res = transSkinWeightsToCluster(geometry, geometry, jnt, cluster[0], self.progressBar_B, self.progressLabel_B)
#if res:
##- weight Node
#mc.cluster(cluster[0], e=True, wn=(jnt, jnt))
##- delete handle
#mc.delete(cluster[1])
#- progerss
self.progressBar_A.setValue(i+1)
self.progressLabel_A.setText('%d/%d'%(i+1, len(joints)))
self.progressBar_A.setValue(0)
self.progressBar_A.setMaximum(1)
self.progressLabel_A.setText('0/0')
def offset_cache_static(self):
checkSel = cmds.ls(sl=1)
if len(checkSel)<2:
print "you need to select two objects"
leader = checkSel[1]
cmds.select(leader, r=1)
cmds.ConvertSelectionToVertices(leader)
ld_lctr = self.locator_select_verts()
follower = checkSel[0]
cmds.select(follower, r=1)
cmds.ConvertSelectionToVertices(follower)
flw_lctr = self.locator_select_verts()
# set the offset node for translate
plsMns = cmds.shadingNode("plusMinusAverage", asUtility = 1)
cmds.setAttr(plsMns+".operation", 2)
cmds.connectAttr(ld_lctr+".translate", plsMns+".input3D[0]", f=1)
cmds.connectAttr(flw_lctr+".translate", plsMns+".input3D[1]", f=1)
# set cluster
cmds.select(checkSel[0])
getpar=cmds.listRelatives(checkSel[0], p=1)
getchildren=[(nodes) for nodes in cmds.listRelatives(getpar[0], ad=1, type="mesh") if "Orig" not in str(nodes) ]
cmds.select(getchildren, add =1 )
create_cstr = cmds.cluster()
# connect result to cluster
cmds.connectAttr( plsMns+".output3D", create_cstr[0]+"Handle.translate", f = 1)
def on_btn_Start_clicked(self, clicked=None):
if clicked == None: return
geometry = str(self.LET_Geometry.text())
joints = [
jnt.strip() for jnt in str(self.LET_Skeleton.text()).split(',')
]
joints = [jnt for jnt in joints if mc.objExists(jnt)]
self.progressBar_A.setMaximum(len(joints))
self.progressLabel_A.setText('0/%d' % len(joints))
for i, jnt in enumerate(joints):
#- create cluster
cluster = mc.cluster(geometry, rel=True)
#- copy weights
res = transSkinWeightsToCluster(geometry, geometry, jnt,
cluster[0], self.progressBar_B,
self.progressLabel_B)
#if res:
##- weight Node
#mc.cluster(cluster[0], e=True, wn=(jnt, jnt))
##- delete handle
#mc.delete(cluster[1])
#- progerss
self.progressBar_A.setValue(i + 1)
self.progressLabel_A.setText('%d/%d' % (i + 1, len(joints)))
self.progressBar_A.setValue(0)
self.progressBar_A.setMaximum(1)
self.progressLabel_A.setText('0/0')
def setup_blendshape_lattice(side = None,
blendShape = None,
divisions = [2,5,2],
ldv = [2,2,2],
parent = None):
#--- this method setups the lattice deformer
lat = cmds.lattice(blendShape,
divisions = divisions,
objectCentered = True,
ldv = ldv)
cmds.setAttr(lat[1] + '.v', 0)
cmds.parent(lat, 'Shapes')
points = cmds.ls(lat[1] + '.pt[*]', flatten = True)
for point in range(len(points)):
pos = cmds.xform(points[point], query = True, translation = True, worldSpace = True)
cPoint = node.nControl(position = pos,
color = 17,
size = 1,
shape = 1,
side = side,
description = "latPoint" + str(point),
parent = parent,
rotateOrder = 2)
cmds.setAttr(cPoint.control['transform'] + '.v', lock = False)
cmds.connectAttr('C_bedMid_CTL.latticeControls', cPoint.control['transform'] + '.v')
cls = cmds.cluster(points[point], name = side + '_latCluster' + str(point) + '_CLS')
for axis in 'xyz':
cmds.connectAttr(cPoint.control['transform'] + '.t' + axis, cls[1] + '.t' + axis)
cmds.parent(cls[1], 'Shapes')
cmds.setAttr(cls[1] + '.v', 0)
def makeRefLine(self,stCtrl,edCtrl):
self.ctrl = cmds.curve(d=1,p=[(0,0,0),(0,0,12)],k = [0,1], n = (self.name))
self.stCtrl = stCtrl
self.edCtrl = edCtrl
cmds.select(self.ctrl+'.cv[0]')
stClu = cmds.cluster(n=(self.ctrl+'st_clu'))
cmds.select(self.ctrl+'.cv[1]')
edClu = cmds.cluster(n=(self.ctrl+'ed_clu'))
km.ApplyConstrain(self.stCtrl,stClu).parentCon(0)
km.ApplyConstrain(self.edCtrl,edClu).parentCon(0)
cmds.setAttr(self.ctrl+'.overrideEnabled', 1)
cmds.setAttr(self.ctrl+'.overrideDisplayType', 2)
self.hkG = cmds.group(n = (stClu[1]+'_g'),em =1)
dt.parentIT(stClu[1],self.hkG)
dt.parentIT(edClu[1],self.hkG)
return self.hkG
def copy_joint_weights_to_cluster(skin_mel_node, joint_mel_node):
'''
'''
#- initlize api nodes
skin_mfn_node = OpenMayaAnim.MFnSkinCluster(pymel.core.PyNode(skin_mel_node).__apiobject__())
joint_dag_path = OpenMaya.MDagPath(pymel.core.PyNode(joint_mel_node).__apiobject__())
#- get joint influcenced points and weight values
components = OpenMaya.MSelectionList()
weights = OpenMaya.MDoubleArray()
skin_mfn_node.getPointsAffectedByInfluence(joint_dag_path, components, weights)
#- create cluster
component_strings = list()
components.getSelectionStrings(component_strings)
cluster_mel_node = mc.cluster(component_strings)[0]
clus_mfn_node = OpenMayaAnim.MFnWeightGeometryFilter(pymel.core.PyNode(cluster_mel_node).__apiobject__())
#- get geometry's dagpath and component
geo_dag_path = OpenMaya.MDagPath()
geo_comp_obj = OpenMaya.MObject()
components.getDagPath(0, geo_dag_path, geo_comp_obj)
#- convert skinweights type to cluster weights type
cluster_weights_array = OpenMaya.MFloatArray()
for v in weights:
cluster_weights_array.append(v)
#- set weights
clus_mfn_node.setWeight(geo_dag_path, geo_comp_obj, cluster_weights_array)
def softSelectionClusterWeights(*args):
sel = mc.ls(sl=True, o=True)
if not sel:
raise RuntimeError('Please select some vertices.')
weights = getSoftSelectionWeights()
if not weights:
raise RuntimeError('Please select some vertices.')
#get manipulator position for pivot
mc.setToolTo('Move')
moveMode = mc.manipMoveContext('Move', query=True, mode=True)
mc.manipMoveContext('Move', edit=True, mode=0)
position = mc.manipMoveContext('Move', query=True, position=True)
mc.manipMoveContext('Move', edit=True, mode=moveMode)
clusterNode, clusterHandle = mc.cluster(sel[0])
for vert in mc.ls(sel[0]+'.vtx[*]', fl=True, l=True):
weight = 0.0
if vert in weights.keys():
weight = weights[vert]
mc.percent(clusterNode, vert, v=weight)
#set cluster pivot
mc.xform(clusterHandle, a=True, ws=True, piv=(position[0], position[1], position[2]))
clusterShape = mc.listRelatives(clusterHandle, c=True, s=True)
mc.setAttr(clusterShape[0] + '.origin', position[0], position[1], position[2])
def _createPerEye(self, side, geos ): mc.select( geos ) clu = mn.Node( mc.cluster( n = side + '_Eye_CLU' )[1] ) print clu.name mc.select( geos ) lat = mn.Nodes( mc.lattice( n = side + '_Eye_LAT', objectCentered = True ) ) ctl = crv.Curve( side + '_Eye_ctl' ) ctl.create( 'circleZ' ) print ctl.name par = mn.Node( mc.parentConstraint( clu, ctl, mo = False )[0]) par.delete() ctl.a.tz.v = self.distance_control_sb.value() + ctl.a.tz.v mc.makeIdentity( ctl, a = True, t = 1, r = 1, s = 1 ) loc = mn.createNode( 'locator' ).parent loc.name = side + '_Eye_Top_Loc' par = mn.Node( mc.aimConstraint( ctl, clu, mo = True, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=loc )[0]) trf = mn.createNode( 'transform' ) trf.name = side + '_Eye_Def_grp' lat[1].parent = trf lat[2].parent = trf clu.parent = trf loc.parent = trf return trf, ctl
def createIKCtrlsOnJnts(ikCrv, parentCtrl, size=1):
ikCVNum = ll.getCurveCVCount(ikCrv)
prev = parentCtrl
for i in range(1, ikCVNum):
clus = mc.cluster('%s.cv[%d]' % (ikCrv, i),
n=parentCtrl.replace('masterctrl', 'ikClus%d') % i)
cvPos = mc.xform('%s.cv[%d]' % (ikCrv, i), q=1, ws=1, t=1)
mc.select(parentCtrl)
meval('wireShape("plus")')
ikCtrl = mc.rename(masterCtrl.replace('masterctrl', 'ikCtrl%d' % i))
mc.xform(ikCtrl, t=cvPos, ws=1)
mc.scale(size, size, size, ikCtrl, ocp=1)
mc.makeIdentity(ikCtrl, a=1, s=1)
mc.parent(ikCtrl, parentCtrl)
lsZeroOut(ikCtrl)
ctrlPR = lsZeroOut(ikCtrl, 'PR')
mc.addAttr(ikCtrl, ln='SPACE', at='bool', k=1)
mc.setAttr(ikCtrl + '.SPACE', l=1)
mc.addAttr(ikCtrl, ln='parent', at='float', dv=0, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='master', at='float', dv=1, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='world', at='float', dv=0, min=0, max=1, k=1)
mc.parentConstraint(ikCtrl, clus)
cons = mc.parentConstraint(prev, parentCtrl, ctrlPR, mo=1)[0]
wal = mc.parentConstraint(cons, q=1, wal=1)
if len(wal) > 1:
mc.connectAttr(ikCtrl + '.parent', '%s.%s' % (cons, wal[0]), f=1)
mc.connectAttr(ikCtrl + '.master', '%s.%s' % (cons, wal[1]), f=1)
prev = ikCtrl
def cluster_on_curve(self, crv):
"""Creates a cluster on each cv on the given curve.
@param crv: the curve
@type crv: String
@return: a list of all clusters
"""
clsName = str(crv)[:-4]
degree = cmds.getAttr(crv+".degree")
spans = cmds.getAttr(crv + ".spans")
cvs = degree + spans
clsReturn = list()
for i in range(0, cvs):
cmds.select(crv + ".cv[" + str(i) +"]", r=True)
cls = cmds.cluster(en=1)
grp = ""
if i==0:
cmds.rename(cls[1],(clsName + "Root" + "_" + 'CLS'))
grp = cmds.group(n=(clsName + "Root" + "_" + 'CLS' + "_" + 'GRP'))
elif i==(cvs-1):
cmds.rename(cls[1],(clsName + "End" + "_" + 'CLS'))
grp = cmds.group(n=(clsName + "End" + "_" + 'CLS' + "_" + 'GRP'))
else:
cmds.rename(cls[1],(clsName + str(i) + "_" + 'CLS'))
grp = cmds.group(n=(clsName + str(i) + "_" + 'CLS' + "_" + 'GRP'))
# END if
#clsAr[i] = grp
clsReturn.append(grp)
cmds.setAttr(grp + ".visibility", 0)
# END for
return clsReturn
def createTemplate(self , eyeMesh):
# create eye jnt
eyeJnt=[]
if 'L_' in str(eyeMesh):
helpClu = mc.cluster(eyeMesh)[0]
LeyeJnt = mc.joint(p=(0,0,0),name=eyeMesh+'_skin_jnt')
self.fromAtoB(eyeJnt,helpClu,1)
ReyeJnt = mc.mirrorJoint(mirrorYZ=True,mirrorBehavior=False,searchReplace=('L_', 'R_')
eyeJnt.append(LeyeJnt)
eyeJnt.append(ReyeJnt)
else:
self.mayaError('Please select the left eye.')
return eyeJnt
def createEyeRig(self):
if mc.objExists(self.eyeGlobalCtrl) == False:
EyesGlobalCtrl = mc.curve(d=1,p=[(-1.069806, 1.027703, 0),(-1.651954,1.89895,0),(-2.523201,2.481098,0),(-3.550904,2.68552,0),(-4.578607,2.481098,0),(-5.449854,1.89895,0),(-6.032002,1.027703,0),(-6.236424,0,0),(-6.032002,-1.027703,0),(-5.449854 ,-1.89895, 0),(-4.578607,-2.481098,0), (-3.550904,-2.68552,0),(-2.523201, -2.481098, 0),(-1.651954,-1.89895,0),(-1.069806,-1.027703,0),(1.058138,-1.032345,0),(1.642915, -1.907527,0),(2.518098,-2.492305,0),( 3.550443,-2.69765,0),(4.582788,-2.492305,0),(5.45797,-1.907527,0),( 6.042748,-1.032345,0),(6.248093,0,0),(6.042748,1.032345,0),( 5.45797,1.907527,0 ),(4.582788,2.492305,0),( 3.550443,2.69765,0),(2.518098,2.492305,0 ),(1.642915,1.907527,0),(1.058138,1.032345,0),( -1.069806,1.027703,0)],k=[0,1,2,3,4,5,6,7,8,9,10,11,12 ,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],n=self.eyeGlobalCtrl)
L_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='L_'+self.eyeAimCtrl)
R_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='R_'+self.eyeAimCtrl)
mc.parent(L_EyeAimCtrl , EyesGlobalCtrl)
mc.parent(R_EyeAimCtrl , EyesGlobalCtrl)
self.fastGrp('On' , ['zero','con','sdk'],L_EyeAimCtrl)
self.fastGrp'On' , ['zero','con','sdk'],R_EyeAimCtrl)
zeroGrp = self.fastGrp('On' , ['zero','con','sdk'],EyesGlobalCtrl)[2]
def createIKCtrlsOnJnts(ikCrv, parentCtrl, size=1):
ikCVNum = ll.getCurveCVCount(ikCrv)
prev=parentCtrl
for i in range(1, ikCVNum):
clus = mc.cluster('%s.cv[%d]'%(ikCrv, i), n=parentCtrl.replace('masterctrl','ikClus%d')%i)
cvPos = mc.xform('%s.cv[%d]'%(ikCrv, i), q=1, ws=1, t=1)
mc.select(parentCtrl)
meval('wireShape("plus")')
ikCtrl = mc.rename(masterCtrl.replace('masterctrl','ikCtrl%d'%i))
mc.xform(ikCtrl, t=cvPos, ws=1)
mc.scale(size, size, size, ikCtrl, ocp=1)
mc.makeIdentity(ikCtrl, a=1, s=1)
mc.parent(ikCtrl, parentCtrl)
lsZeroOut(ikCtrl)
ctrlPR = lsZeroOut(ikCtrl, 'PR')
mc.addAttr(ikCtrl, ln='SPACE', at='bool', k=1)
mc.setAttr(ikCtrl+'.SPACE', l=1)
mc.addAttr(ikCtrl, ln='parent', at='float', dv=0, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='master', at='float', dv=1, min=0, max=1, k=1)
mc.addAttr(ikCtrl, ln='world', at='float', dv=0, min=0, max=1, k=1)
mc.parentConstraint(ikCtrl, clus)
cons = mc.parentConstraint(prev, parentCtrl, ctrlPR, mo=1)[0]
wal = mc.parentConstraint(cons, q=1, wal=1)
if len(wal) > 1:
mc.connectAttr(ikCtrl+'.parent', '%s.%s'%(cons, wal[0]), f=1)
mc.connectAttr(ikCtrl+'.master', '%s.%s'%(cons, wal[1]), f=1)
prev=ikCtrl
def softSelectionClusterWeights(*args):
sel = mc.ls(sl=True, o=True)
if not sel:
raise RuntimeError('Please select some vertices.')
weights = getSoftSelectionWeights()
if not weights:
raise RuntimeError('Please select some vertices.')
#get manipulator position for pivot
mc.setToolTo('Move')
moveMode = mc.manipMoveContext('Move', query=True, mode=True)
mc.manipMoveContext('Move', edit=True, mode=0)
position = mc.manipMoveContext('Move', query=True, position=True)
mc.manipMoveContext('Move', edit=True, mode=moveMode)
clusterNode, clusterHandle = mc.cluster(sel[0])
for vert in mc.ls(sel[0]+'.vtx[*]', fl=True, l=True):
weight = 0.0
if vert in weights.keys():
weight = weights[vert]
mc.percent(clusterNode, vert, v=weight)
#set cluster pivot
mc.xform(clusterHandle, a=True, ws=True, piv=(position[0], position[1], position[2]))
clusterShape = mc.listRelatives(clusterHandle, c=True, s=True)
mc.setAttr(clusterShape[0] + '.origin', position[0], position[1], position[2])
def createClusterFromSelection(*args):
vtx = cmds.ls(sl=True, fl=True)
for v in vtx:
cmds.select(cl=True)
clu = cmds.cluster()
pos = cmds.xform(v, q=True, ws=True, t=True)
cmds.xform(clu, ws=True, t=pos)
def clusterCurve(splineCurve):
clusters = []
clusterCtrls = []
# Get all CVs in spline curve
curveCVs = cmds.ls('%s.cv[:]' % splineCurve, flatten=1)
for i, cv in enumerate(curveCVs):
# Create cluster for each CV
cvCluster = cmds.cluster(cv, name='spl_%s_CL' % i)
cvCluster = cvCluster[1] # cmds.cluster() returns [cluster, handle]
clusters.append(cvCluster)
if i > 0:
# Create control for cluster
cvPos = cmds.pointPosition(cv)
cvControl = createCubeControl('spl_%s_CTRL' % i, cvPos)
cmds.makeIdentity(cvControl, apply=1, t=1, r=1, s=1, n=0)
cmds.parentConstraint(cvControl, cvCluster, maintainOffset=1)
clusterCtrls.append(cvControl)
return clusters, clusterCtrls
def makePipeJoints():
#track selection order must be on for this to work
joints = []
sel = cmd.ls(os=True)
obj = cmd.ls(sl=True, o=True)
name = obj[0].rsplit('_', 1)[0]
for one in sel:
strip = re.search(r"\[([0-9]+)\]", one)
num = strip.group(1)
cmd.select(one)
cmd.polySelect(el=int(num))
clust = cmd.cluster(n = 'poo#')
posi = cmd.getAttr(clust[0]+'HandleShape.origin')
cmd.delete (clust[0])
size = len(joints)
joints.append(cmd.joint(n='%s_%s_JNT' %(name, size+1),p = posi[0]))
if size > 0:
cmd.parent(joints[size], joints[size-1])
cmd.joint(joints[size-1], e=True, oj = 'xyz', sao = 'yup')
circle = cmd.circle(nr = [1, 0, 0], n='%s_%s_CTL' %(name, size))
group = cmd.group(n = '%s_GP' %(circle[0]))
jntCTL(joints[size-1], circle[0], group)
if size > 1:
cmd.parentConstraint(joints[size-2], group, mo =1)
cmd.select(joints, obj[0])
cmd.skinCluster(mi=4)
def main():
mm.eval('selectCurveCV("all");')
sel = mc.ls(sl=1, fl=1)
grpname = (sel[0].split('.'))
grpname = grpname[0]+"_grp"
grp = mc.group(em=1, n=grpname)
for i in sel:
iname = i.replace('[', '')
iname = iname.replace(']','')
iname = iname.replace('.','_')
locname = iname+"_loc"
clusname = iname+"_clus"
mc.select(i, r=1)
print "here"
cluster = mc.cluster(n=clusname)
location = mc.xform(cluster, q=1, ws=1, sp=1)
print location
locator = mc.spaceLocator(n=locname, p=(location[0], location[1], location[2]))
mc.xform(locator, cp=1)
set_vis = clusname+"Handle.visibility"
mc.setAttr(set_vis, 0)
mc.parent(cluster, locator)
mc.parent(locator, grp)
shape = mc.listRelatives(locator)
mc.setAttr((shape[0]+".overrideEnabled"),1)
mc.setAttr((shape[0]+".overrideColor"),17)
def controlShape(self):
name = self._name + self._suffix
if self._style == "cube": shape = utils.controlShapes.cube()
if self._style == "sphere": shape = utils.controlShapes.sphere()
if self._style == "spine": shape = utils.controlShapes.spine()
orient = (0,0,0)
if self._orient == (1,0,0): orient = (90,0,0)
if self._orient == (0,1,0): orient = (0,90,0)
if self._orient == (0,0,1): orient = (0,0,90)
control = "cube_ctrl"
control = mc.rename(shape, name)
# move control
cluster = mc.cluster(control)
mc.xform(cluster, t=self._center, s=self._size, ro=orient)
mc.delete(control, ch=True)
mc.setAttr(control + ".overrideEnabled", 1)
# scale control
mc.xform(control, scale=self._size)
mc.makeIdentity(control, apply=True, s=1)
self.controller = control
self.controlShape = mc.listRelatives(control, shapes=True)[0]
def setClusterWeights(geometry, args, weights):
weightListIndex = mc.listRelatives(mc.cluster(args, q=True, g=True),
p=True,
path=True).index(geometry)
vtxCounts = len(weights)
weights = mc.setAttr(
'%s.wl[%d].w[:%d]' % (args, weightListIndex, vtxCounts - 1), *weights)
def Fivecrv():
GlobalName = 'tmp'
basecurve5 = cmds.rename(
mel.eval(
"curve -d 3 -p -4 0 0 -p -2 0 0 -p 0 0 0 -p 2 0 0 -p 4 0 0 -k 0 -k 0 -k 0 -k 1 -k 2 -k 2 -k 2 ;"
), (GlobalName + '_Wire'))
curve5Size = 5
curveOption = basecurve5
curveOptionFinal.append(curveOption)
curveSize = curve5Size
for i in range(curveSize):
cls = cmds.cluster(str(curveOption) + '.cv[' + str(i) + ']',
n=(GlobalName + 'CrvCls_0' + str(i)))
clusterList.append(cls[1])
for i in clusterList:
tmpctrls = cmds.circle(n=(i + '_Ctrl'), nr=[1, 0, 0], ch=0)
cmds.delete(cmds.pointConstraint(i, tmpctrls))
cmds.makeIdentity(tmpctrls, apply=True, t=1, r=1, s=1)
cmds.pointConstraint(tmpctrls, i, mo=True)
ctrlList.append(tmpctrls[0])
clGrp = cmds.group(clusterList, n=('Cl_Group' + GlobalName))
ctrlGrp = cmds.group(ctrlList, n=('Ctrl_Group' + GlobalName))
mainGrp = cmds.group(clGrp,
ctrlGrp,
curveOption,
n=('Main_' + GlobalName + '_Grp'))
return ctrlList
def create_cluster(self, mesh):
cluster = cmds.cluster()[0]
cluster_handle_dag = oopmaya.DAG_Node()
cmds.setAttr("{0}.relative".format(cluster), 1)
cmds.parent(cluster_handle_dag.name(), mesh)
def softModToCluster():
softTransform = rig.ls(sl = True)[0]
solftMod = rig.listConnections(softTransform,s = False,d = True,type = 'softMod')[0]
modifModel = rig.listConnections(solftMod,s = False,d = True,type = 'mesh')
if modifModel:
origPos = rig.xform(softTransform,q = True,t = True,wd = True)
for mesh in modifModel:
prePos = []
curPos = []
weights = []
vtxs = rig.ls(mesh+'.vtx[*]',fl = True)
rig.xform(softTransform,t = (0,0,0),wd = True)
for vtx in vtxs:
pos = rig.xform(vtx,q = True,t = True,wd = True)
prePos.append(pos)
rig.xform(softTransform,t = (0,1,0),wd = True)
for vtx in vtxs:
pos = rig.xform(vtx,q = True,t = True,wd = True)
curPos.append(pos)
weights = [math.pow(math.pow(pos[0]-curPos[i][0],2)+math.pow(pos[1]-curPos[i][1],2)+math.pow(pos[2]-curPos[i][2],2),0.5) for i,pos in enumerate(prePos)]
rig.xform(softTransform,t = (0,0,0),wd = True)
CLS = rig.cluster(mesh,n = mesh+'_CLS')
for i,vtx in enumerate(vtxs):
rig.percent(CLS[0],vtx,v = weights[i])
rig.xform(softTransform,t = origPos,wd = True)
def createCluster( clusterName, objs, **kwargs): """ Creates cluster on object / objects """ cluster = (cmds.cluster(objs, name = (clusterName + "_CLS"), **kwargs))[1] clusterGrp = cmds.group(cluster, name = (clusterName + "_GRP") ) return [cluster,clusterGrp]
def cluster_on_curve(cu):
# find number of CVs in curve
numCVs = cmds.getAttr('%s.controlPoints' % cu, size=1)
res = []
# make CV into a cluster
for i in range(numCVs):
cl = cmds.cluster('%s.cv[%s]' % (cu, i), relative=False, n='vk_cluster#')[1]
res.append(cl)
return res
def ctrlTocv(self ,ctrlList,spanCrv):
#--------------------------------------------------------------------------------------#
#note : control the curve points.
#--------------------------------------------------------------------------------------#
crvPointNum = len(mc.ls(spanCrv+'.cv[:]' , fl=1))
for i in range(crvPointNum):
clu = mc.cluster(spanCrv + '.cv[' + str(i) + ']',n = ctrlList[i] + '_clu')[1]
mc.setAttr(clu + '.visibility',0)
mc.parent(clu,ctrlList[i])
