def create_waveSystem(self):
horizAmp = self.autoJnt.addAttr('horizontalAmplitude',
attributeType='float',
min=-5,
max=5,
defaultValue=0,
keyable=True)
horizWaveLength = self.autoJnt.addAttr('horizontalWaveLength',
attributeType='float',
min=-.01,
max=1,
defaultValue=1,
keyable=True)
vertAmp = self.autoJnt.addAttr('verticalAmplitude',
attributeType='float',
min=-5,
max=5,
defaultValue=0,
keyable=True)
vertWaveLength = self.autoJnt.addAttr('verticalWaveLength',
attributeType='float',
min=-.01,
max=1,
defaultValue=1,
keyable=True)
#horizontal deformer
horizontalWave, horizontalWaveHandle = pm.nonLinear(
self.ribbonSystem.nurbsPatch, type='wave')
horizontalWave.renameNode(name=self.TipName,
base="%sWaveDeformerHorizontal_1")
horizontalWaveHandle.renameNode(name=self.TipName,
base="%sWaveDeformerHorizontal_1")
#vertical deformer
verticalWave, verticalWaveHandle = pm.nonLinear(
self.ribbonSystem.nurbsPatch, type='wave')
verticalWave.renameNode(name=self.TipName,
base="%sWaveDeformerHorizontal")
verticalWaveHandle.renameNode(name=self.TipName,
base="%sWaveDeformerHorizontal")
pm.delete(
pm.orientConstraint(self.fkJnts[0],
horizontalWaveHandle,
maintainOffset=False))
pm.delete(
pm.orientConstraint(self.fkJnts[0],
verticalWaveHandle,
maintainOffset=False))
horizontalWaveHandle.rx.set(horizontalWaveHandle.rx.get() + 90)
horizAmp.connect(horizontalWave.amp)
horizWaveLength.connect(horizontalWave.wav)
vertAmp.connect(verticalWave.amp)
vertWaveLength.connect(verticalWave.wav)
def createBendDeformerOnCurve(curveTransforms, upDir=(1,0,0), aimDir=(0,1,0)):
'''Creates bend deformers on every curve and aims them at the end
Args:
curveTransforms ([pm.nt.Transform]): list of transforms with nurbsCurve shapes
upDir (float, float, float): up direction for aim to orient the bend deformer
Returns:
([pm.nt.nonLinear]): list of bend deformers
Usage:
createBendDeformerOnCurve(pm.ls(sl=True))
'''
bends=[]
for curveTransform in curveTransforms:
bendName = curveTransform.name().replace('CRV','BEND')
bend = pm.nonLinear(curveTransform, type='bend', frontOfChain=True, curvature=0.0, lowBound=0, highBound=1)
bend[0].rename(bendName.replace('BEND','BENDHDL'))
bend[1].rename(bendName)
startPosition = curveTransform.getShape().cv[0].getPosition(space='world')
endPosition = curveTransform.getShape().cv[-1].getPosition(space='world')
loc = pm.spaceLocator()
pm.move(loc, endPosition, a=True)
pm.move(bend[1], startPosition, a=True)
aimConst = pm.aimConstraint( loc, bend[1], upVector=upDir, aimVector=aimDir )
pm.delete([loc, aimConst])
bends.append(bend)
return bends
def makeLantern(): #clear workspace cmds.select(all=True) cmds.delete() #get values from sliders ridges = cmds.intSliderGrp(ridgesSlider, q=True, value=True) deform = cmds.intSliderGrp(deformSlider, q=True, value=True) bend = cmds.intSliderGrp(bendSlider, q=True, value=True) bendNum = bend/100.0+1.0 flatten = float(cmds.intSliderGrp(flattenSlider, q=True, value=True)) lantern = pm.polySphere(n='lantern', sx=10, r=1, sy=ridges) rings = pm.polySelect( lantern, er=1) pm.select(lantern, cl=True) toggle = True for i in rings: if toggle: pm.polySelect( lantern, el=i) pm.scale(pm.selected(), [bendNum,bendNum,bendNum], xz=True) toggle = not toggle pm.select(lantern) pm.displaySmoothness(divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3) wave = pm.nonLinear(type='wave', amplitude=0.03) pm.setAttr(wave[0]+'.wavelength', deform/100+0.1) pm.rotate(wave, 0, 0, '45deg') pm.select(all=True) pm.scale(lantern, [1,1-(flatten/100),1], xyz=True) pm.delete(ch=True)
def importDeformers(fileName):
deformerDict = json.loads(open(fileName).read())
fileDir = '\\'.join(fileName.split('\\')[:-1])
for key in deformerDict.keys():
geo = deformerDict[key]['geo']
pm.select(geo)
dfm = pm.nonLinear(name=key, type=deformerDict[key]['nlType'])
pm.xform(dfm[1], ws=1, m=deformerDict[key]['mtx'])
parent = deformerDict[key]['parent']
if parent:
dfm[1].setParent(parent)
for param in deformerDict[key]['params'].keys():
attr = pm.Attribute(('%s.%s' % (dfm[0].name(), param)))
if not attr.isArray():
attr.set(deformerDict[key]['params'][param])
for conn in deformerDict[key]['conns'].keys():
pm.Attribute(deformerDict[key]['conns'][conn]).connect(
'%s.%s' % (dfm[0].name(), conn))
for g in geo:
weightsFile = '%s_%s_weights.xml' % (g, key)
pm.select(g)
try:
pm.deformerWeights(weightsFile,
im=1,
deformer=dfm[0],
path=fileDir)
except:
print 'unable to load weights:\n\tdeformer: %s\n\tshape: %s\n\tweightsFile: %s' % (
dfm[0], g, weightsFile)
def bdAddTwist(self,surfaceRbn_BS):
pm.select(surfaceRbn_BS)
twistDef, twistDefTransform = pm.nonLinear(type='twist')
twistDefTransform.rename(surfaceRbn_BS.name().replace('SRF_BS','twistHandle'))
twistDef.rename(surfaceRbn_BS.name().replace('SRF_BS','twist'))
twistDefTransform.rotateX.set(180)
return twistDef, twistDefTransform
def build(name=None, crv=None, reg_node=None, log=False):
"""Create ine node deformer and attributes on given plane, and
IK control connected to the reg_node.
name -- Prefix name. Str
crv -- Curve to add deformer to. nt.Transform
reg_node -- registration node. nt.Transform
"""
general.check_type(name, "name", [str])
general.check_type(crv, "crv", [pm.nt.Transform])
general.check_type(reg_node, "reg_node", [pm.nt.Transform])
cnt_attr = "%s1_ik_cnt" % name
if not hasattr(reg_node, cnt_attr):
raise errors.InputError("reg_node", reg_node, "Missing attr: %s" % cnt_attr)
attr = getattr(reg_node, cnt_attr)
cnt = attr.listConnections()[0]
if log:
str_1 = "Cnt: ", cnt
general.logging.debug(str_1)
crv2 = crv.duplicate()
sineDef, sineHndl = pm.nonLinear(crv2, typ="sine", name="%s_sineDeformer" % name)
bs = pm.blendShape(crv2, crv, foc=True, name="%s_sineBlendShape" % name)[0]
attr = getattr(bs, crv2[0].name())
attr.set(1)
sineDef.rename("%s_sineDeformer" % name)
sineHndl.rename("%s_sineDeformerHandle" % name)
attrs = {"sineOffOn": [1, 0, 1], "amplitude": 0.3, "wavelength": 2, "offset": 0, "direction": 0}
for attr in attrs.keys():
if isinstance(attrs[attr], list):
pm.addAttr(cnt, ln=attr, dv=attrs[attr][0], min=attrs[attr][1], max=attrs[attr][2], k=1)
else:
pm.addAttr(cnt, ln=attr, dv=attrs[attr], k=1)
cnt.sineOffOn >> sineDef.envelope
cnt.amplitude >> sineDef.amplitude
cnt.wavelength >> sineDef.wavelength
cnt.offset >> sineDef.offset
cnt.direction >> sineHndl.rotateY
# Setup the handle
hndl_grp = pm.group(name="%s_hndlGrp" % name, em=1)
pm.parent(sineHndl, hndl_grp)
sineHndl.rz.set(180)
sineDef.dropoff.set(1)
sineDef.lowBound.set(0)
sineDef.highBound.set(2)
control.register_object(reg_node, "sine_handle", sineHndl)
return reg_node
def add_sine(self):
nurbs_sine = pm.duplicate(self.nurbs,
name='geo_' + self.ribbon_name + '_sine')
# create sine deformer
dfm_sine, tfm_sine = pm.nonLinear(nurbs_sine, type='sine')
tfm_sine.setRotation([0, 0, 90], space='world')
dfm_sine.dropoff.set(1)
pm.blendShape(nurbs_sine, self.nurbs, weight=[0, 1])
def addTwist(self):
pm.select(self.rbnBsSrf)
twistDef, twistDefTransform = pm.nonLinear(self.rbnBsSrf, type='twist')
twistDefTransform.rename(self.rbnName + '_srf_bs_twistHandle')
twistDefTransform.scale.set(
[self.rbnLength * 0.5, self.rbnLength * 0.5, self.rbnLength * 0.5])
twistDefTransform.hide()
pm.parent(twistDefTransform, self.rbnNoTransformGrp)
twistDef.rename(self.rbnName + '_srf_bs_twist')
twistDefTransform.rotateZ.set(90)
self.rbnTwist = twistDef
print twistDefTransform, twistDefTransform.scale
pm.select(cl=1)
def saveDeformers():
saveFilePath = pm.fileDialog2(fileFilter='*.json')[0]
if saveFilePath:
saveFileDir = '/'.join(saveFilePath.split('/')[:-1]) + '/'
dfms = [dfm for dfm in pm.ls() if pm.nodeType(dfm) in deformerTypes]
deformerDict = {}
for dfm in dfms:
key = dfm.name()
handle = getHandle(dfm)
deformerDict[key] = {}
deformerDict[key]['nlType'] = getNonlinearType(dfm)
deformerDict[key]['mtx'] = pm.xform(handle, q=1, ws=1, m=1)
parent = None
if handle.getParent():
parent = handle.getParent().name()
deformerDict[key]['parent'] = parent
deformerDict[key]['params'] = {}
deformerDict[key]['geo'] = [
geo for geo in pm.nonLinear(dfm, q=1, geometry=1)
]
for geo in deformerDict[key]['geo']:
fileName = '%s_%s_weights.xml' % (geo, key)
toSkip = [node.name() for node in dfms if not node == dfm]
pm.deformerWeights(fileName,
export=1,
sh=geo,
skip=toSkip,
path=saveFileDir)
attrs = [
a for a in pm.listAttr(dfm)
if pm.Attribute('%s.%s' %
(key, a)).isKeyable() and not 'weight' in a
]
for attr in attrs:
deformerDict[key]['params'][attr] = pm.getAttr(
'%s.%s' % (dfm.name(), attr))
deformerDict[key]['conns'] = {}
for attr in attrs:
if not pm.Attribute('%s.%s' % (key, attr)).isArray():
conn = pm.listConnections('%s.%s' % (key, attr),
plugs=1,
d=0)
if conn:
deformerDict[key]['conns'][attr] = conn[0].name()
with open(saveFilePath, 'w') as outfile:
json.dump(deformerDict, outfile)
def createBend(self, obj, coords, parent=None):
# bend1
pm.select(obj)
bend = pm.nonLinear(type='bend')
bendTransform = bend[1]
bendTransform.translate.set(coords[0])
pm.xform(bendTransform, ro=coords[1], ws=1)
pm.xform(bendTransform, ro=(0, 0, -90), os=1, r=1)
bendScale = bendTransform.scaleX.get() * 2
bendTransform.scale.set(bendScale, bendScale, bendScale)
bend[0].lowBound.set(0)
if parent:
bendTransform.setParent(parent)
return bend
def extendPipe( jointLength=1 ):
defaultLength = 3.0
currJnt = ''
name = ''
root = ''
newJnts = []
for sel in pm.selected():
sel.select()
# for now, there's no branching, so we find the deepest joint
try:
currJnt = sel
name = currJnt.split('_')[0]
root = pm.nt.Joint( '%s_Jnt0' % name )
except:
raise "select an object on the pipe that you want to extend"
# naming
#----------
num = int(currJnt.extractNum())
try:
twoPrev = int(currJnt.getParent().getParent().extractNum())
except:
twoPrev = num-2
try:
prev = int(currJnt.getParent().extractNum())
except:
prev = num-1
curr = num
new = int(currJnt.nextUniqueName().extractNum())
print "extending from", currJnt, new
branchNum = len(currJnt.getChildren())
#print '%s has %s children' % (currJnt, branchNum)
if branchNum:
print "new segment is a branching joint"
currJnt.addAttr( 'pipeLengthInBtwn%s' % branchNum, min=0 )
#currJnt.attr( 'pipeLengthInBtwn%s' % branchNum ).showInChannelBox(1)
#print twoPrev, prev, curr, new
rigGrp = '%s_RigGrp' % name
geoGrp = '%s_GeoGrp' % name
# new skeletal joint
#---------------------
if new>1:
prevJnt = pm.nt.Joint( '%s_Jnt%s' % (name, prev) )
pos = 2*currJnt.getTranslation(ws=1) - prevJnt.getTranslation(ws=1)
else:
prevJnt = None
pos = currJnt.getTranslation(ws=1) + [0,defaultLength,0]
newJnt = pm.joint( p=pos, n= '%s_Jnt%s' % (name, new) )
# re-orient the last created joint, which is considered our current joint
pm.joint( currJnt, e=1, zeroScaleOrient=1, secondaryAxisOrient='yup', orientJoint='xyz')
# pymel method: NEEDS FIXING
#currJnt.setZeroScaleOrient(1)
#currJnt.setSecondaryAxisOrient('yup') # Flag secondaryAxisOrient can only be used in conjunction with orientJoint flag.
#currJnt.setOrientJoint('xyz')
newJnt.scale.lock()
newJnt.addAttr( 'pipeLength',
defaultValue=jointLength, min=.0001 )
newJnt.pipeLength.showInChannelBox(1)
newJnt.addAttr( 'pipeLengthInBtwn0', min=0 )
#newJnt.attr( 'pipeLengthInBtwn0' ).showInChannelBox(1)
newJnt.addAttr( 'pipeLeadIn', dv=0, min=0 )
newJnt.pipeLeadIn.showInChannelBox(1)
newJnt.addAttr( 'radiusMultiplier', dv=1, min=0 )
newJnt.radiusMultiplier.showInChannelBox(1)
newJnt.displayHandle = 1
newJnt.radius.showInChannelBox(0)
# bend hierarchy
#-----------------
trans = pm.group( empty=1, n='%s_Elbow%s' % (name, new))
trans.rotateOrder = 1
pm.aimConstraint( currJnt, trans,
aimVector = [0, -1, 0],
upVector = [-1, 0, 0]
)
pm.pointConstraint( newJnt, trans )
trans.setParent( rigGrp )
# keep the end joint oriented along the joint chain so that it can be slid back
# and forth to change the length of the current pipe segment
pm.delete( pm.orientConstraint( trans, newJnt ) )
# Main Pipe
#------------
pipe, pipeHist = pm.polyCylinder( height = 1, radius=1,
name = '%s_Geo%s' % (name, new) )
pipeHist = pipeHist.rename( '%s_GeoHist%s' % (name, new) )
pipe.setPivots( [0, -.5, 0], r=1 )
root.globalPipeRadius >> pipe.sx
root.globalPipeRadius >> pipe.sz
pipeHist.createUVs = 3 # normalize and preserve aspect ratio
root.subdivisionsAxis >> pipeHist.subdivisionsAxis
# Pipe Connectors
#-------------
pipeConn1, pipeConnHist1 = pm.polyCylinder( height = .1, radius=1,
name = '%s_Connector1AGeo%s' % (name, new) )
pipeConnHist1 = pipeConnHist1.rename( '%s_Connector1AHist%s' % (name, new) )
pipeConn1.setPivots( [0, -.05, 0], r=1 )
pipeConn1.setParent( pipe, relative=True )
pipeConn1.rotate.lock()
root.subdivisionsAxis >> pipeConnHist1.subdivisionsAxis
pipeConn2, pipeConnHist2 = pm.polyCylinder( height = .1, radius=1,
name = '%s_Connector2AGeo%s' % (name, new) )
pipeConnHist2 = pipeConnHist2.rename( '%s_Connector2AHist%s' % (name, new) )
pipeConn2.setPivots( [0, .05, 0], r=1 )
pipeConn2.setParent( pipe, relative=True )
pipeConn2.rotate.lock()
root.subdivisionsAxis >> pipeConnHist2.subdivisionsAxis
pipeConn1, pipeConnHist1 = pm.polyCylinder( height = .1, radius=1,
name = '%s_Connector1BGeo%s' % (name, new) )
pipeConnHist1 = pipeConnHist1.rename( '%s_Connector1BHist%s' % (name, new) )
pipeConn1.setPivots( [0, -.05, 0], r=1 )
pipeConn1.setParent( pipe, relative=True )
pipeConn1.rotate.lock()
pipeConn1.visibility = 0
root.subdivisionsAxis >> pipeConnHist1.subdivisionsAxis
pipeConn2, pipeConnHist2 = pm.polyCylinder( height = .1, radius=1,
name = '%s_Connector2BGeo%s' % (name, new) )
pipeConnHist2 = pipeConnHist2.rename( '%s_Connector2BHist%s' % (name, new) )
pipeConn2.setPivots( [0, .05, 0], r=1 )
pipeConn2.setParent( pipe, relative=True )
pipeConn2.rotate.lock()
pipeConn2.visibility = 0
root.subdivisionsAxis >> pipeConnHist2.subdivisionsAxis
pipe.setParent( geoGrp )
#constraints
pm.pointConstraint( currJnt, pipe )
aim = pm.aimConstraint( newJnt, pipe )
aim.offsetZ = -90
# convert the previous pipe joint into a bendy joint
if new > 1:
currElbow = pm.PyNode('%s_Elbow%s' % (name, curr) )
pipeLoc = pm.spaceLocator( n= '%s_PipeDummy%s' % (name, new) )
pipeLoc.hide()
tweak = pm.group(n='%s_ElbowTweak%s' % (name, new))
tweak.rotateOrder = 2
#tweak.translate = currElbow.translate.get()
tweak.setParent( currElbow, r=1 )
pm.aimConstraint( prevJnt, tweak,
aimVector = [1, 0, 0],
upVector = [0, -1, 0],
skip=['z', 'x'] )
# Pipe Joint
#------------
pipeJnt, pipeJntHist = pm.polyCylinder( height = 1, radius=1,
name = '%s_JntGeo%s' % (name, new),
subdivisionsAxis = 20,
subdivisionsHeight = 30 )
pipeJnt.setParent( geoGrp )
pipeJnt.sy = jointLength
pipeJnt.visibility = 0
pipeJntHist = pipeJntHist.rename( '%s_JntGeoHist%s' % (name, new) )
pipeJntHist.createUVs = 3 # normalize and preserve aspect ratio
root.subdivisionsAxis >> pipeJntHist.subdivisionsAxis
root.subdivisionsJoint >> pipeJntHist.subdivisionsHeight
# constraints
pm.parentConstraint( pipeLoc, pipeJnt )
pipeJnt.translate.lock()
pipeJnt.rotate.lock()
#pipeJnt.scale.lock()
aim = pm.PyNode('%s_Elbow%s_aimConstraint1' % (name, curr))
aim.setWorldUpType( 2 )
aim.setWorldUpObject( newJnt )
bend, bendHandle = pm.nonLinear( '%s_JntGeo%s' % (name, new),
type='bend' )
bendHandle = pm.nt.Transform(bendHandle).rename( '%s_BendHandle%s' % (name, new) )
bendHandle.sx =.5
bendHandle.hide()
bend.rename( '%s_Bend%s' % (name, new) )
pm.parentConstraint( '%s_ElbowTweak%s' % (name, new), bendHandle )
aim = '%s_ElbowTweak%s_aimConstraint1' % (name, new)
#aim.worldUpType.set( 1 )
pm.aimConstraint( aim, e=1, worldUpType='object', worldUpObject=newJnt )
bendHandle.setParent(rigGrp)
expr = """
float $v1[];
$v1[0] = %(name)s_Elbow%(twoPrev)s.translateX - %(name)s_Elbow%(prev)s.translateX;
$v1[1] = %(name)s_Elbow%(twoPrev)s.translateY - %(name)s_Elbow%(prev)s.translateY;
$v1[2] = %(name)s_Elbow%(twoPrev)s.translateZ - %(name)s_Elbow%(prev)s.translateZ;
float $v2[];
$v2[0] = %(name)s_Elbow%(curr)s.translateX - %(name)s_Elbow%(prev)s.translateX;
$v2[1] = %(name)s_Elbow%(curr)s.translateY - %(name)s_Elbow%(prev)s.translateY;
$v2[2] = %(name)s_Elbow%(curr)s.translateZ - %(name)s_Elbow%(prev)s.translateZ;
float $mag = sqrt ( $v2[0]*$v2[0] + $v2[1]*$v2[1] + $v2[2]*$v2[2] );
float $angleData[] = `angleBetween -v1 $v1[0] $v1[1] $v1[2] -v2 $v2[0] $v2[1] $v2[2] `;
float $angle = $angleData[3];
if ( !equivalentTol($angle,180.0, 0.1) )
{
float $jointDeg = 180 - $angle;
float $jointRad = -1 * deg_to_rad( $jointDeg );
%(name)s_Bend%(curr)s.curvature = $jointRad/2;
%(name)s_ElbowTweak%(curr)s.rotateZ = $jointDeg/2;
%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s = %(name)s_Jnt%(prev)s.pipeLength;
float $pipeLength = %(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s;
float $centerAngleRad = deg_to_rad(90 -$angle/2);
float $delta = 0;
float $pipeLengthRatio = 1;
if ($centerAngleRad > 0.0) {
float $radius = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s/ $centerAngleRad;
$delta = $radius - ($radius * cos( $centerAngleRad ));
$pipeLengthRatio = .5 * $pipeLength / ( $radius * sin( $centerAngleRad ) );
$pipeLength *= $pipeLengthRatio;
}
%(name)s_PipeDummy%(curr)s.translateX = -1*$delta;
%(name)s_BendHandle%(curr)s.scaleX = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s;
%(name)s_BendHandle%(curr)s.scaleY = %(name)s_BendHandle%(curr)s.scaleX;
%(name)s_BendHandle%(curr)s.scaleZ = %(name)s_BendHandle%(curr)s.scaleX;
%(name)s_JntGeo%(curr)s.scaleY = $pipeLength * (1.0+%(name)s_Jnt%(curr)s.pipeLeadIn);
%(name)s_JntGeo%(curr)s.scaleX = %(name)s_Jnt0.globalPipeRadius + %(name)s_Jnt0.globalJointRadius;
%(name)s_JntGeo%(curr)s.scaleZ = %(name)s_JntGeo%(curr)s.scaleX;
%(name)s_JntGeo%(curr)s.visibility = 1;
%(name)s_Connector1BGeo%(curr)s.visibility=1;
%(name)s_Connector2BGeo%(curr)s.visibility=1;
}
else
{
%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s = 0;
%(name)s_JntGeo%(curr)s.scaleY = 0;
%(name)s_JntGeo%(curr)s.visibility = 0;
%(name)s_Connector1BGeo%(curr)s.visibility=0;
%(name)s_Connector2BGeo%(curr)s.visibility=0;
}
%(name)s_Connector1AGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * (1/%(name)s_Geo%(curr)s.scaleY);
%(name)s_Connector2AGeo%(curr)s.scaleY = %(name)s_Connector1AGeo%(curr)s.scaleY;
%(name)s_Connector1AGeo%(curr)s.translateY = -.5 + %(name)s_Connector1AHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset;
%(name)s_Connector2AGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1AHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset;
%(name)s_Connector1AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector1AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector1BGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * (1/%(name)s_Geo%(curr)s.scaleY);
%(name)s_Connector2BGeo%(curr)s.scaleY = %(name)s_Connector1BGeo%(curr)s.scaleY;
%(name)s_Connector1BGeo%(curr)s.translateY = -.5 + %(name)s_Connector1BHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset - .1*%(name)s_Connector1BGeo%(curr)s.scaleY;
%(name)s_Connector2BGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1BHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset + .1*%(name)s_Connector1BGeo%(curr)s.scaleY;
%(name)s_Connector1BGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector1BGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2BGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2BGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Geo%(curr)s.scaleY = $mag - .5*%(name)s_Jnt%(curr)s.pipeLengthInBtwn0 - .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s;
normalize($v2);
%(name)s_Geo%(curr)s_pointConstraint1.offsetX = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[0];
%(name)s_Geo%(curr)s_pointConstraint1.offsetY = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[1];
%(name)s_Geo%(curr)s_pointConstraint1.offsetZ = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[2];
""" % { 'twoPrev' : prev,
'prev' : curr,
'curr' : new,
'new' : new+1,
'name': name,
'branch': branchNum
}
#print expr
print 'editing %s_PipeExpr%s' % (name, new)
#expression( '%s_PipeExpr%s' % (name, curr), e=1, s=expr, ae=1 )
pm.expression( s=expr, ae=1, n = '%s_PipeExpr%s' % (name, new) )
# special case for first joint
else:
expr = """
float $x = %(newJnt)s.tx;
float $y = %(newJnt)s.ty;
float $z = %(newJnt)s.tz;
float $mag = sqrt ( $x*$x + $y*$y + $z*$z );
%(name)s_Geo%(curr)s.sy = $mag - .5*%(newJnt)s.pipeLengthInBtwn0;
%(name)s_Connector1AGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * 1/%(name)s_Geo%(curr)s.scaleY;
%(name)s_Connector2AGeo%(curr)s.scaleY = %(name)s_Connector1AGeo%(curr)s.scaleY;
%(name)s_Connector1AGeo%(curr)s.translateY = -.5 + %(name)s_Connector1AHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset;
%(name)s_Connector2AGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1AHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset;
%(name)s_Connector1AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector1AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius;
%(name)s_Connector2AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius;
""" % { 'newJnt': newJnt,
'curr' : new,
'name': name
}
print 'creating %s_PipeExpr1' % (name)
pm.expression( s=expr, ae=1, n = '%s_PipeExpr1' % (name))
'''
expr = """
%(pipeJnt)s.scaleX = %(root)s.globalPipeRadius + %(root)s.globalJointRadius;
%(pipeJnt)s.scaleZ = %(pipeJnt)s.scaleX;
""" % { 'pipeJnt': pipeJnt,
'root' : '%s_Jnt0' % (name) }
print 'creating %s_PipeExpr%s' % (name, new)
expression( s=expr, ae=1, n = '%s_PipeExpr%s' % (name, new))
'''
pipe.translate.lock()
pipe.rotate.lock()
#pipe.scale.lock()
newJnts.append( newJnt )
pm.select(newJnts)
def addVolume(self):
self.rbnVolSrf = pm.duplicate(self.rbnSrf,
name=self.rbnName + '_vol_srf')[0]
pm.parent(self.rbnVolSrf, self.rbnNoTransformGrp)
self.rbnSquash, rbnSquashTransform = pm.nonLinear(type='squash')
rbnSquashTransform.rename(self.rbnName + '_vol_srf_squashHandle')
pm.parent(rbnSquashTransform, self.rbnNoTransformGrp)
self.rbnSquash.rename(self.rbnName + '_vol_srf_squash')
rbnSquashTransform.rotateZ.set(90)
self.rbnVolFlcGrp = self.createFlcs(self.rbnVolSrf)
pm.xform(self.rbnVolSrf, t=[0, 0, -0.5 * self.rbnWidth])
pm.xform(rbnSquashTransform, t=[0, 0, -0.5 * self.rbnWidth])
# Add volume attributes on the rbn trs
pm.addAttr(self.rbnCtrl,
ln='volumeAttr',
nn='------',
at='enum',
en='Volume:',
keyable=1)
self.rbnCtrl.volumeAttr.lock()
pm.addAttr(self.rbnCtrl,
ln='enableVolume',
nn='Enable',
at='double',
min=0,
max=1,
dv=0,
keyable=1)
pm.addAttr(self.rbnCtrl,
ln='multiplyVolume',
nn='Multiply',
at='double',
dv=0.7,
keyable=1)
pm.addAttr(self.rbnCtrl,
ln='smoothVolume',
nn='Smooth',
at='double',
min=0,
max=1,
dv=1,
keyable=1)
self.rbnCtrl.smoothVolume.connect(self.rbnSquash.startSmoothness)
self.rbnCtrl.smoothVolume.connect(self.rbnSquash.endSmoothness)
# drive the original surface follicles scale based on the translate Z of the vol follicles ( well, not the folicle , but the controler under it, the folicle has the global scale on it)
folicles = self.rbnVolFlcGrp.listRelatives(c=True, type='transform')
for flc in folicles:
flcShape = flc.getShape()
if (self.rbnDirection == 'v'):
flcShape.parameterU.set(0.0)
else:
flcShape.parameterV.set(0.0)
self.connectFlc(folicles.index(flc))
rbnSquashTransform.hide()
self.rbnVolFlcGrp.hide()
self.rbnVolSrf.hide()
# drive the suqash deformer factor with the scale of the ribbon
wireCrvInfo = pm.shadingNode('curveInfo',
asUtility=1,
name=self.rbnWireCrv.name() + '_ci')
self.rbnWireCrv.getShape().worldSpace.connect(wireCrvInfo.inputCurve)
self.rbnScaleRefCrv = pm.duplicate(self.rbnWireCrv,
name=self.rbnName + '_scl_crv')[0]
crvInfo = pm.shadingNode('curveInfo',
asUtility=1,
name=self.rbnScaleRefCrv.name() + '_ci')
self.rbnScaleRefCrv.getShape().worldSpace.connect(crvInfo.inputCurve)
scaleFactorMd = pm.shadingNode('multiplyDivide',
au=1,
name=self.rbnWireCrv.name() +
'_scale_factor_md')
scaleFactorMd.operation.set(2)
wireCrvInfo.arcLength.connect(scaleFactorMd.input1X)
crvInfo.arcLength.connect(scaleFactorMd.input2X)
zeroFactorAdl = pm.shadingNode('addDoubleLinear',
au=1,
name=self.rbnWireCrv.name() +
'_zerofactor_adl')
zeroFactorAdl.input2.set(-1)
scaleFactorMd.outputX.connect(zeroFactorAdl.input1)
enableVolMdl = pm.shadingNode('multDoubleLinear',
au=1,
name=self.rbnName + '_enable_volume_mdl')
self.rbnCtrl.enableVolume.connect(enableVolMdl.input1)
zeroFactorAdl.output.connect(enableVolMdl.input2)
enableVolMdl.output.connect(self.rbnSquash.factor)
blendNode = pm.blendShape(curveToWrap, hairNew, frontOfChain = True, name = "BS_hair_curves" )
print(blendNode)
# connect to controller
pm.connectAttr('M_head_up_02_ctrl.HairPop', '%s.hair_curves_bs' % blendNode[0].nodeName())
############################################################################ start step 3: blenshape connection
############################################################################ start step 4: connect squash and stretch
## ======================================================================== apply squash and stretch
headSquash = pm.ls('head_squash_Handle', r = 1)[0]
headBendRL = pm.ls('bend_headRL_Handle', r = 1)[0]
headBendFB = pm.ls('bend_headFB_Handle', r = 1)[0]
toSquashCurves = pm.PyNode('hair_curves')
pm.nonLinear(headSquash, e = True, g = toSquashCurves)
pm.nonLinear(headBendRL, e = True, g = toSquashCurves)
pm.nonLinear(headBendFB, e = True, g = toSquashCurves)
############################################################################ end step 4: connect squash and stretch
## ========================================================================= select curves to geocacheset (bake4hair)
setTmp = pm.listRelatives('hair_curves', allDescendents = True, type = 'transform')
geoCacheSet = []
for elt in setTmp:
if elt.getShape():
geoCacheSet.append(elt)
pm.select(geoCacheSet)
def doRig(self):
nurbsSurf = pm.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=self.width, lr=0.1, d=3, u=self.div, v=1, ch=0,
n=self.flexName + 'FlexNurbsSrf')[0]
nurbsSurf.visibility.set(False)
nurbsSurf.translate.set(self.width / 2, 0, 0)
spacing = 1.0 / float(self.div)
start = spacing / 2.0
grp1 = pm.group(n=self.flexName + 'Folicules_grp', empty=True)
grp2 = pm.group(em=True, n=self.flexName + 'ribbonGlobalMove')
grp3 = pm.group(em=True, n=self.flexName + 'FlexNoMove')
for i in range(int(self.div)):
foll = self.createFoll(self.flexName + 'Follicle' + str('%02d' % i), nurbsSurf, start + spacing * i, 0.5)
jnt1 = pm.joint(p=(0, 0, 0), n=self.flexName + str('%02d' % i) + '_jnt')
pm.move(0, 0, 0, jnt1, ls=True)
pm.parent(foll, grp1)
nurbsSurfBlend = pm.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=self.width, lr=0.1, d=3, u=self.div, v=1, ch=0,
n=self.flexName + 'FlexBlendNurbsSrf')[0]
nurbsSurfBlend.translate.set(self.width / 2, 0, 0)
pm.blendShape(nurbsSurfBlend, nurbsSurf, frontOfChain=True, tc=0, w=(0, 1))
crv = pm.curve(d=2, p=[((self.width * -0.5), 0, 0), (0, 0, 0), ((self.width * 0.5), 0, 0)], k=[0, 0, 1, 1],
n=self.flexName + 'Crv')
crv.translate.set(self.width / 2, 0, 0)
cls1 = pm.cluster(crv + '.cv[0]', crv + '.cv[1]', rel=True, n=self.flexName + 'Cls1')
pm.move((self.width * -0.5), 0, 0, cls1[1] + '.scalePivot', cls1[1] + '.rotatePivot')
cls2 = pm.cluster(crv + '.cv[2]', crv + '.cv[1]', rel=True, n=self.flexName + 'Cls2')
pm.move((self.width * 0.5), 0, 0, cls2[1] + '.scalePivot', cls2[1] + '.rotatePivot')
cls3 = pm.cluster(crv + '.cv[1]', rel=True, n=self.flexName + 'Cls3')
pm.percent(cls1[0], crv + '.cv[1]', v=0.5)
pm.percent(cls2[0], crv + '.cv[1]', v=0.5)
twist = pm.nonLinear(nurbsSurfBlend, type='twist', n=self.flexName + 'Twist')
twist[1].rotate.set(0, 0, 90)
wir = pm.wire(nurbsSurfBlend, gw=False, en=1.000000, ce=0.000000, li=0.000000, w=crv, dds=(0, 20))
wireNode = pm.PyNode(wir[0])
baseWire = [x for x in wireNode.connections() if 'BaseWire' in x.name()]
cntrl1 = controlTools.cntrlCrv(name=self.flexName + 'aux1', icone='grp')
cntrl2 = controlTools.cntrlCrv(name=self.flexName + 'aux2', icone='grp')
cntrl3 = controlTools.cntrlCrv(name=self.flexName + 'aux3', icone='grp')
pos = pm.pointOnSurface(nurbsSurfBlend, u=0.0, v=0.5)
cntrl1.getParent().translate.set(pos)
pos = pm.pointOnSurface(nurbsSurfBlend, u=1.0, v=0.5)
cntrl2.getParent().translate.set(pos)
pos = pm.pointOnSurface(nurbsSurfBlend, u=0.5, v=0.5)
cntrl3.getParent().translate.set(pos)
cntrl1.addAttr('twist', at='float', dv=0, k=1)
cntrl2.addAttr('twist', at='float', dv=0, k=1)
pm.pointConstraint(cntrl1, cntrl2, cntrl3.getParent())
cntrl1.translate >> cls1[1].translate
cntrl2.translate >> cls2[1].translate
cntrl3.translate >> cls3[1].translate
cntrl2.twist >> twist[0].startAngle
cntrl1.twist >> twist[0].endAngle
pm.parent(nurbsSurf, cntrl1.getParent(), cntrl2.getParent(), cntrl3.getParent(), grp2)
pm.parent(grp1, nurbsSurfBlend, cls1[1], cls2[1], cls3[1], baseWire, crv, twist[1], grp3)
pm.setAttr(grp3 + '.visibility', 0)
# pm.group (grp1,grp2,grp3,n=self.flexName+'Flex_grp')
# implementar squash/stretch
# implementar o connect to limb
def build(name=None, crv=None, reg_node=None, log=False):
'''Create ine node deformer and attributes on given plane, and
IK control connected to the reg_node.
name -- Prefix name. Str
crv -- Curve to add deformer to. nt.Transform
reg_node -- registration node. nt.Transform
'''
general.check_type(name, 'name', [str])
general.check_type(crv, 'crv', [pm.nt.Transform])
general.check_type(reg_node, 'reg_node', [pm.nt.Transform])
cnt_attr = '%s1_ik_cnt' % name
if not hasattr(reg_node, cnt_attr):
raise errors.InputError('reg_node', reg_node,
'Missing attr: %s' % cnt_attr)
attr = getattr(reg_node, cnt_attr)
cnt = attr.listConnections()[0]
if log:
str_1 = 'Cnt: ', cnt
general.logging.debug(str_1)
crv2 = crv.duplicate()
sineDef, sineHndl = pm.nonLinear(crv2,
typ='sine',
name='%s_sineDeformer' % name)
bs = pm.blendShape(crv2, crv, foc=True, name='%s_sineBlendShape' % name)[0]
attr = getattr(bs, crv2[0].name())
attr.set(1)
sineDef.rename('%s_sineDeformer' % name)
sineHndl.rename('%s_sineDeformerHandle' % name)
attrs = {
'sineOffOn': [1, 0, 1],
'amplitude': 0.3,
'wavelength': 2,
'offset': 0,
'direction': 0
}
for attr in attrs.keys():
if isinstance(attrs[attr], list):
pm.addAttr(cnt,
ln=attr,
dv=attrs[attr][0],
min=attrs[attr][1],
max=attrs[attr][2],
k=1)
else:
pm.addAttr(cnt, ln=attr, dv=attrs[attr], k=1)
cnt.sineOffOn >> sineDef.envelope
cnt.amplitude >> sineDef.amplitude
cnt.wavelength >> sineDef.wavelength
cnt.offset >> sineDef.offset
cnt.direction >> sineHndl.rotateY
# Setup the handle
hndl_grp = pm.group(name='%s_hndlGrp' % name, em=1)
pm.parent(sineHndl, hndl_grp)
sineHndl.rz.set(180)
sineDef.dropoff.set(1)
sineDef.lowBound.set(0)
sineDef.highBound.set(2)
control.register_object(reg_node, 'sine_handle', sineHndl)
return reg_node
def flexiplane(self, prefix=''):
"""
Build FlexiPlane
:param index: number of flexiplane in scene (auto managed by maya)
:return: FlexiPlane group node
"""
fp_name = '%sflexiPlane' % prefix
fp_name = nameCheck.nameCheck(fp_name + '*_GRP').replace(
'_GRP', '', 1) # flexiPlane_GRP
fp_surf = self.create_plane('%s_NURBS' % (fp_name))[0]
fp_surf.overrideEnabled.set(1)
fp_surf.overrideDisplayType.set(2)
# Assign Material
self.create_lambret(fp_surf,
color=(0.067, 0.737, 0.749),
transparency=(0.75, 0.75, 0.75))
# Create Follicles
# flc_name = 'flexiPlane'
v = 0.1 # 1/width
flcs = []
how_many_flc = 5 # width/2
for i in range(0, how_many_flc):
ofoll = self.create_follicle(
fp_surf, '%s_flc_%s_FLC' % (fp_name, letters[i + 26]), v, 0.5)
flcs.append(ofoll)
v += 0.2 # (1/width)*2
# Group Follicles
flc_grp = pm.group(flcs, name='%s_flcs_GRP' % (fp_name))
# creates flexiPlane controls curves at each end
self.ctrl_a = self.ctrl_square(name='%s_ctrl_a_CTRL' % (fp_name),
pos=[-5, 0, 0])
ctrl_ashape = self.ctrl_a.getShape()
pm.rename(ctrl_ashape, '%sShape' % self.ctrl_a)
self.ctrl_b = self.ctrl_square(name='%s_ctrl_b_CTRL' % (fp_name),
pos=[5, 0, 0])
ctrl_bshape = self.ctrl_b.getShape()
pm.rename(ctrl_bshape, '%sShape' % self.ctrl_b)
pm.select(cl=True)
# creates flexiPlane blendshape # blendshape suffix: _bShp_
fp_bshp = pm.duplicate(fp_surf, n='%s_bshp_NURBS' % (fp_name))[0]
pm.move(0, 0, -5, fp_bshp)
fps_bshp_node = pm.blendShape(fp_bshp,
fp_surf,
n='%s_BSHP' % (fp_name))[0]
pm.setAttr('%s.%s' % (fps_bshp_node, fp_bshp), 1)
# pm.rename('tweak1', '%sbshp_%stweak_01' % (fp_name, sur))
# creates curve for wire deformer
fp_curve = pm.curve(d=2,
p=[(-5, 0, -5), (0, 0, -5), (5, 0, -5)],
k=[0, 0, 1, 1],
n='%s_wire_CV' % (fp_name))
cl_a, cl_b, cl_mid = self.cluster_curve(fp_curve, fp_name)
# create and place twist deformer
pm.select(fp_bshp)
fp_twist = pm.nonLinear(type='twist', lowBound=-1, highBound=1)
# displays warning: pymel.core.general : could not create desired mfn. Defaulting MfnDependencyNode.
# doesn't seem to affect anything though
pm.rename(fp_twist[0], '%s_twistAttr_surface_NURBS' % (fp_name))
pm.rename(fp_twist[1], '%s_twist_Handle_DEFORMER' % (fp_name))
fp_twist[1].rz.set(90)
# connect start and end angle to their respective control
connect = self.ctrl_b.rx >> fp_twist[0].startAngle
connect = self.ctrl_a.rx >> fp_twist[0].endAngle
# skins wire to blendshape
fp_wire = pm.wire(
fp_bshp,
w=fp_curve,
gw=False,
en=1,
ce=0,
li=0, # dds=(0, 20),
n='%s_wireAttrs_DEFORMER' % (fp_name))
fp_wire[0].dropoffDistance[0].set(20)
hist = pm.listHistory(fp_surf)
tweaks = [t for t in hist if 'tweak' in t.nodeName()]
pm.rename(tweaks[2], '%s_cl_cluster_tweak' % (fp_name))
pm.rename(tweaks[0], '%s_wireAttrs_tweak' % (fp_name))
pm.rename(tweaks[1], '%s_extra_tweak' % (fp_name))
# group clusters
cl_grp = pm.group(cl_a[1],
cl_b[1],
cl_mid[1],
n='%s_cls_GRP' % (fp_name))
util.lock_and_hide_all(cl_grp)
# creates mid control
self.ctrl_mid = self.flexiplane_mid_ctrl(name='%s_ctrl_mid_CTRL' %
(fp_name))
ctrl_mid_grp = pm.group(self.ctrl_mid,
n='%s_grp_midBend_GRP' % (fp_name))
pm.pointConstraint(self.ctrl_a,
self.ctrl_b,
ctrl_mid_grp,
o=[0, 0, 0],
w=1)
# groups controls together and locks and hides group attributes
ctrl_grp = pm.group(self.ctrl_a,
self.ctrl_b,
ctrl_mid_grp,
n='%s_ctrl_GRP' % (fp_name))
util.lock_and_hide_all(ctrl_grp)
# connecting translate attrs of control curves for to the clusters
connect = []
connect.append(self.ctrl_a.t >> cl_a[1].t)
connect.append(self.ctrl_b.t >> cl_b[1].t)
connect.append(self.ctrl_mid.t >> cl_mid[1].t)
# makes mid_ctrl, flexiPlane and blendShape surfaces non renderable
util.no_render(fp_surf)
util.no_render(fp_bshp)
util.no_render(self.ctrl_mid)
# groups everything under 1 group then locks and hides the transform attrs of that group #flexiPlane_wire_surface0101BaseWire
self.fp_grp = pm.group(
fp_surf,
flc_grp,
fp_bshp,
fp_wire,
# '%s_wire_%s_BaseWire_GRP' % (fp_name, self.surfaceSuffix),
cl_grp,
ctrl_grp,
n='%s_GRP' % (fp_name))
util.lock_and_hide_all(self.fp_grp)
# creates global move group and extraNodes
fp_gm_grp = pm.group(fp_surf,
ctrl_grp,
n='%s_globalMove_GRP' % (fp_name))
fp_xnodes_grp = pm.group(flc_grp,
fp_bshp,
fp_wire,
'%s_wire_CVBaseWire' % (fp_name),
cl_grp,
n='%s_extraNodes_GRP' % (fp_name))
pm.parent(fp_twist, fp_xnodes_grp)
pm.parent(fp_xnodes_grp, self.fp_grp)
fp_xnodes_grp.overrideEnabled.set(1)
fp_xnodes_grp.overrideDisplayType.set(2)
# scale constrains follicles to global move group
for follicle in flcs:
mparent = follicle.getParent()
pm.scaleConstraint(fp_gm_grp, mparent)
# creates global move control
self.fp_gm_ctrl = self.global_ctrl(name=fp_name)
# moves global control into flexiPlane group then parent global move group to global move control.
pm.parent(self.fp_gm_ctrl, self.fp_grp)
pm.parent(fp_gm_grp, self.fp_gm_ctrl)
# joints placement
jnts = []
for i in range(0, len(flcs)):
posx = round(flcs[i].getParent().translateX.get(), 4)
jnt = pm.joint(p=(posx, 0, 0),
rad=0.5,
n='%sbind_%s_JNT' % (fp_name, letters[i + 26]))
jnts.append(jnt)
# parent joint under follicle
pm.parent(jnt, flcs[i].getParent())
# locks and hides transformNodes flexiPlane surface
util.lock_and_hide_all(fp_surf)
# hides blendShape, clusters and twist Deformer
fp_twist[1].visibility.set(0)
cl_grp.visibility.set(0)
fp_bshp.visibility.set(0)
fp_curve.visibility.set(0)
# selects the wire deformer and creates a curve info node...
# ...to get the wire deformers length
pm.select(fp_curve, r=True)
length = pm.arclen(ch=1)
length.rename('%scurveInfo_DEFORMER' % (fp_name))
# creates a multiplyDivideNode for squashStretch length...
# ...and sets it operation to divide
fp_div = pm.createNode('multiplyDivide',
n='%sdiv_squashStretch_length' % (fp_name))
fp_div.operation.set(2)
# secondary multDivNode for volume, sets input1X to 1
fp_div_vol = pm.createNode('multiplyDivide',
n='%sdiv_volume' % (fp_name))
fp_div_vol.operation.set(2)
fp_div_vol.input1X.set(1)
# creates a conditionNode for global_ctrl enable attr
fp_cond = pm.createNode('condition', n='%scond_volume' % (fp_name))
fp_cond.secondTerm.set(1)
# connects curve all the nodes
connect = length.arcLength >> fp_div.input1.input1X
fp_div.input2.input2X.set(10)
connect = fp_div.outputX >> fp_div_vol.input2.input2X
connect = self.fp_gm_ctrl.enable >> fp_cond.firstTerm
connect = fp_div_vol.outputX >> fp_cond.colorIfTrueR
fp_ctrl_global = self.fp_gm_ctrl.getShape()
for i in range(0, len(flcs)):
connect = fp_cond.outColorR >> jnts[i].sy
connect = fp_cond.outColorR >> jnts[i].sz
flcs[i].visibility.set(0)
# hides blendShape, clusters and twist Deformer
fp_twist[1].visibility.set(0)
cl_grp.visibility.set(0)
fp_bshp.visibility.set(0)
fp_curve.visibility.set(0)
pm.select(self.fp_gm_ctrl, r=True)
return self.fp_gm_ctrl
def addOperators(self):
"""Create operators and set the relations for the component rig
Apply operators, constraints, expressions to the hierarchy.
In order to keep the code clean and easier to debug,
we shouldn't create any new object in this method.
"""
host = self.getHost()
if not host:
host = self.root
# IK Chain -----------------------------------------
# Drive ik crv points
self.dm = []
for i in range(len(self.ik_ctl)):
num = str(i + 1).zfill(2)
d = pm.createNode('decomposeMatrix',
name=self.getName('ikCtl_%s_worldMtx2Srt_utl' %
num))
self.ik_ctl[i].worldMatrix[0].connect(d.inputMatrix)
d.outputTranslate.connect(self.ikCrv.controlPoints[i])
self.dm.append(d)
# Drive aimers --------------------------------------
ang = pm.createNode('angleBetween',
name=self.getName('_startAim_angle_utl'))
startLocalVec = pm.createNode('vectorProduct',
name=self.getName('_startVec_utl'))
self.dm[1].outputTranslate.connect(startLocalVec.input1)
self.ik_cns.worldInverseMatrix[0].connect(startLocalVec.matrix)
startLocalVec.operation.set(4)
startLocalVec.output.connect(ang.vector2)
ang.vector1.set(1, 0, 0)
ang.euler.connect(self.aim_loc.r)
ang = pm.createNode('angleBetween',
name=self.getName('_endAim_angle_utl'))
endLocalVec = pm.createNode('vectorProduct',
name=self.getName('_endVec_utl'))
self.dm[-2].outputTranslate.connect(endLocalVec.input1)
self.ik_ctl[-1].worldInverseMatrix[0].connect(endLocalVec.matrix)
endLocalVec.operation.set(4)
endLocalVec.output.connect(ang.vector2)
ang.vector1.set(-1, 0, 0)
ang.euler.connect(self.aim_end_loc.r)
# Drive ik rail points -----------------------------
self.ikRailMp = []
for i in range(numSamples):
num = str(i + 1).zfill(2)
param = (1.0 / (numSamples - 1)) * i
mp = pm.createNode('motionPath',
name=self.getName('ikCrv_%s_mp_utl' % num))
self.ikCrv.worldSpace[0].connect(mp.geometryPath)
mp.uValue.set(param)
mp.fractionMode.set(1)
mp.frontAxis.set(0)
mp.upAxis.set(1)
mp.follow.set(1)
mp.worldUpType.set(2)
vp = pm.createNode('vectorProduct',
name=self.getName('ikRail_%s_upVec_utl' % num))
vp.operation.set(3)
vp.normalizeOutput.set(1)
vp.input1Y.set(1)
if not i:
self.aim_loc.worldMatrix[0].connect(mp.worldUpMatrix)
self.aim_loc.worldMatrix[0].connect(vp.matrix)
else:
self.ikRailMp[-1].orientMatrix.connect(vp.matrix)
self.ikRailMp[-1].orientMatrix.connect(mp.worldUpMatrix)
pma = pm.createNode('plusMinusAverage',
name=self.getName('ikRail_%s_pos_utl' % num))
md = pm.createNode('multiplyDivide',
name=self.getName('ikRail_%s_upVecMult_utl' %
num))
md.input2.set((.1, .1, .1))
vp.output.connect(md.input1)
md.output.connect(pma.input3D[0])
mp.allCoordinates.connect(pma.input3D[1])
pma.output3D.connect(self.ikRailCrv.controlPoints[i])
self.ikRailMp.append(mp)
# Twist --------------------------------------------
mpUp = pm.createNode('motionPath', name=self.getName('twist_upMp_utl'))
self.ikRailCrv.worldSpace[0].connect(mpUp.geometryPath)
mpUp.uValue.set(1.0)
twistVec = pm.createNode('vectorProduct',
name=self.getName('twistVec_utl'))
mpUp.allCoordinates.connect(twistVec.input1)
self.aim_end_loc.worldInverseMatrix[0].connect(twistVec.matrix)
twistVec.operation.set(4)
twistAng = pm.createNode('angleBetween',
name=self.getName('twistAngle_utl'))
twistVec.output.connect(twistAng.vector1)
twistAng.vector2.set(0, 1, 0)
twistSign = pm.createNode('condition',
name=self.getName('twistSign_utl'))
twistVec.outputZ.connect(twistSign.firstTerm)
twistSign.operation.set(2)
twistSign.colorIfTrueR.set(-1)
signedTwist = pm.createNode('animBlendNodeAdditiveDA',
name=self.getName('twistResult_utl'))
twistAng.angle.connect(signedTwist.inputA)
twistSign.outColorR.connect(signedTwist.weightA)
# FK Chain -----------------------------------------
self.fk_mtx = []
print 'fk mpo: %s' % self.fk_npo
for i in range(self.settings['num_fk_ctls']):
num = str(i + 1).zfill(2)
param = (1.0 / (self.settings['num_fk_ctls'] - 1)) * i
mp = pm.createNode('motionPath',
name=self.getName('ikCrv_%s_mp_utl' % num))
mp.fractionMode.set(1)
mp.follow.set(1)
mp.frontAxis.set(0)
mp.upAxis.set(1)
mp.worldUpType.set(1)
self.ikCrv.worldSpace[0].connect(mp.geometryPath)
mp.uValue.set(param)
mpUp = pm.createNode('motionPath',
name=self.getName('ikCrv_%s_mp_utl' % num))
self.ikRailCrv.worldSpace[0].connect(mpUp.geometryPath)
mpUp.uValue.set(param)
mtxUp = pm.createNode('composeMatrix',
name=self.getName('ikCrv_%s_upMtx_utl' %
num))
mpUp.allCoordinates.connect(mtxUp.inputTranslate)
mtxUp.outputMatrix.connect(mp.worldUpMatrix)
wMtx = pm.createNode('composeMatrix',
name=self.getName('ikCrv_%s_worldMtx_utl' %
num))
mp.allCoordinates.connect(wMtx.inputTranslate)
mp.rotate.connect(wMtx.inputRotate)
self.fk_mtx.append(wMtx)
if not i:
mp.allCoordinates.connect(self.fk_npo[i].t)
mp.rotate.connect(self.fk_npo[i].r)
else:
localMtx = pm.createNode('multMatrix',
name=self.getName(
'ikCrv_%s_localMtx_utl' % num))
wMtx.outputMatrix.connect(localMtx.matrixIn[0])
iMtx = pm.createNode('inverseMatrix',
name='ikCrv_%s_worldInverseMtx_utl' % num)
self.fk_mtx[i - 1].outputMatrix.connect(iMtx.inputMatrix)
iMtx.outputMatrix.connect(localMtx.matrixIn[1])
self.fk_ctl[i - 1].worldMatrix[0].connect(localMtx.matrixIn[2])
d = pm.createNode('decomposeMatrix',
name=self.getName('ikCrv_%s_mtx2Srt_utl' %
num))
localMtx.matrixSum.connect(d.inputMatrix)
d.outputTranslate.connect(self.fk_npo[i].t)
d.outputRotate.connect(self.fk_npo[i].r)
twistMult = pm.createNode('animBlendNodeAdditiveDA',
name=self.getName(
'ikCrv_%s_twistMult_utl' % num))
twistMult.weightA.set(
(1.0 / (self.settings['num_fk_ctls'] - 1)) * i)
signedTwist.output.connect(twistMult.inputA)
twistMult.output.connect(mp.frontTwist)
# Drive fk crv points
self.fk_dm = []
for i in range(len(self.fk_ctl)):
num = str(i + 1).zfill(2)
d = pm.createNode('decomposeMatrix',
name=self.getName('fkCtl_%s_worldMtx2Srt_utl' %
num))
self.fk_ctl[i].worldMatrix[0].connect(d.inputMatrix)
d.outputTranslate.connect(self.fkCrv.controlPoints[i])
self.fk_dm.append(d)
# Drive avg nodes
pb = pm.createNode('pairBlend',
name=self.getName('fkAvg_%s_utl' % num))
self.fk_ctl[i].r.connect(pb.inRotate2)
self.fk_ctl[i].roll.connect(pb.inRotateX1)
pb.weight.set(0.5)
pb.outRotate.connect(self.fk_avg[i].r)
# FK rail crv points
vp = pm.createNode('vectorProduct',
name=self.getName('fkRailPoint_%s_utl' % num))
self.fk_avg[i].worldMatrix[0].connect(vp.matrix)
vp.input1.set(0, 0.1, 0)
vp.operation.set(4)
vp.output.connect(self.fkRailCrv.controlPoints[i])
# Stretch --------------------------------------------
self.crvInfo = pm.createNode('curveInfo',
name=self.getName('fk_crvInfo_utl'))
self.fkCrv.worldSpace[0].connect(self.crvInfo.inputCurve)
stretchScaled = pm.createNode('multiplyDivide',
name=self.getName('fk_crvLenScaled_utl'))
stretchScaled.operation.set(2)
self.dm[0].outputScaleX.connect(stretchScaled.input1X)
self.crvInfo.arcLength.connect(stretchScaled.input2X)
stretch = pm.createNode('multiplyDivide',
name=self.getName('fk_crvStretch_utl'))
stretchScaled.outputX.connect(stretch.input2X)
stretch.input1X.set(self.crvInfo.arcLength.get())
stretchClamp = pm.createNode('clamp',
name=self.getName('stretchClamp_utl'))
stretchClamp.maxR.set(1.0)
stretch.outputX.connect(stretchClamp.inputR)
# Sine ---------------------------------------------
pm.select(None)
sineDef = pm.nonLinear(self.sineCrv,
type='sine',
name=self.getName('sine_def'))
sineDef[1].rz.set(-90)
sineDef[1].setParent(self.noXForm)
host.sine_roll.connect(sineDef[1].ry)
sinePosMult = pm.createNode('multDoubleLinear',
name=self.getName('sinePosMult_utl'))
host.sine_centre.connect(sinePosMult.input1)
sinePosMult.input2.set(self.settings['num_joints'])
sinePosMult.output.connect(sineDef[1].tx)
host.sine_decay.connect(sineDef[0].dropoff)
host.sine_amplitude.connect(sineDef[0].amplitude)
host.sine_wavelength.connect(sineDef[0].wavelength)
host.sine_offset.connect(sineDef[0].offset)
sineHighRange = pm.createNode('setRange',
name=self.getName('sineHighRange_utl'))
sineHighRange.oldMinX.set(0)
sineHighRange.oldMaxX.set(1)
sineHighRange.minX.set(2)
sineHighRange.maxX.set(0)
host.sine_centre.connect(sineHighRange.valueX)
sineHighRange.outValueX.connect(sineDef[0].highBound)
sineLowRange = pm.createNode('setRange',
name=self.getName('sineLowRange_utl'))
sineLowRange.oldMinX.set(0)
sineLowRange.oldMaxX.set(1)
sineLowRange.minX.set(0)
sineLowRange.maxX.set(-2)
host.sine_centre.connect(sineLowRange.valueX)
sineLowRange.outValueX.connect(sineDef[0].lowBound)
# Joints -------------------------------------------
self.joints = []
for i in range(self.settings['num_joints']):
num = str(i + 1).zfill(2)
# per joint stretch and grow
param = (1.0 / (self.settings['num_joints'] - 1)) * i
stretchedParam = pm.createNode(
'multDoubleLinear',
name=self.getName('result_%s_stretchedParam_utl' % num))
stretchedParam.input1.set(param)
stretchClamp.outputR.connect(stretchedParam.input2)
stretchBlend = pm.createNode(
'blendTwoAttr',
name=self.getName('result_%s_stretchBlend_utl' % num))
stretchedParam.input1.connect(stretchBlend.input[1])
stretchedParam.output.connect(stretchBlend.input[0])
host.stretch.connect(stretchBlend.attributesBlender)
growBlend = pm.createNode('animBlendNodeAdditive',
name=self.getName(
'result_%s_growBlend_utl' % num))
stretchBlend.output.connect(growBlend.inputA)
host.grow.connect(growBlend.weightA)
# twisting and rolling
roll = pm.createNode('animBlendNodeAdditiveDA',
name=self.getName('result_%s_twist_utl' %
num))
host.roll.connect(roll.inputA)
host.twist.connect(roll.inputB)
growBlend.output.connect(roll.weightB)
mp = pm.createNode('motionPath',
name=self.getName('result_%s_mp_utl' % num))
self.fkCrv.worldSpace[0].connect(mp.geometryPath)
mp.fractionMode.set(1)
mp.frontAxis.set(0)
mp.upAxis.set(1)
mp.follow.set(1)
mp.worldUpType.set(3)
growBlend.output.connect(mp.uValue)
roll.output.connect(mp.frontTwist)
mpUp = pm.createNode('motionPath',
name=self.getName('result_%s_upMp_utl' % num))
self.fkRailCrv.worldSpace[0].connect(mpUp.geometryPath)
mpUp.fractionMode.set(1)
growBlend.output.connect(mpUp.uValue)
upVec = pm.createNode('plusMinusAverage',
name=self.getName('result_%s_upVec_utl' %
num))
mpUp.allCoordinates.connect(upVec.input3D[0])
mp.allCoordinates.connect(upVec.input3D[1])
upVec.operation.set(2)
upVec.output3D.connect(mp.worldUpVector)
# sine wave
sineMp = pm.createNode('motionPath',
name=self.getName('sine_%s_mp_utl' % num))
self.sineCrv.worldSpace[0].connect(sineMp.geometryPath)
sineMp.uValue.set(i)
j = pm.createNode('joint', name=self.getName('%s_dfm' % num))
if not i:
self.dm[0].outputScale.connect(j.s)
j.setParent(self.noXForm)
wMtx = pm.createNode('composeMatrix',
name=self.getName(
'result_%s_worldMtx_utl' % num))
mp.allCoordinates.connect(wMtx.inputTranslate)
mp.rotate.connect(wMtx.inputRotate)
localMtx = pm.createNode('multMatrix',
name=self.getName(
'result_%s_localMtx_utl' % num))
wMtx.outputMatrix.connect(localMtx.matrixIn[0])
#self.root.worldInverseMatrix[0].connect(localMtx.matrixIn[1])
d = pm.createNode('decomposeMatrix',
name=self.getName('result_%s_mtx2Srt_utl' %
num))
localMtx.matrixSum.connect(d.inputMatrix)
deformedPos = pm.createNode(
'plusMinusAverage',
name=self.getName('result_%s_deformedPos_utl' % num))
d.outputTranslate.connect(deformedPos.input3D[0])
sineMp.allCoordinates.yCoordinate.connect(
deformedPos.input3D[1].input3Dy)
sineMp.allCoordinates.zCoordinate.connect(
deformedPos.input3D[1].input3Dz)
deformedPos.output3D.connect(j.t)
d.outputRotate.connect(j.r)
else:
j.setParent(self.joints[-1])
wMtx = pm.createNode('composeMatrix',
name=self.getName(
'result_%s_worldMtx_utl' % num))
mp.allCoordinates.connect(wMtx.inputTranslate)
mp.rotate.connect(wMtx.inputRotate)
localMtx = pm.createNode('multMatrix',
name=self.getName(
'result_%s_localMtx_utl' % num))
wMtx.outputMatrix.connect(localMtx.matrixIn[0])
self.joints[-1].worldInverseMatrix[0].connect(
localMtx.matrixIn[1])
d = pm.createNode('decomposeMatrix',
name=self.getName('result_%s_mtx2Srt_utl' %
num))
localMtx.matrixSum.connect(d.inputMatrix)
deformedPos = pm.createNode(
'plusMinusAverage',
name=self.getName('result_%s_deformedPos_utl' % num))
d.outputTranslate.connect(deformedPos.input3D[0])
sineMp.allCoordinates.yCoordinate.connect(
deformedPos.input3D[1].input3Dy)
sineMp.allCoordinates.zCoordinate.connect(
deformedPos.input3D[1].input3Dz)
deformedPos.output3D.connect(j.t)
d.outputRotate.connect(j.r)
j.segmentScaleCompensate.set(0)
j.jo.set(0, 0, 0)
self.joints.append(j)
from PySide import QtGui
import pymel.core as pm
from pprint import pprint
import re
headSquash = pm.PyNode('head_squash_Handle')
bendHeadRL = pm.PyNode('bend_headRL_Handle')
bendHeadFB = pm.PyNode('bend_headFB_Handle')
headGrp = ['body_grp','m_eye_geo_group', 'eye_patch_grp' ]
pm.nonLinear(headSquash, e = True, g = headGrp )
pm.nonLinear(bendHeadRL, e = True, g = headGrp )
pm.nonLinear(bendHeadFB, e = True, g = headGrp )
helmetSquash = pm.PyNode('helmet_squash_Handle')
bendHelmetRL = pm.PyNode('bend_helmetFB_Handle')
bendHelmetFB = pm.PyNode('bend_helmetRL_Handle')
helmetGrp = ['helmet_grp']
pm.nonLinear(helmetSquash, e = True, g = helmetGrp )
pm.nonLinear(bendHelmetRL, e = True, g = helmetGrp )
pm.nonLinear(bendHelmetFB, e = True, g = helmetGrp )
def doRig(self):
if pm.objExists('head_contrained'):
constrained_grp = 'head_contrained'
else:
constrained_grp = pm.group(n='head_contrained', em=True)
if pm.objExists(self.name + "Ctrl_grp"):
pm.delete(self.name + "Ctrl_grp")
if pm.objExists(self.name + 'Sys_grp'):
pm.delete(self.name + 'Sys_grp')
deformLength = self.length.distance.get()
proxy = pm.polyCube(n="def_proxy", ch=False)[0]
matrix = pm.xform (self.midGuide, m=True, ws=True, q=True)
pm.xform(proxy, m=matrix, ws=True)
proxy.scaleY.set(deformLength)
pm.select(proxy)
squash = pm.nonLinear(type='squash')
pm.nonLinear(squash[0], e=True, lowBound=0, highBound=1, startSmoothness=0, endSmoothness=0)
pm.select(proxy)
bendA = pm.nonLinear(type='bend')
pm.nonLinear(bendA[0],e=True, lowBound=0, highBound=1, curvature=0)
pm.select(proxy)
bendB = pm.nonLinear(type='bend')
pm.nonLinear(bendB[0], e=True, lowBound=0, highBound=1, curvature=0)
matrix = pm.xform(self.baseGuide, m=True, ws=True, q=True)
deformers = pm.group(em=True, n=self.name + 'Sys_grp')
pm.xform(deformers, m=matrix, ws=True)
pm.parent(squash, bendA, bendB, proxy, deformers)
pm.setAttr(deformers + ".visibility", 0)
pm.xform(squash[1], m=matrix, ws=True)
pm.xform(bendA[1], m=matrix, ws=True)
pm.xform(bendB[1], m=matrix, ws=True)
pm.xform (bendB[1], ro=(0, 90 ,0), r=True)
pm.setAttr(bendB[0] + ".highBound", deformLength)
pm.setAttr(bendA[0] + ".highBound", deformLength)
pm.setAttr(squash[0] + ".highBound", deformLength)
## Criar controle
squashCtrl = pm.curve(d=1, p=[(-1, 0, -2), (1, 0, -2), (1, 0, 2), (3, 0, 2), (0, 0, 5), (-3, 0, 2), (-1, 0, 2),
(-1, 0, -2)], k=[0, 1, 2, 3, 4, 5, 6, 7], n="squash_ctrl")
pm.xform(squashCtrl, cp=True)
squashCtrl.rotateX.set(90)
squashCtrl.scale.set((0.5, 0.5, 0.5))
pm.makeIdentity(squashCtrl, apply=True, t=1, r=1, s=1, n=0, pn=1)
squashGrp = pm.group(squashCtrl, n=self.name+"Ctrl_grp")
pm.parent(squashGrp, constrained_grp)
matrix = pm.xform(self.ctrlGuide, m=True, ws=True, q=True)
pm.xform(squashGrp, m=matrix, ws=True)
# Conectar controle
mult = pm.shadingNode('multiplyDivide', asUtility=True)
pm.connectAttr((squashCtrl) + '.translateY', mult + '.input1Y')
pm.connectAttr((squashCtrl) + '.translateX', mult + '.input1X')
pm.connectAttr((squashCtrl) + '.translateZ', mult + '.input1Z')
pm.setAttr(mult + '.input2X', 5)
pm.setAttr(mult + '.input2Y', .2)
pm.setAttr(mult + '.input2Z', -5)
pm.connectAttr(mult + '.outputY', squash[0] + '.factor')
pm.connectAttr(mult + '.outputX', bendA[0] + '.curvature')
pm.connectAttr(mult + '.outputZ', bendB[0] + '.curvature')
maxExpandPos = self.midPos.distance.get()/deformLength
pm.setAttr(squash[0]+'.maxExpandPos', maxExpandPos)
self.guideMoveall.visibility.set(0)
def create_ribbon(numJoints=10, prefix='testRibbon', numSpans=5, startObj=None, endObj=None):
rigGrp = pm.group(empty=True, name='%s_rig_grp' %prefix)
ctrlGrp = pm.group(empty=True, name="%s_ctrl_grp" %prefix)
proxyGrp = pm.group(empty=True, name="%s_proxy_grp" %prefix)
ctrlGrp.overrideDisplayType.set(1) #template
proxyGrp.visibility >> ctrlGrp.overrideEnabled
#===========================================================================
# proxy
#===========================================================================
proxy_start = pm.spaceLocator(name='%s_root_start' %prefix)
pm.parent( proxy_start.add_parent_group(suffix='const'), proxyGrp)
proxy_end = pm.spaceLocator(name='%s_root_end' %prefix)
proxy_end.tx.set(1)
pm.parent( proxy_end.add_parent_group(suffix='const'), proxyGrp)
#===========================================================================
# proxy
#===========================================================================
rootCtrl = pm.spaceLocator(name='%s_root_ctrl' %prefix)
pm.parent(pm.parentConstraint(proxy_start, rootCtrl, mo=False), proxyGrp)
pm.parent(rootCtrl, ctrlGrp)
proxy_up = pm.spaceLocator(name='%s_root_up' %prefix)
proxy_up.ty.set(1)
pm.parent( proxy_up.add_parent_group(suffix='const'), proxyGrp)
proxy_mid = pm.spaceLocator(name='%s_root_mid' %prefix)
proxy_mid.tx.set(1)
proxy_mid_const = proxy_mid.add_parent_group(suffix='const')
pm.parent( proxy_mid_const, proxyGrp)
pm.pointConstraint(proxy_start, proxy_end, proxy_mid_const, mo=False)
pm.aimConstraint(proxy_end, proxy_start, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name())
pm.aimConstraint(proxy_start, proxy_end, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name())
pm.parentConstraint(rootCtrl, rigGrp, mo=False)
#===========================================================================
# ribbon plane
#===========================================================================
ribbonGrp = pm.group(empty=True, name="%s_ribbon_grp" %prefix)
pm.parent(ribbonGrp, rigGrp)
follicleGrp = pm.group(empty=True, name="%s_follicle_grp" %prefix)
pm.parent(follicleGrp, rigGrp)
follicleGrp.inheritsTransform.set(0)
follicleGrp.overrideDisplayType.set(2) #reference
proxyGrp.visibility >> follicleGrp.overrideEnabled
ribbonName = "%s_ribbon" %prefix
ribbon = pm.nurbsPlane(ax=[0,1,0], w=1, lr=0.05, d=3, u=10, v=1, ch=0, name=ribbonName)[0]
ribbon.translateX.set(0.5)
ribbon.rotateX.set(90)
pm.makeIdentity(ribbon, apply=True, t=1 ,r=1 ,s=1, n=0 ,pn=1)
ribbon.scalePivot.set(0,0,0)
ribbon.rotatePivot.set(0,0,0)
pm.parent(ribbon, ribbonGrp)
ribbonGrp.visibility.set(0)
#proxy_start.rotateX >> ribbon.rotateX
#===========================================================================
# ribbon follicles / joints
#===========================================================================
joints = []
proxyCubes = []
spacing = (1.0/(numJoints-1))
for i in range(numJoints):
uPos = i * spacing
jointName = "%s_%d" %(prefix, i+1)
fol = create_follicle(ribbon, uPos, 0.5)
fol_trans = fol.getParent()
pm.select(clear=True)
joint = pm.joint(name=jointName)
#=======================================================================
cube = pm.polyCube(w=spacing, h=spacing, d=spacing, ch=False)[0]
pm.parentConstraint(joint, cube)
pm.parent(cube, joint)
# pm.parent(cube, proxyGrp)
proxyCubes.append(cube)
cube.overrideEnabled.set(1)
cube.overrideDisplayType.set(2) #reference
#=======================================================================
pm.parent(joint, fol_trans, r=True)
pm.parent(fol_trans, follicleGrp)
joints.append(joint)
#===========================================================================
# ribbon wires
#===========================================================================
wireGrp = pm.group(empty=True, name="%s_wire_grp" %prefix)
pm.parent(wireGrp, rigGrp)
wireCtrlGrp = pm.group(empty=True, name='%s_wire_ctrl_grp' %prefix)
pm.parent(wireCtrlGrp, rootCtrl)
wireCtrlGrp.inheritsTransform.set(0)
wireName = '%s_wire' %prefix
wireCurve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name=wireName)
mel.eval("rebuildCurve -ch 0 -rpo 1 -rt 0 -end 1 -kr 0 -kcp 0 -kep 1 -kt 0 -s %d -d 2 %s" %(numSpans, wireCurve.name()))
wire2, wireCurve, wireBaseCurve = wire_deformer( wireCurve, ribbon)
pm.parent(wireCurve, wireBaseCurve, wireGrp)
#pm.reorderDeformers(wire1, wire2, ribbon)
#===========================================================================
# ribbon curve/ctrls
#===========================================================================
curve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name="%s_curve"%prefix)
pm.parent(curve, ribbonGrp)
#wire1, curve, baseCurve = wire_deformer( curve, wireCurve)
ctrls=[]
for cv in curve.cv:
clusterName = '%s_curve%d_cluster' %(prefix, cv.index())
ctrlName = "%s_curve%d_ctrl" %(prefix, cv.index())
cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName)
clusterHandle.visibility.set(0)
ctrl = pm.spaceLocator(name=ctrlName)
pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False))
pm.parentConstraint(ctrl, clusterHandle)
ctrls.append(ctrl)
pm.parent(clusterHandle, ribbonGrp)
startCtrl = ctrls[0]
midCtrl = ctrls[1]
endCtrl = ctrls[-1]
startCtrlName = "%s_start_ctrl" %prefix
endCtrlName = "%s_end_ctrl" %prefix
startCtrl.rename("%s_start_ctrl" %prefix)
startConst = startCtrl.add_parent_group(suffix='const')
pm.parent(pm.parentConstraint(proxy_start, startConst, mo=False), proxyGrp)
endCtrl.rename("%s_end_ctrl" %prefix)
endConst = endCtrl.add_parent_group(suffix='const')
pm.parent(pm.parentConstraint(proxy_end, endConst, mo=False), proxyGrp)
midCtrl.rename("%s_mid_ctrl" %prefix)
midConst = midCtrl.add_parent_group(suffix='const')
pm.parent(pm.parentConstraint(proxy_mid, midConst, mo=False), proxyGrp)
startCtrl.getShape().localPositionX.set(-1)
endCtrl.getShape().localPositionX.set(1)
pm.parent(startConst, endConst, midConst, rootCtrl)
#===========================================================================
# ribbon wire cluster
#===========================================================================
for cv in wireCurve.cv:
#cluster / ctrl
clusterName = '%s_wire%d_cluster' %(prefix, cv.index())
ctrlName = "%s_wire%d_ctrl" %(prefix, cv.index())
cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName)
ctrl = pm.spaceLocator(name=ctrlName)
pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False))
pm.parentConstraint(ctrl, clusterHandle)
pm.scaleConstraint(ctrl, clusterHandle)
#ctrl.t >> clusterHandle.t
#ctrl.r >> clusterHandle.r
#ctrl.s >> clusterHandle.s
ctrls.append(ctrl)
pm.parent(clusterHandle, wireGrp)
#revit
revit = pm.spaceLocator(name="%s_revit" %ctrl.name())
revit.getShape().localScale.set(0,0,0)
pm.delete(pm.parentConstraint(ctrl, revit, mo=False))
pm.parent(ctrl, revit)
revit_locator_to_curve(revit, curve)
rootCtrl.r >> revit.r
pm.parent(revit, wireCtrlGrp)
wireGrp.visibility.set(0)
#===========================================================================
# twist
#===========================================================================
twistGrp = pm.group(empty=True, name="%s_twist_grp" %prefix)
pm.parent(twistGrp, rigGrp)
startTwist = pm.group(empty=True, name="%s_start_twist" %prefix)
startTwistAim = startTwist.add_parent_group(suffix='aim')
pm.pointConstraint(startCtrl, startTwistAim, mo=False)
endTwist = pm.group(empty=True, name="%s_end_twist" %prefix)
endTwistAim = endTwist.add_parent_group(suffix='aim')
pm.pointConstraint(endCtrl, endTwistAim, mo=False)
startTwistUp = pm.spaceLocator(name="%s_start_twistUp" %prefix)
pm.delete(pm.parentConstraint(startCtrl, startTwistUp, mo=False))
startTwistUp.ty.set(1)
pm.parentConstraint(startCtrl, startTwistUp, mo=True)
endTwistUp = pm.spaceLocator(name="%s_end_twistUp" %prefix)
pm.parentConstraint(endCtrl, endTwistUp, mo=False)
endTwistUp.ty.set(1)
const = pm.parentConstraint(endCtrl, endTwistUp, mo=True)
pm.aimConstraint(endTwistAim, startTwistAim, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=startCtrl.name())
pm.aimConstraint(startTwistAim, endTwistAim, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=endCtrl.name())
#pm.aimConstraint(endTwist, startTwist, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=startTwistUp.name())
#pm.aimConstraint(startTwist, endTwist, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=endTwistUp.name())
twist, twistHdl = pm.nonLinear(ribbon , type='twist', foc=True, name='%s_twist'%prefix)
twistHdl.rotateZ.set(90)
startTwistAim.rx >> twist.endAngle
endTwistAim.rx >> twist.startAngle
#startTwist.rx >> twist.endAngle
#endTwist.rx >> twist.startAngle
pm.parent(startTwistUp, endTwistUp, twistHdl, startTwistAim, endTwistAim, twistGrp)
twistGrp.visibility.set(0)
#===========================================================================
# stretch and squash
#===========================================================================
stretchGrp = pm.group(empty=True, name="%s_stretch_grp" %prefix)
stretchGrp.addAttr('baseDistance', at='double')
pm.parent(stretchGrp, rigGrp)
stretchGrp.inheritsTransform.set(0)
stretchPlane = pm.nurbsPlane(ax=[0,1,0], ch=False, w=2, lr=1, d=3, u=2, v=2, name='%s_stretch_plane'%prefix)
squash, squashHdl = pm.nonLinear(stretchPlane, type='squash', foc=True, name="%s_squash"%prefix)
squashHdl.rotateZ.set(90)
for i in range(numJoints):
spacing = i * (1.0/(numJoints-1))
pointOnSurface = pm.createNode('pointOnSurfaceInfo')
stretchPlane[0].getShape().worldSpace[0] >> pointOnSurface.inputSurface
pointOnSurface.parameterU.set(spacing)
pointOnSurface.positionZ >> joints[i].sz
pointOnSurface.positionZ >> joints[i].sy
baseDistance = pm.createNode('distanceBetween', name="%s_base_distance" %prefix)
proxy_start.getShape().worldPosition[0] >> baseDistance.point1
proxy_end.getShape().worldPosition[0] >> baseDistance.point2
stretchDistance = pm.createNode('distanceBetween', name="%s_stretch_distance" %prefix)
stretchDistanceStart = pm.spaceLocator(name="%s_stretch_distance_start" %prefix)
stretchDistanceStart.localScale.set(0,0,0)
pm.parentConstraint(startCtrl, stretchDistanceStart, mo=False)
stretchDistanceEnd = pm.spaceLocator(name="%s_stretch_distance_end" %prefix)
stretchDistanceEnd.localScale.set(0,0,0)
pm.parentConstraint(endCtrl, stretchDistanceEnd, mo=False)
stretchDistanceStart.getShape().worldPosition[0] >> stretchDistance.point1
stretchDistanceEnd.getShape().worldPosition[0] >> stretchDistance.point2
strechFactor_md = pm.createNode('multiplyDivide', name='%s_stretch_distance_md' %prefix)
strechFactor_md.operation.set(2) #divide
baseDistance.distance >> stretchGrp.baseDistance
stretchGrp.baseDistance >> strechFactor_md.input2X
stretchDistance.distance >> strechFactor_md.input1X
strechFactor_remap = pm.createNode('remapValue', name="%s_stretch_factor_remap" %prefix)
strechFactor_md.outputX >> strechFactor_remap.inputValue
strechFactor_remap.inputMin.set(0.5)
strechFactor_remap.inputMax.set(1.5)
strechFactor_remap.outputMin.set(-1)
strechFactor_remap.outputMax.set(1)
strechFactor_remap.outValue >> squash.factor
pm.parent(stretchDistanceStart, stretchDistanceEnd, stretchPlane, squashHdl, stretchGrp)
stretchGrp.visibility.set(0)
#===========================================================================
for cube in proxyCubes:
stretchGrp.baseDistance >> cube.sx
stretchGrp.baseDistance >> cube.sy
stretchGrp.baseDistance >> cube.sz
stretchGrp.baseDistance >> ribbon.sz
#===========================================================================
#===========================================================================
# Positioning
#===========================================================================
if startObj and endObj:
pm.delete(pm.parentConstraint(startObj, proxy_start, mo=False))
pm.delete(pm.parentConstraint(endObj, proxy_end, mo=False))
pm.delete(pm.parentConstraint(startObj, proxy_up, mo=False))
proxy_up.ty.set(proxy_up.ty.get() + 1)
def doRig(self):
anchorList = []
cntrlList = []
locList = []
offCtrlLoc=[]
offAuxLoc = []
dummyCrv = self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv'
pm.hide(pm.polyCube(n=dummyCrv))
if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']):
pm.delete(self.ribbonDict['moveallSetup']['nameTempl'])
if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']):
pm.delete(self.ribbonDict['noMoveSetup']['nameTempl'])
###Estrutura que nao deve ter transformacao
noMoveSpace = pm.group(empty=True, n=self.ribbonDict['noMoveSetup']['nameTempl'])
if not pm.objExists('NOMOVE'):
pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE')
else:
pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE')
pm.parent(self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv', noMoveSpace)
noMoveSpace.visibility.set(0)
noMoveSpace.translate.set(self.size * -0.5, 0, 0)
noMoveBend1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
noMoveBend2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
noMoveCrvJnt = pm.curve(bezier=True, d=3,
p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0), (self.size * -0.496, 0, 0),
(self.size * -0.495, 0, 0), (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0),
(0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0),
(self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0), (self.size * 0.499, 0, 0),
(self.size * 0.50, 0, 0)],
k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10])
noMoveCrvTweak1 = pm.curve(d=2,
p=[(self.size * -0.5, 0, 0), (self.size * -0.25, 0, 0), (self.size * 0, 0, 0)],
k=[0, 0, 1, 1])
noMoveCrvTweak2 = pm.curve(d=2,
p=[(self.size * 0.0, 0, 0), (self.size * 0.25, 0, 0), (self.size * 0.50, 0, 0)],
k=[0, 0, 1, 1])
# Deformers das superficies noMove
twist1 = pm.nonLinear(noMoveBend1[0], type='twist') # twist das superficies noMove
twist2 = pm.nonLinear(noMoveBend2[0], type='twist')
twist1[1].rotateZ.set(90)
twist2[1].rotateZ.set(90)
wireTweak1 = pm.wire(noMoveBend1[0], w=noMoveCrvTweak1, dds=[(0, 50)])
wireTweak2 = pm.wire(noMoveBend2[0], w=noMoveCrvTweak2, dds=[(0, 50)])
wireDef = pm.wire(noMoveBend1[0], noMoveBend2[0], w=noMoveCrvJnt, dds=[(0, 50)]) # Wire das superficies noMove
wireDef[0].rotation.set(1) # seta wire controlando rotacao
baseWire = [x for x in wireDef[0].connections() if 'BaseWire' in x.name()]
baseWireTweak1 = [x for x in wireTweak1[0].connections() if 'BaseWire' in x.name()]
baseWireTweak2 = [x for x in wireTweak2[0].connections() if 'BaseWire' in x.name()]
pm.group(baseWire, baseWireTweak1, baseWireTweak2, noMoveCrvJnt, noMoveCrvTweak1, noMoveCrvTweak2,
noMoveBend1[0], noMoveBend2[0], p=noMoveSpace, n=self.name + 'Deforms')
pm.parent(twist1[1], twist2[1], noMoveSpace)
###Estrutura que pode ser movida
cntrlsSpace = pm.group(empty=True, n=self.ribbonDict['moveallSetup']['nameTempl'])
cntrlsSpace.translate.set(self.size * -0.5, 0, 0)
bendSurf1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
bendSurf2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
# blendShape transferindo as deformaacoes para a superficie move
blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0])
blend2 = pm.blendShape(noMoveBend2[0], bendSurf2[0])
pm.blendShape(blend1, e=True, w=[(0, 1)])
pm.blendShape(blend2, e=True, w=[(0, 1)])
pm.parent(bendSurf1[0], bendSurf2[0], cntrlsSpace)
##Cntrls
tweak1Cls = pm.cluster(noMoveCrvTweak1.name()+'.cv[1]')
tweak2Cls = pm.cluster(noMoveCrvTweak2.name() + '.cv[1]')
displaySetup = self.ribbonDict['ctrlTweakSetup'].copy()
cntrlName = displaySetup['nameTempl'] + '1'
cntrlTweak1 = controlTools.cntrlCrv(name=cntrlName, obj=tweak1Cls[1], connType='connection',
align='pivot', offsets=1, **displaySetup)
cntrlName = displaySetup['nameTempl'] + '2'
cntrlTweak2 = controlTools.cntrlCrv(name=cntrlName, obj=tweak2Cls[1], connType='connection',
align='pivot', offsets=1, **displaySetup)
controlTools.addMultiply([cntrlTweak1.getParent(), cntrlTweak2.getParent()])
tweakFoll1 = self.attachObj(obj=cntrlTweak1.getParent(3), mesh=bendSurf1[0], u=0.5, v=0.5, mode=4)
tweakFoll2 = self.attachObj(obj=cntrlTweak2.getParent(3), mesh=bendSurf2[0], u=0.5, v=0.5, mode=4)
tweakGrp = pm.group(tweak1Cls[1], tweak2Cls[1], n=self.name+'TweakCls_grp')
pm.parent(tweakGrp, noMoveSpace)
pm.parent(cntrlTweak1.getParent(3), cntrlTweak2.getParent(3), cntrlsSpace)
for i in range(0, 7):
anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) + ']')
pm.cluster(anchor[1], e=True, g=dummyCrv)
clsHandle = anchor[1]
anchorGrp = pm.group(em=True, n=self.name+'clusterGrp' + str(i))
anchorDrn = pm.group(em=True, n=self.name+'clusterDrn' + str(i), p=anchorGrp)
pos = pm.xform(anchor[1], q=True, ws=True, rp=True)
pm.xform(anchorGrp, t=pos, ws=True)
pm.parent(anchor[1], anchorDrn)
anchorList.append(anchor[1])
if i == 0 or i == 6:
displaySetup = self.ribbonDict['cntrlSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)
elif i == 3:
displaySetup = self.ribbonDict['midCntrlSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)
else:
displaySetup = self.ribbonDict['cntrlTangSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)
offCtrlLoc.append(pm.spaceLocator(n=cntrlName+'off_loc'))
offCtrlLoc[-1].localScale.set(0.2, 0.2, 0.2)
pm.parent(offCtrlLoc[-1], cntrl, r=True)
if i in [1, 2, 4, 5]:
offCtrlLoc[-1].getShape().visibility.set(False)
# Nao pode fazer conexao na criacao do controle, pois tera conexao direta
pm.xform(cntrl.getParent(), t=pos, ws=True)
# estrutura de buffers para conexao direta
auxLocGrp = pm.group(em=True, n=self.name + 'Aux_grp')
auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + str(i)+ 'Aux_loc')
pm.xform(auxLocGrp, t=pos, ws=True)
loc = pm.PyNode(auxLoc)
if i==0 or i==3 or i==6:
tmpOffAuxLoc = pm.group(em=True, n=self.name + str(i) + 'AuxOff_loc')
offAuxLoc.append(tmpOffAuxLoc)
pm.parent(tmpOffAuxLoc, auxLoc, r=True)
offCtrlLoc[-1].translate >> offAuxLoc[-1].translate
offCtrlLoc[-1].rotate >> offAuxLoc[-1].rotate
if i == 1 or i == 4:
pm.xform(anchorGrp, s=(-1, 1, 1), r=True)
pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True)
pm.xform(loc.getParent(), s=(-1, 1, 1), r=True)
# Conexoes dos buffers cm os clusters e com os controles
pm.parentConstraint(cntrl, loc, mo=True)
loc.translate >> anchorDrn.translate
loc.rotate >> anchorDrn.rotate
cntrlList.append(cntrl)
locList.append(loc)
# workaround do flip do inicio do wire(adicao de mais pontos)
startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]')
endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]')
pm.cluster(startCls[1], e=True, g=dummyCrv)
pm.cluster(endCls[1], e=True, g=dummyCrv)
pm.parent(startCls[1], anchorList[0])
pm.parent(endCls[1], anchorList[6])
cntrlsSpace.addAttr('midCtrlViz', at='double', dv=1, max=1, min=0, k=True, h=False)
cntrlsSpace.addAttr('bezierCtrlViz', at='double', dv=1,max=1, min=0, k=True, h=False)
cntrlsSpace.addAttr('bendExtraCtrlViz', at='double',max=1, min=0, dv=1, k=True, h=False)
cntrlsSpace.addAttr('extraCtrlsVis', at='double', dv=0,max=1, min=0, k=True, h=False)
cntrlList[0].addAttr('twist', at='double', dv=0, k=True)
cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True)
cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True)
cntrlList[3].addAttr('twist', at='double', dv=0, k=True)
cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True)
cntrlList[6].addAttr('twist', at='double', dv=0, k=True)
cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True)
cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True)
cntrlList[0].twist >> twist1[0].endAngle
cntrlList[3].twist >> twist1[0].startAngle
cntrlList[3].twist >> twist2[0].endAngle
cntrlList[6].twist >> twist2[0].startAngle
# cria sistema do tweak pra compensar twist da ribbon
tweak1Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
tweak1Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
tweak1Add = pm.createNode('addDoubleLinear', name='tweak1Add')
tweak2Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
tweak2Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
tweak2Add = pm.createNode('addDoubleLinear', name='tweak1Add')
cntrlList[0].twist >> tweak1Twist1Multi.input1
tweak1Twist1Multi.input2.set(-0.5)
cntrlList[3].twist >> tweak1Twist2Multi.input1
tweak1Twist2Multi.input2.set (-0.5)
tweak1Twist1Multi.output >> tweak1Add.input1
tweak1Twist2Multi.output >> tweak1Add.input2
tweak1Add.output >> cntrlTweak1.getParent(2).rotate.rotateX
cntrlList[6].twist >> tweak2Twist1Multi.input1
tweak2Twist1Multi.input2.set(-0.5)
cntrlList[3].twist >> tweak2Twist2Multi.input1
tweak2Twist2Multi.input2.set(-0.5)
tweak2Twist1Multi.output >> tweak2Add.input1
tweak2Twist2Multi.output >> tweak2Add.input2
tweak2Add.output >> cntrlTweak2.getParent(2).rotate.rotateX
# hierarquia
pm.parent(anchorList[1].getParent(2), anchorList[0])
pm.parent(anchorList[5].getParent(2), anchorList[6])
pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2), anchorList[3])
pm.parent(cntrlList[1].getParent(), offCtrlLoc[0])
pm.parent(cntrlList[5].getParent(), offCtrlLoc[6])
pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(), offCtrlLoc[3])
pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(), cntrlList[6].getParent(), cntrlsSpace)
pm.parent(locList[1].getParent(), offAuxLoc[0])
pm.parent(locList[5].getParent(), offAuxLoc[2])
pm.parent(locList[2].getParent(), locList[4].getParent(), offAuxLoc[1])
pm.parent(locList[3].getParent(), locList[0].getParent(), locList[6].getParent(), cntrlsSpace)
pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2), anchorList[6].getParent(2), noMoveSpace)
for i, j in zip([1, 2, 4, 5], [0, 3, 3, 6]):
crv = pm.curve(d=1, p=[(1, 0, 0), (-1, 0, 0)], k=[0, 1])
crv.inheritsTransform.set(False)
crv.template.set(True)
offCtrlLoc[i].worldPosition[0] >> crv.getShape().controlPoints[0]
offCtrlLoc[j].worldPosition[0] >> crv.getShape().controlPoints[1]
pm.parent(crv, offCtrlLoc[i], r=True)
# Skin joints do ribbon
skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts')
follGrp = pm.group(em=True, n=self.name + 'Foll_grp')
pm.parent(tweakFoll1, tweakFoll2, follGrp)
# cria ramps para controlar o perfil de squash e stretch
ramp1 = pm.createNode('ramp', n=self.name+'SquashRamp1')
ramp1.attr('type').set(1)
ramp2 = pm.createNode('ramp', n=self.name+'SquashRamp2')
ramp2.attr('type').set(1)
expre1 = "float $dummy = " + ramp1.name() + ".outAlpha;float $output[];float $color[];"
expre2 = "float $dummy = " + ramp2.name() + ".outAlpha;float $output[];float $color[];"
extraCntrlsGrp = pm.group(em=True, r=True, p=cntrlsSpace, n=self.name + 'ExtraCntrls')
# loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon.
# cria tmb node tree pro squash/stretch
# e controles extras
vIncrement = float((1.0 - (self.offsetStart + self.offsetEnd)) / ((self.numJnts - 2) / 2.0))
for i in range(1, (self.numJnts / 2) + 1):
# cria estrutura pra superficie 1
pm.select(cl=True)
jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'A' + str(i) + self.jntSulfix
jnt1 = pm.joint(p=(0, 0, 0), n=jntName)
self.skinJoints.append(jnt1)
displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
cntrlName = displaySetup['nameTempl'] + 'A' + str(i)
cntrl1 = controlTools.cntrlCrv(name=cntrlName, obj=jnt1, connType='constraint', **displaySetup)
# node tree
blend1A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1A')
blend1B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1B')
gammaCorr1 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma1')
cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX
cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX
blend1A.input[0].set(1)
gammaCorr1.outValueX >> blend1A.input[1]
blend1B.input[0].set(1)
blend1A.output >> blend1B.input[1]
cntrlList[3].attr ('autoVolume') >> blend1B.attributesBlender
blend1B.output >> cntrl1.getParent().scaleY
blend1B.output >> cntrl1.getParent().scaleZ
# expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch
expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str(
self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name() + " `;$output[" + str(
i) + "] = $color[0];" + blend1A.name() + ".attributesBlender=$output[" + str(i) + "];"
# cria estrutura pra superficie 2
pm.select(cl=True)
jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'B' + str(i) + self.jntSulfix
jnt2 = pm.joint(p=(0, 0, 0), n=jntName)
self.skinJoints.append(jnt2)
displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
cntrlName = displaySetup['nameTempl'] + 'B' + str(i)
cntrl2 = controlTools.cntrlCrv(name=cntrlName, connType='constraint', obj=jnt2, **displaySetup)
# node tree
blend2A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2A')
blend2B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2B')
gammaCorr2 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma2')
cntrlList[6].attr('autoVolumStregth') >> gammaCorr2.gammaX
cntrlList[6].attr('stretchDist') >> gammaCorr2.value.valueX
blend2A.input[0].set(1)
gammaCorr2.outValueX >> blend2A.input[1]
blend2B.input[0].set(1)
blend2A.output >> blend2B.input[1]
cntrlList[3].attr('autoVolume') >> blend2B.attributesBlender
blend2B.output >> cntrl2.getParent().scaleY
blend2B.output >> cntrl2.getParent().scaleZ
# expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch
expre2 = expre2 + "$color = `colorAtPoint -o RGB -u " + str(
self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp2.name() + " `;$output[" + str(
i) + "] = $color[0];" + blend2A.name() + ".attributesBlender=$output[" + str(i) + "];"
# prende joints nas supeficies com follicules
foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4)
foll2 = self.attachObj(cntrl2.getParent(), bendSurf2[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4)
pm.parent(cntrl1.getParent(), cntrl2.getParent(), extraCntrlsGrp)
pm.parent(jnt1, jnt2, skinJntsGrp)
pm.parent(foll1, foll2, follGrp)
pm.select (cl=True)
jntName = self.ribbonDict['jntSetup']['nameTempl'] +'Elbow' + self.jntSulfix
elbowJnt = pm.joint(p=(0, 0, 0), n=jntName)
pm.parent(elbowJnt, skinJntsGrp)
elbowAuxFoll1 = self.createFoll(bendSurf1[0], 0.999, 0.5)
elbowAuxFoll2 = self.createFoll(bendSurf2[0], 0.001, 0.5)
pm.parent(elbowAuxFoll1, elbowAuxFoll2, follGrp)
orientConstraint = pm.PyNode(pm.orientConstraint(elbowAuxFoll1, elbowAuxFoll2, elbowJnt, mo=False))
orientConstraint.interpType.set(2)
pm.pointConstraint(cntrlList[3], elbowJnt, mo=False)
# seta expressoes para so serem avaliadas por demanda
pm.expression(s=expre1, ae=False, n=self.name+'Expression1')
pm.expression(s=expre2, ae=False, n=self.name+'Expression2')
pm.parent(skinJntsGrp, cntrlsSpace)
pm.parent(follGrp, noMoveSpace)
# hideCntrls
pm.toggle(bendSurf1[0], bendSurf2[0], g=True)
bendSurf1[0].visibility.set(0)
bendSurf2[0].visibility.set (0)
# skinJntsGrp.visibility.set(0)
cntrlsSpace.extraCtrlsVis >> extraCntrlsGrp.visibility
cntrlsSpace.bezierCtrlViz >> cntrlList[0].getParent().visibility
cntrlsSpace.midCtrlViz >> cntrlList[3].getParent().visibility
cntrlsSpace.bezierCtrlViz >> cntrlList[4].getParent().visibility
cntrlsSpace.bezierCtrlViz >> cntrlList[2].getParent().visibility
cntrlsSpace.bezierCtrlViz >> cntrlList[6].getParent().visibility
cntrlsSpace.bendExtraCtrlViz >> cntrlTweak1.getParent().visibility
cntrlsSpace.bendExtraCtrlViz >> cntrlTweak2.getParent().visibility
# povoa ribbon Dict
self.ribbonDict['name'] = 'bezierRibbon'
self.ribbonDict['ribbonMoveAll'] = cntrlsSpace
for i in range(0, 7):
self.ribbonDict['cntrl' + str(i)] = cntrlList[i]
def paperbloc_gen(sel=None,
w=21.0,
d=29.7,
h=2,
num_sheets=10,
max_xz=0.5,
max_rot=10.0,
name='paperbloc'):
sel = paperbloc_base(w, d, h, name)
if not sel:
# Get Current selection
sel = pmc.ls(sl=True)
elif not isinstance(sel, list):
sel = [sel]
if len(sel) != 2:
raise ValueError(
'Select Two Objects please, the fill paper and the paper bloc.')
sSel = sel
bloc_paper = sel[-1]
sel = sel[0]
print(bloc_paper)
# check if the name already is in the scene
i = 0
num = 1
while i < num:
chk = pmc.ls(name + '_' + str(i))
if chk:
num += 1
i += 1
if i == num:
num -= 1
name_grp = name + '_grp_' + str(num)
name_fill = name + '_fill_' + str(num)
name = name + '_' + str(num)
bloc_paper = pmc.duplicate(bloc_paper, n=name)
fill_sheets = [bloc_paper[0]]
#raise ValueError('STOP DOGGIE')
for i in range(num_sheets):
r_seed_x = random() * max_xz
r_seed_y = random() * h
r_seed_z = random() * max_xz
r_seed_rot = random() * max_rot
coin = coin_toss()
if coin == 1:
r_seed_rot = -r_seed_rot
coin = coin_toss()
if coin_toss == 1:
r_seed_z = -r_seed_z
coin = coin_toss()
if coin_toss == 1:
r_seed_x = -r_seed_x
base_y = pmc.getAttr(sel.translateY)
y_val = r_seed_y + base_y
n_paper = pmc.duplicate(sel, n=name_fill)
n_paper = n_paper[0]
coin = coin_toss()
if coin == 1:
r_pivotx = random() * 10.0
r_pivotz = random() * 10.0
coin = coin_toss()
if coin == 1:
r_pivotx = -r_pivotx
coin = coin_toss()
if coin == 1:
r_pivotz = -r_pivotz
pmc.move(n_paper.rotatePivot, r_pivotx, 0, r_pivotz)
pmc.setAttr(n_paper.ty, y_val)
pmc.setAttr(n_paper.tx, r_seed_x)
pmc.setAttr(n_paper.tz, r_seed_z)
pmc.setAttr(n_paper.ry, r_seed_rot)
fill_sheets.append(n_paper)
print('---------feuilles placees -----------')
print(fill_sheets)
bender = pmc.nonLinear(fill_sheets, type='bend')
print('bend creation')
pmc.rename(bender[0], name + '__bend')
pmc.rename(bender[-1], name + '__bendHandle')
print('---------bend done -----------')
pmc.setAttr(bender[-1].rotateZ, 90)
fill_sheets.append(bender[0])
fill_sheets.append(bender[-1])
grp = pmc.group(em=True, n=name_grp)
pmc.setAttr(grp.ty, base_y)
pmc.parent(fill_sheets, grp)
ar.zero_out(mc.ls(str(bender[-1])))
pmc.addAttr(grp, ln='bend_me', at='float', k=True)
pmc.addAttr(grp, ln='bend_shift', at='float', k=True)
pmc.addAttr(grp, ln='bend_min', at='float', min=-10, dv=-1, max=0, k=True)
pmc.addAttr(grp, ln='bend_max', at='float', min=0, dv=1, max=10, k=True)
pmc.addAttr(grp, ln='pos_bendx', at='float', k=True)
pmc.addAttr(grp, ln='pos_bendz', at='float', k=True)
pmc.connectAttr(grp.bend_me, bender[0].curvature)
pmc.connectAttr(grp.bend_shift, bender[-1].rx)
pmc.connectAttr(grp.bend_min, bender[0].lowBound)
pmc.connectAttr(grp.bend_max, bender[0].highBound)
pmc.connectAttr(grp.pos_bendx, bender[-1].ty)
pmc.connectAttr(grp.pos_bendz, bender[-1].tz)
pmc.delete(sSel)
pmc.select(pmc.ls(grp))
return grp
def create_surface(self, name='Surface', epsilon=0.001, default_scale=1.0):
"""
Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide
a surface for the influence to slide on.
:param name: The suffix of the surface name to create.
:return: A pymel.nodetypes.Transform instance of the created surface.
"""
nomenclature = self.get_nomenclature_rig().copy()
nomenclature.add_tokens(name)
root = pymel.createNode('transform')
pymel.addAttr(root, longName='bendUpp', k=True)
pymel.addAttr(root, longName='bendLow', k=True)
pymel.addAttr(root, longName='bendSide', k=True)
# Create Guide
plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4)
# Create Bends
bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform, type='bend')
bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform, type='bend')
bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform, type='bend')
plane_transform.r.set(0, -90, 0)
bend_side_handle.r.set(90, 90, 0)
bend_upp_handle.r.set(180, 90, 0)
bend_low_handle.r.set(180, 90, 0)
bend_upp_deformer.highBound.set(0) # create pymel warning
bend_low_deformer.lowBound.set(0) # create pymel warning
plane_transform.setParent(root)
bend_side_handle.setParent(root)
bend_upp_handle.setParent(root)
bend_low_handle.setParent(root)
pymel.connectAttr(root.bendSide, bend_side_deformer.curvature)
pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature)
pymel.connectAttr(root.bendLow, bend_low_deformer.curvature)
# Rename all the things!
root.rename(nomenclature.resolve('SurfaceGrp'))
plane_transform.rename(nomenclature.resolve('Surface'))
bend_upp_deformer.rename(nomenclature.resolve('UppBend'))
bend_low_deformer.rename(nomenclature.resolve('LowBend'))
bend_side_deformer.rename(nomenclature.resolve('SideBend'))
bend_upp_handle.rename(nomenclature.resolve('UppBendHandle'))
bend_low_handle.rename(nomenclature.resolve('LowBendHandle'))
bend_side_handle.rename(nomenclature.resolve('SideBendHandle'))
# Try to guess the desired position
min_x = None
max_x = None
pos = pymel.datatypes.Vector()
for jnt in self.jnts:
pos += jnt.getTranslation(space='world')
if min_x is None or pos.x < min_x:
min_x = pos.x
if max_x is None or pos.x > max_x:
max_x = pos.x
pos /= len(self.jnts)
root.setTranslation(pos)
# Try to guess the scale
length_x = max_x - min_x
if len(self.jnts) <= 1 or length_x < epsilon:
log.debug("Cannot automatically resolve scale for surface. Using default value {0}".format(default_scale))
length_x = default_scale
root.scaleX.set(length_x)
root.scaleY.set(length_x * 0.5)
root.scaleZ.set(length_x)
pymel.select(root)
# self.input.append(plane_transform)
return plane_transform
def create_surface(self, name='Surface'):
"""
Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide
a surface for the influence to slide on.
:param name: The suffix of the surface name to create.
:return: A pymel.nodetypes.Transform instance of the created surface.
"""
nomenclature = self.get_nomenclature_rig().copy()
nomenclature.add_tokens(name)
root = pymel.createNode('transform')
pymel.addAttr(root, longName='bendUpp', k=True)
pymel.addAttr(root, longName='bendLow', k=True)
pymel.addAttr(root, longName='bendSide', k=True)
# Create Guide
plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4)
# Create Bends
bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform,
type='bend')
bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform,
type='bend')
bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform,
type='bend')
plane_transform.r.set(0, -90, 0)
bend_side_handle.r.set(90, 90, 0)
bend_upp_handle.r.set(180, 90, 0)
bend_low_handle.r.set(180, 90, 0)
bend_upp_deformer.highBound.set(0) # create pymel warning
bend_low_deformer.lowBound.set(0) # create pymel warning
plane_transform.setParent(root)
bend_side_handle.setParent(root)
bend_upp_handle.setParent(root)
bend_low_handle.setParent(root)
pymel.connectAttr(root.bendSide, bend_side_deformer.curvature)
pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature)
pymel.connectAttr(root.bendLow, bend_low_deformer.curvature)
# Rename all the things!
root.rename(nomenclature.resolve('SurfaceGrp'))
plane_transform.rename(nomenclature.resolve('Surface'))
bend_upp_deformer.rename(nomenclature.resolve('UppBend'))
bend_low_deformer.rename(nomenclature.resolve('LowBend'))
bend_side_deformer.rename(nomenclature.resolve('SideBend'))
bend_upp_handle.rename(nomenclature.resolve('UppBendHandle'))
bend_low_handle.rename(nomenclature.resolve('LowBendHandle'))
bend_side_handle.rename(nomenclature.resolve('SideBendHandle'))
# Try to guess the desired position
min_x = None
max_x = None
pos = pymel.datatypes.Vector()
for jnt in self.jnts:
pos += jnt.getTranslation(space='world')
if min_x is None or pos.x < min_x:
min_x = pos.x
if max_x is None or pos.x > max_x:
max_x = pos.x
pos /= len(self.jnts)
length_x = max_x - min_x
root.setTranslation(pos)
root.scaleX.set(length_x)
root.scaleY.set(length_x * 0.5)
root.scaleZ.set(length_x)
pymel.select(root)
#self.input.append(plane_transform)
return plane_transform
import pymel.core as pm
#select all verts of number
import pymel.core as pm
vtxs=[]
for obj in pm.ls(sl=True):
vtxs.append( obj.vtx[492] )
pm.select( vtxs, r=True )
#aim some bend deformers based on two points
for obj in pm.ls(sl=True):
pm.select(obj, r=True)
bend = pm.nonLinear( type= 'bend', curvature=0 )
pc = pm.pointConstraint( obj.name().replace('_GEO','_pc'), bend[1], mo=False )
ac = pm.aimConstraint( obj.name().replace('_GEO','_ac'), bend[1], aimVector=[0,1,0], upVector=[-1,0,0], worldUpType='scene', mo=False )
bend[0].lowBound.set(0)
bend[0].highBound.set(2.65)
bend[0].rename( obj.name().replace('_GEO','_BEND') )
bend[1].rename( obj.name().replace('_GEO','_BENDHandle') )
pm.delete( pc, ac )
#add nonlinear deformers from source to target
sel = pm.ls(sl=True)
src = sel[0]
tgts = sel[1:]
deformers = list(set(src.getShape().listHistory(type='nonLinear')))
def doRig(self):
anchorList = []
cntrlList = []
locList = []
dummyCrv = self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv'
pm.hide(pm.polyCube(n=dummyCrv))
if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']):
pm.delete(self.ribbonDict['noMoveSetup']['nameTempl'])
if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']):
pm.delete(self.ribbonDict['moveallSetup']['nameTempl'])
logger
###Estrutura que nao deve ter transformacao
noMoveSpace = pm.group(empty=True,
n=self.ribbonDict['noMoveSetup']['nameTempl'])
if not pm.objExists('NOMOVE'):
pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE')
else:
pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE')
pm.parent(self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv',
noMoveSpace)
noMoveSpace.visibility.set(0)
noMoveBend1 = pm.nurbsPlane(p=(self.size * 0.5, 0, 0),
ax=(0, 0, 1),
w=self.size,
lr=0.1,
d=3,
u=5,
v=1)
# noMoveCrvJnt = pm.curve ( bezier=True, d=3, p=[(self.size*-0.5,0,0),(self.size*-0.4,0,0),(self.size*-0.1,0,0),(0,0,0),(self.size*0.1,0,0),(self.size*0.4,0,0),(self.size*0.5,0,0)], k=[0,0,0,1,1,1,2,2,2])
noMoveCrvJnt = pm.curve(
bezier=True,
d=3,
p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0),
(self.size * -0.496, 0, 0), (self.size * -0.495, 0, 0),
(self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0),
(0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0),
(self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0),
(self.size * 0.499, 0, 0), (self.size * 0.50, 0, 0)],
k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10])
noMoveCrvJnt.translate.set(self.size * 0.5, 0, 0)
# Deformers das superficies noMove
twist1 = pm.nonLinear(noMoveBend1[0],
type='twist') # twist das superficies noMove
twist1[1].rotateZ.set(90)
# IMPLEMENTAR O TWIST DO MEIO
twist2 = pm.nonLinear(noMoveBend1[0].name() + '.cv[0:3][0:3]',
type='twist') # twist das superficies noMove
twist2[1].rotateZ.set(90)
twist3 = pm.nonLinear(noMoveBend1[0].name() + '.cv[4:7][0:3]',
type='twist') # twist das superficies noMove
twist3[1].rotateZ.set(90)
wireDef = pm.wire(noMoveBend1[0], w=noMoveCrvJnt,
dds=[(0, 50)]) # Wire das superficies noMove
wireDef[0].rotation.set(1) # seta rotacao pra acontecer
baseWire = [
x for x in wireDef[0].connections() if 'BaseWire' in x.name()
]
pm.group(baseWire,
noMoveCrvJnt,
noMoveBend1[0],
p=noMoveSpace,
n=self.name + 'Deforms_grp')
pm.parent(twist1[1], twist2[1], twist3[1], noMoveSpace)
###Estrutura que pode ser movida
cntrlsSpace = pm.group(empty=True,
n=self.ribbonDict['moveallSetup']['nameTempl'])
bendSurf1 = pm.nurbsPlane(p=(self.size * -0.5, 0, 0),
ax=(0, 0, 1),
w=self.size * 0.5,
lr=.1,
d=3,
u=5,
v=1)
blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0])
pm.blendShape(blend1, e=True, w=[(0, 1)])
pm.parent(bendSurf1[0], cntrlsSpace)
##Cntrls
for i in range(0, 7):
anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) +
']')
pm.cluster(anchor[1], e=True, g=dummyCrv)
clsHandle = anchor[1]
anchorGrp = pm.group(em=True, n='clusterGrp' + str(i))
anchorDrn = pm.group(em=True, n='clusterDrn' + str(i), p=anchorGrp)
pos = pm.xform(anchor, q=True, ws=True, rp=True)
pm.xform(anchorGrp, t=pos, ws=True)
pm.parent(anchor[1], anchorDrn)
anchorList.append(anchor[1])
if i == 0 or i == 6:
displaySetup = self.ribbonDict['cntrlSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName,
obj=anchor[1],
**displaySetup)
elif i == 3:
displaySetup = self.ribbonDict['midCntrlSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName,
obj=anchor[1],
**displaySetup)
else:
displaySetup = self.ribbonDict['cntrlTangSetup'].copy()
cntrlName = displaySetup['nameTempl'] + str(i)
cntrl = controlTools.cntrlCrv(name=cntrlName,
obj=anchor[1],
**displaySetup)
# Nao pode fazer conexao na criacao do controle, pois tera conexao direta
pm.xform(cntrl.getParent(), t=pos, ws=True)
# estrutura de buffers para conexao direta
auxLocGrp = pm.group(em=True, n=self.name + 'auxLoc_grp')
auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + 'aux_loc')
pm.xform(auxLocGrp, t=pos, ws=True)
loc = pm.PyNode(auxLoc)
if i == 1 or i == 4:
pm.xform(anchorGrp, s=(-1, 1, 1), r=True)
pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True)
pm.xform(loc.getParent(), s=(-1, 1, 1), r=True)
# Conexoes dos buffers cm os clusters e com os controles
pm.parentConstraint(cntrl, loc)
loc.translate >> anchorDrn.translate
loc.rotate >> anchorDrn.rotate
cntrlList.append(cntrl)
locList.append(loc)
startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]')
endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]')
pm.cluster(startCls[1], e=True, g=dummyCrv)
pm.cluster(endCls[1], e=True, g=dummyCrv)
pm.parent(startCls, anchorList[0])
pm.parent(endCls, anchorList[6])
cntrlsSpace.addAttr('cntrlsVis', at='double', dv=1, k=True, h=False)
cntrlsSpace.addAttr('extraCntrlsVis',
at='double',
dv=0,
k=True,
h=False)
cntrlList[0].addAttr('twist', at='double', dv=0, k=True)
cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True)
cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True)
cntrlList[3].addAttr('twist', at='double', dv=0, k=True)
cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True)
cntrlList[6].addAttr('twist', at='double', dv=0, k=True)
cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True)
cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True)
cntrlList[0].twist >> twist1[0].endAngle
cntrlList[3].twist >> twist2[0].startAngle
cntrlList[3].twist >> twist3[0].endAngle
cntrlList[6].twist >> twist1[0].startAngle
# hierarquia
pm.parent(anchorList[1].getParent(2), anchorList[0])
pm.parent(anchorList[5].getParent(2), anchorList[6])
pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2),
anchorList[3])
pm.parent(cntrlList[1].getParent(), cntrlList[0])
pm.parent(cntrlList[5].getParent(), cntrlList[6])
pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(),
cntrlList[3])
pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(),
cntrlList[6].getParent(), cntrlsSpace)
pm.parent(locList[1].getParent(), locList[0])
pm.parent(locList[5].getParent(), locList[6])
pm.parent(locList[2].getParent(), locList[4].getParent(), locList[3])
pm.parent(locList[3].getParent(), locList[0].getParent(),
locList[6].getParent(), cntrlsSpace)
pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2),
anchorList[6].getParent(2), noMoveSpace)
# Skin joints do ribbon
skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts_grp')
follGrp = pm.group(em=True, n=self.name + 'Foll_grp')
# cria ramps para controlar o perfil de squash e stretch
ramp1 = pm.createNode('ramp', n=self.name + 'SquashRamp1')
ramp1.attr('type').set(1)
# ramp2 = pm.createNode ('ramp')
# ramp2.attr('type').set(1)
expre1 = "float $dummy = " + ramp1.name(
) + ".outAlpha;float $output[];float $color[];"
# expre2 = "float $dummy = "+ramp2.name()+".outAlpha;float $output[];float $color[];"
extraCntrlsGrp = pm.group(em=True,
r=True,
p=cntrlsSpace,
n=self.name + 'extraCntrls_grp')
# loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon.
# cria tmb node tree pro squash/stretch
# e controles extras
vIncrement = float(
(1.0 - (self.offsetStart + self.offsetEnd)) / (self.numJnts - 1))
for i in range(1, self.numJnts + 1):
# cria estrutura pra superficie 1
pm.select(cl=True)
jntName = self.ribbonDict['jntSetup']['nameTempl'] + str(
i) + self.jntSulfix
jnt1 = pm.joint(p=(0, 0, 0), n=jntName)
self.skinJoints.append(jnt1)
displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
cntrlName = displaySetup['nameTempl'] + 'A' + str(i)
cntrl1 = controlTools.cntrlCrv(name=cntrlName,
obj=jnt1,
connType='parentConstraint',
**displaySetup)
# node tree
blend1A = pm.createNode('blendTwoAttr',
n=self.name + 'VolumeBlend1A')
blend1B = pm.createNode('blendTwoAttr',
n=self.name + 'VolumeBlend1B')
gammaCorr1 = pm.createNode('gammaCorrect',
n=self.name + 'VolumeGamma1')
cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX
cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX
blend1A.input[0].set(1)
gammaCorr1.outValueX >> blend1A.input[1]
blend1B.input[0].set(1)
blend1A.output >> blend1B.input[1]
cntrlList[3].attr('autoVolume') >> blend1B.attributesBlender
blend1B.output >> cntrl1.getParent().scaleY
blend1B.output >> cntrl1.getParent().scaleZ
# expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch
expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str(
self.offsetStart +
(i - 1) * vIncrement) + " -v 0.5 " + ramp1.name(
) + " `;$output[" + str(i) + "] = $color[0];" + blend1A.name(
) + ".attributesBlender=$output[" + str(i) + "];"
# prende joints nas supeficies com follicules
foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0],
self.offsetStart + (i - 1) * vIncrement,
0.5, 4)
pm.parent(cntrl1.getParent(), extraCntrlsGrp)
pm.parent(jnt1, skinJntsGrp)
pm.parent(foll1, follGrp)
# seta expressoes para so serem avaliadas por demanda
pm.expression(s=expre1, ae=False)
pm.parent(skinJntsGrp, cntrlsSpace)
pm.parent(follGrp, noMoveSpace)
# hideCntrls
pm.toggle(bendSurf1[0], g=True)
bendSurf1[0].visibility.set(0)
# skinJntsGrp.visibility.set(0)
cntrlsSpace.extraCntrlsVis >> extraCntrlsGrp.visibility
cntrlsSpace.cntrlsVis >> cntrlList[0].getParent().visibility
cntrlsSpace.cntrlsVis >> cntrlList[3].getParent().visibility
cntrlsSpace.cntrlsVis >> cntrlList[6].getParent().visibility
# povoa ribbon Dict
self.ribbonDict['name'] = 'bezierRibbon'
self.ribbonDict['ribbonMoveAll'] = cntrlsSpace
for i in range(0, 7):
self.ribbonDict['cntrl' + str(i)] = cntrlList[i]
self.startCntrl = cntrlList[0]
self.midCntrl = cntrlList[3]
self.endCntrl = cntrlList[6]
self.moveall = cntrlsSpace
def create(cls, geometry, type="bend", influences=None):
nonlinear = pm.nonLinear(geometry, type=type)[0]
return NonLinear(nonlinear)
