def getGroup(modeName, main=None, checkOnly=False):
''' Returns the group that contains the space's proxy target, i.e. the node the zero space is actually constrained to.
Args:
modeName: str = One of the target modes, ex: 'PARENT', 'POINT_ORIENT', etc.
main: PyNode = The main controller in case the scene has multiple.
checkOnly: bool = If True, won't build the space and returns None if not found.
'''
modeName = toCamel(modeName)
if not main:
main = find.mainGroup()
for child in main.listRelatives():
if pdil.simpleName(child) == '__spaces__':
spaceContainer = child
break
else:
spaceContainer = group(em=True, n='__spaces__', p=main)
hide(spaceContainer)
for child in spaceContainer.listRelatives():
if pdil.simpleName(child) == modeName:
spaceGroup = child
break
else:
if checkOnly:
return None
else:
spaceGroup = group(em=True, name=modeName, p=spaceContainer)
return spaceGroup
def exportCameras(self, cacheFolder, log):
perspCameras = pm.listCameras(o=0, p=1)
userCameras = []
for cam in perspCameras:
if 'persp' not in cam:
userCameras.append(cam)
self.userCameras = userCameras
for cam in userCameras:
startTime = pm.playbackOptions(query=True, minTime=True)
endTime = pm.playbackOptions(query=True, maxTime=True)
pm.select(cam)
fileName = cam + '.abc'
fileName = os.path.join(cacheFolder, fileName).replace('\\', '/')
jobstring = "AbcExport "
jobstring += "-j \" -fr %d %d -worldSpace" % (startTime, endTime)
jobstring += ' -root ' + cam
jobstring += ' -file ' + fileName
jobstring += '\"'
print jobstring
try:
pm.hide(all=True)
pm.select(cam)
pm.showHidden(above=True)
pm.mel.eval(jobstring)
except:
pm.warning('Could not export %s cam' % cam)
def assert_cache(namespace, path):
cache_group = assert_group_chain('animated', '{}_group'.format(namespace), 'cache')
pm.hide(cache_group)
if not pm.hasAttr(cache_group, 'mmCachePath'):
cache_group.addAttr('mmCachePath', dataType='string')
nodes = pm.listRelatives(cache_group, children=True)
if nodes:
existing_path = cache_group.attr('mmCachePath').get()
if not existing_path:
raise ValueError("Cache group {} has children, but no mmCachePath set.".format(cache_group))
if existing_path == path:
print(' NOTE: Already up to date.')
return nodes, True
print(' WARNING: Out of date; deleting.')
pm.delete(nodes)
nodes = None
if not nodes:
before = set(pm.ls(assemblies=True))
pm.AbcImport(path, ft='{}:[^:]*$'.format(namespace))
nodes = list(set(pm.ls(assemblies=True)) - before)
for node in nodes:
pm.parent(node, cache_group)
cache_group.attr('mmCachePath').set(path)
return nodes, False
def infoStore(storeName, storeValue=False):
storeName = str(storeName)
#Create info store if it doesn't exist
try:
py.ls('infoStore')[0]
except:
originalSelection = py.ls(selection=True)
py.spaceLocator(n='infoStore')
py.addAttr('infoStore',
shortName='progress',
longName='ProgressBarName',
dataType='string')
py.select(originalSelection)
py.hide('infoStore')
#Get value from info store or create new attribute
try:
storedValue = ast.literal_eval(py.getAttr('infoStore.' + storeName))
except:
py.addAttr('infoStore', longName=storeName, dataType='string')
py.setAttr('infoStore.' + storeName, '{}')
storedValue = ast.literal_eval(py.getAttr('infoStore.' + storeName))
#Write values to info store
if storeValue != False:
py.setAttr('infoStore.' + storeName, str(storeValue))
return storedValue
def rig_curveBetweenTwoPoints(start,end, name='curveBetween' , degree=1, colour='white', parent='allModel_GRP'):
startPos = pm.xform( start, translation=True, query=True, ws=True)
endPos = pm.xform( end, translation=True, query=True, ws=True)
pm.select(cl=True)
startJnt = pm.joint(name=name+'Start_JNT')
pm.pointConstraint( start, startJnt )
pm.select(cl=True)
endJnt = pm.joint(name=name+'End_JNT')
pm.pointConstraint( end, endJnt )
curve = pm.curve( n=name+'_CRV', d=degree, p=(startPos, endPos), k=(0,1) )
sc = pm.skinCluster( (startJnt, endJnt),curve , tsb=True, dr=1)
pm.skinPercent( sc, curve.cv[0],tv=(startJnt, 1) )
pm.skinPercent( sc, curve.cv[1],tv=(endJnt, 1) )
col = name_to_rgb(colour)
curve.overrideColorRGB.set(col[0], col[1], col[2])
topGrp = 'puppetLinearCurves_GRP'
if not pm.objExists(topGrp):
topGrp = rig_transform(0, name='puppetLinearCurves', type='group',
parent=parent).object
pm.parent(curve,startJnt,endJnt, topGrp)
pm.setAttr(curve+".inheritsTransform", 0)
pm.setAttr(curve+".template", 1)
pm.hide( startJnt, endJnt )
return curve
def start(cls):
temp = core.findNode.controllers()
ctrls = temp[:-2] # Cut out the main controller and root motion
# Artificially add the parents of the selected controls so they are hidden as a result
selectedControls = set(selected())
for ctrl in selected():
if type(ctrl) in (fossilNodes.SubController,
fossilNodes.RigController):
selectedControls.update(ctrl.getAllParents())
# Hide the spaces since the controls vis is locked and hidden to prevent accidentally being keyed hidden.
cls.controlsToHide = set(ctrls).difference(selectedControls)
for obj in cls.controlsToHide:
hide(obj.getParent(), obj.getParent().getParent())
main = temp[-2]
cls.hideMain = main not in selectedControls
if cls.hideMain:
cls.mainShapes = core.shape.getShapes(main)
hide(cls.mainShapes)
print 'hide main', cls.mainShapes[0].isVisible()
if cls.mainShapes[0].isVisible():
plug = cls.mainShapes[0].visibility.listConnections(s=True,
p=True)
if plug:
plug[0].set(0)
def import_file():
base_path = get_file_path('ecAutoFaceImport.mb')
if mc.objExists('Blend_Morph') is False:
mc.file(base_path, i=True)
py.hide('baseoffset', 'PhonemeController')
else:
pass
def addControlsToCurve(name,
crv=None,
spec={
'shape': 'sphere',
'size': 10,
'color': 'blue 0.22'
}): # noqa e128
'''
Given a curve, make a control sphere at each CV.
:return: List of newly made controls.
'''
if not crv:
crv = selected()[0]
controls = []
for i, cv in enumerate(crv.cv):
#l = control.sphere( '{0}{1:0>2}'.format( name, i+1), size, 'blue', type=control.SPLINE )
shape = controllerShape.build('{0}{1:0>2}'.format(name, i + 1),
spec,
type=controllerShape.ControlType.SPLINE)
core.dagObj.moveTo(shape, cv)
handle = cluster(cv)[1]
handle.setParent(shape)
hide(handle)
controls.append(shape)
return controls
def ctrl_paintEffect(cv_list):
cv_list = pm.ls(cv_list)
pm.select(cv_list)
mel.eval('AttachBrushToCurves;')
stroke_list = []
for cv in cv_list:
cv_shape_list = cv.getShapes()
for cv_shape in cv_shape_list:
stroke = pm.listConnections(cv_shape.worldSpace)[-1]
stroke_list.append(stroke)
pm.rename(stroke, str(cv.name()) + '_stroke')
ctrl_geo_list = []
empty_grp_list = []
pm.select(stroke_list)
mel.eval('doPaintEffectsToPoly( 1,0,0,1,100000);')
for ctrl_geo_shape in pm.ls(sl=True):
stroke = pm.listConnections(ctrl_geo_shape.inMesh)[-1]
ctrl_geo = ctrl_geo_shape.getParent()
ctrl_geo_list.append(ctrl_geo)
empty_grp_list.append(ctrl_geo.getParent())
pm.rename(ctrl_geo, str(stroke).replace('_stroke', '_stroke_geo'))
ctrl_geo_grp = pm.group(em=True, n='ctrl_geo_grp')
stroke_grp = pm.group(stroke_list, n='stroke_grp', p=ctrl_geo_grp)
cv_geo_grp = pm.group(ctrl_geo_list, n='ctrl_geo_grp', p=ctrl_geo_grp)
pm.hide(stroke_grp)
pm.delete(empty_grp_list)
return ctrl_geo_list
def lock_rig(lock=True):
pm.hide(pm.ls(type='locator'))
pm.select(pm.ls(type='locator'), add=True)
pm.select(pm.ls(type='orientConstraint'), add=True)
pm.select(pm.ls(type='parentConstraint'), add=True)
pm.select(pm.ls(type='pointConstraint'), add=True)
# pm.select(pm.ls(type='skinCluster'),add=True)
# pm.select(pm.ls(type='blendShape'),add=True)
pm.select(pm.ls(type='follicle'), add=True)
pm.select(pm.ls(type='ikHandle'), add=True)
pm.select(pm.ls('*miscGp'), hi=True, add=True)
pm.select(pm.ls('*bonGp'), hi=True, add=True)
pm.select(pm.ls('*genGp'), hi=True, add=True)
# pm.select(pm.ls('*facialGp'),hi=True,add=True)
sel = pm.selected()
for i in sel:
log.info("{}:lock:{}".format(i, lock))
pm.lockNode(i, lock=lock)
if i.nodeType() == 'skinCluster':
for b in i.getInfluence():
b.attr('lockInfluenceWeights').set(lock)
try:
for atr in i.listAttr():
if 'vis' not in atr:
try:
if lock:
atr.lock()
else:
atr.unlock()
except:
pass
except:
pass
def annotateSelectionHandle(obj, text, pos=None):
'''
Make an annotation of the `obj`'s selection handle, optionally specifying
the position of the handle as well.
'''
obj.displayHandle.set( True )
if pos:
obj.selectHandle.set( pos )
loc = spaceLocator()
ann = annotate(loc, text=text).getParent()
ann.setParent( obj )
ann.t.set(obj.selectHandle.get())
ann.r.lock()
ann.s.lock()
loc.setParent(ann)
loc.t.set(0, 0, 0)
hide(loc)
add = createNode( 'plusMinusAverage' )
ann.t >> add.input3D[0]
add.input3D[1].set( 0, 1, 0 )
add.output3D >> obj.selectHandle
def directPlacementMode(card):
assert len(card.joints) == 3
grp = group(em=True, n='DirectPlacement_Deletable')
ctrls = []
for bpj in card.joints:
ctrl = tempWidget()
pdil.dagObj.matchTo(ctrl, bpj)
ctrls.append(ctrl)
ctrl.setParent(grp)
base, up, aim = ctrls
aimLoc = spaceLocator()
aimLoc.setParent(aim)
aimLoc.t.set(0, 0, 0)
baseLoc = spaceLocator()
baseLoc.setParent(base)
baseLoc.t.set(0, 0, 0)
dist = distanceDimension(baseLoc, aimLoc)
dist.getParent().setParent(grp)
hide(dist)
pointConstraint(base, card, mo=True)
aimConstraint(aim,
card,
wut='object',
wuo=up,
aim=[0, -1, 0],
u=[0, 0, -1],
mo=True)
# save base dimension
# current dimesion / base dimension
# multiply x, z by card's existing scale
dist.addAttr('baseDist', at='double', dv=dist.distance.get())
scaled = pdil.math.divide(dist.distance, dist.baseDist)
mult = createNode('multiplyDivide')
scaled >> mult.input1X
scaled >> mult.input1Y
scaled >> mult.input1Z
mult.input2Y.set(card.sy.get())
mult.input2Z.set(card.sz.get())
mult.outputY >> card.sy
mult.outputZ >> card.sz
pointConstraint(up, card.joints[1], sk='x')
def makeGroupIfNotExist(self, grpName, isHidden):
if not pm.objExists(grpName):
grp = pm.group(n=grpName, em=1)
if isHidden:
pm.hide(grp)
else:
grp = pm.PyNode(grpName)
return grp
def ToggleHairCtrlVis(state='switch'):
hairCtrlsGroup = pm.ls('HairCtrlGroup')[0]
if not hairCtrlsGroup:
return
if state == 'switch':
pass
elif state == 'show':
pm.showHidden(hairCtrlsGroup, below=True)
elif state == 'hide':
pm.hide([ctrl.getChildren() for ctrl in hairCtrlsGroup.getChildren()])
def disconnectNoise(self, cmd=''):
# Parent camera to world
pc.parent(self.camera, w=True)
# Disconnect offset attributes and move the anim curves back to the camera
self.disconnectOffsetAttributes()
self.reconnectAnimationCurves(self.control, self.camera)
# Add an extra attribute to the control locator to remember which camera was associated with. Then hide it
self.addControlLinkedCameraAttribute()
pc.hide(self.control)
pc.select(self.camera)
self.closeUI()
def disconnectNoise(self, cmd=''):
# Parent camera to world
pc.parent(self.camera, w=True)
# Disconnect offset attributes and move the anim curves back to the camera
self.disconnectOffsetAttributes()
self.reconnectAnimationCurves(self.control, self.camera)
# Add an extra attribute to the control locator to remember which camera was associated with. Then hide it
self.addControlLinkedCameraAttribute()
pc.hide(self.control)
pc.select(self.camera)
self.closeUI()
def fControl(self, newName, num):
circ = controls.roundZ(curveScale=.2)
pm.rename(circ, newName + "{0:02d}_fCTL".format(num))
border = controls.square2()
pm.hide(border)
pm.rename(border, newName + "{0:02d}_fBDR".format(num))
grp = pm.group(circ, border, n=newName + "{0:02d}_fGRP".format(num))
grp2 = pm.group(grp, n=newName + "offSet_{0:02d}_fGRP".format(num))
grp3 = pm.group(empty=True,
n=newName + "woldSpace_{0:02d}_fGRP".format(num))
pm.parent(grp2, grp3)
pm.setAttr(str(grp) + ".tz", -0.3)
def __init__(self, name):
self.side = ''
if name.startswith('l_'):
self.side = 'l'
if name.startswith('r_'):
self.side = 'r'
self.top = pm.PyNode(rig_transform(0, name=name+'Module').object)
self.controls = pm.PyNode(rig_transform(0, name=name+'Controls',
parent=self.top).object)
self.controlsSec = pm.PyNode(rig_transform(0, name=name + 'ControlsSecondary',
parent=self.controls).object)
self.skeleton = pm.PyNode(rig_transform(0, name=name+'Skeleton',
parent=self.top).object)
self.parts = pm.PyNode(rig_transform(0, name=name+'Parts',
parent=self.top).object)
pm.hide(self.parts)
pm.addAttr(self.top, longName='skeletonVis', at='long', k=True, min=0,
max=1)
pm.connectAttr(self.top.skeletonVis, self.skeleton.visibility)
pm.addAttr(self.top, longName='controlsVis', at='long', k=True, min=0,
max=1)
pm.connectAttr(self.top.controlsVis, self.controls.visibility)
pm.addAttr(self.top, longName='ikFkSwitch', at='long', k=True, min=0,
max=1)
if pm.objExists('global_CTRL'):
globalCtrl = pm.PyNode('global_CTRL')
pm.connectAttr(globalCtrl.skeletonVis, self.top.skeletonVis)
pm.connectAttr(globalCtrl.controlsVis, self.top.controlsVis)
pm.setAttr(self.skeleton.overrideEnabled, 1)
pm.setDrivenKeyframe(self.skeleton.overrideDisplayType,
cd=globalCtrl.skeleton, dv=0, v=0)
pm.setDrivenKeyframe(self.skeleton.overrideDisplayType,
cd=globalCtrl.skeleton, dv=1, v=2)
self.controlsList = []
self.skeletonList = []
self.partsList = []
rigModule = 'rigModules_GRP'
if pm.objExists(rigModule):
pm.parent(self.top, rigModule)
pm.addAttr(rigModule, longName=name+'Module', at='long', k=True,
min=0, max=1, dv=1)
pm.connectAttr( rigModule+'.'+name+'Module', self.top.visibility )
def matchMesh(self, btn):
""" This function can execute all functions related to creating a match mesh
Args:
None
Returns (None)
"""
smoothMesh = self.get_smooth_mesh()
skinMesh = self.get_skin_mesh()
pm.hide(skinMesh)
pm.showHidden(smoothMesh)
print smoothMesh
print 'YOU DID IT NOW MATCH THAT MESH!'
def accessoryGroup():
main = mainGroup()
for child in main.listRelatives():
if child.name() == 'accessory':
grp = child
break
else:
grp = group(n='accessory', em=True)
grp.setParent(main)
hide(grp)
return grp
def face_mesh_query():
transforms = []
transforms.append(py.getAttr('Blend_Morph.translate'))
transforms.append(py.getAttr('Blend_Morph.rotate'))
transforms.append(py.getAttr('Blend_Morph.scale'))
py.setAttr('master_locator_grp.translate', transforms[0], type="double3")
py.setAttr('master_locator_grp.rotate', transforms[1], type="double3")
py.setAttr('master_locator_grp.scale', transforms[2], type="double3")
py.setAttr('master_offset_grp.translate', transforms[0], type="double3")
py.setAttr('master_offset_grp.rotate', transforms[1], type="double3")
py.setAttr('master_offset_grp.scale', transforms[2], type="double3")
py.hide('Blend_Morph')
def shaderSwitch(pRenderStyle, *Args):
skinMat = getMaterial('Eyelashes')
fillMat = getMaterial('blocker')
if pRenderStyle == 'Normal':
applyMatToSelection(skinMat, ['Body_%s' % (globalGender[0]), 'Eyes'])
pm.hide('Eyes', 'blocker', 'IconRenderer')
pm.showHidden('Eyelashes')
if pRenderStyle == 'Flat':
applyMatToSelection(fillMat, ['Body_%s' % (globalGender[0]), 'Eyes'])
pm.showHidden('Eyes', 'blocker', 'IconRenderer')
pm.hide('Eyelashes')
def connectingLine(src, dest):
'''
Draw an annotation arrow from the src to the dest.
'''
loc = spaceLocator()
line = annotate(loc, tx='').getParent()
line.setParent(src)
line.t.set(0, 0, 0)
shape = line.getShape()
shape.overrideEnabled.set(True)
shape.overrideDisplayType.set(1)
loc.setParent(dest)
loc.t.set(0, 0, 0)
loc.t.lock()
hide(loc.listRelatives())
def maketwistJoints(self, parentJnt, nTwistJoint, rotAxis):
prefix = name.removeSuffix(parentJnt)
parentJntChild = pm.listRelatives(parentJnt, c=1, type='joint')[0]
# make twist joints
twistJntGrp = pm.group(n=prefix + 'TwistJoint_GRP',
p=self.twistJointsMainGrp,
em=1)
twistParentJnt = pm.duplicate(parentJnt,
n=prefix + 'TwistStart_JNT',
parentOnly=True)[0]
twistChildJnt = pm.duplicate(parentJntChild,
n=prefix + 'TwistEnd_JNT',
parentOnly=True)[0]
# adjust twist joints
origJntRadius = pm.getAttr(parentJnt + '.radius')
for j in [twistParentJnt, twistChildJnt]:
pm.setAttr(j + '.radius', origJntRadius * 2)
pm.color(j, ud=1)
pm.parent(twistChildJnt, twistParentJnt)
pm.parent(twistParentJnt, twistJntGrp)
# attach twist joints
pm.pointConstraint(parentJnt, twistParentJnt)
# make IK handle
twistIk = pm.ikHandle(n=prefix + 'TwistJoint_IKH',
sol='ikSCsolver',
sj=twistParentJnt,
ee=twistChildJnt)[0]
pm.hide(twistIk)
pm.parent(twistIk, twistJntGrp)
pm.parentConstraint(parentJntChild, twistIk)
pm.hide(twistParentJnt)
innerJointList = self.makeInnerTwistJoints(prefix, twistParentJnt,
twistChildJnt, nTwistJoint,
rotAxis)
pm.parent(innerJointList, twistJntGrp)
# Constriant twistJoint group to main Joint
pm.parentConstraint(parentJnt, twistJntGrp, mo=True)
def addConnectingCurve(objs):
'''
Given a list of objects, make a curve that links all of them.
'''
crv = curve( d=1, p=[(0, 0, 0)] * len(objs) )
grp = group(crv, n='connectingCurve')
for i, obj in enumerate(objs):
handle = cluster(crv.cv[i])[1]
pointConstraint( obj, handle )
handle.setParent( grp )
hide(handle)
crv.getShape().overrideEnabled.set( 1 )
crv.getShape().overrideDisplayType.set( 2 )
return grp
def createProxyCTRL():
import pymel.core as pm
proxyGrp = pm.ls(sl=True)[0]
grp = pm.duplicate(proxyGrp)
ctrlShape = pm.listRelatives(grp, ad=True, type="nurbsCurve")
ctrl = pm.listRelatives(ctrlShape, p=True)
proxyCtrlShape = pm.listRelatives(proxyGrp, ad=True, type="nurbsCurve")
proxyCtrl = pm.listRelatives(proxyCtrlShape, ap=True)
proxyGrpHier = pm.listRelatives(proxyGrp, ad=True)
for i in range(len(proxyGrpHier)):
pm.rename(proxyGrpHier[i], proxyGrpHier[i] + "Proxy")
pm.rename(proxyGrp, proxyGrp + "Proxy")
pm.rename(grp, proxyGrp[:-5])
for x in range(len(ctrl)):
pm.connectAttr(ctrl[x].translate, proxyCtrl[x].translate)
pm.connectAttr(ctrl[x].rotate, proxyCtrl[x].rotate)
pm.hide(proxyGrp)
pm.select(cl=True)
def makeClavicle(self, prefix, limbJoints, scapulaJnt, rigScale,
rigmodule):
clavicleCtrl = control.Control(prefix=prefix + 'Clavicle',
translateTo=scapulaJnt,
rotateTo=scapulaJnt,
parent=rigmodule.controlsGrp,
shape='sphere',
lockChannels=['t', 's', 'v'])
scapulaIk = pm.ikHandle(n=prefix + 'Scapula_IKH',
sol='ikSCsolver',
sj=scapulaJnt,
ee=limbJoints[0])[0]
pm.hide(scapulaIk)
pm.parentConstraint(self.baseAttachGrp, clavicleCtrl.Off, mo=1)
pm.parent(scapulaIk, clavicleCtrl.C)
pm.pointConstraint(clavicleCtrl.C, scapulaJnt)
return clavicleCtrl
def __init__(self, prefix='new', baseObj=None):
"""
:param prefix: str, prefix to name new objects
:param baseObj: instance of base.module.Base class
:return: None
"""
self.topGrp = pm.group(n=prefix + 'Module_GRP', em=1)
self.controlsGrp = pm.group(n=prefix + 'Controls_GRP',
em=1,
p=self.topGrp)
self.secControlsGrp = pm.group(n=prefix + 'secondaryControls_GRP',
em=1,
p=self.topGrp)
self.jointsGrp = pm.group(n=prefix + 'Joints_GRP', em=1, p=self.topGrp)
self.partsGrp = pm.group(n=prefix + 'Parts_GRP', em=1, p=self.topGrp)
self.partsNoTransGrp = pm.group(n=prefix + 'PartsNoTrans_GRP',
em=1,
p=self.topGrp)
pm.hide(self.partsGrp, self.partsNoTransGrp)
pm.setAttr(self.partsNoTransGrp + '.it', 0, l=1)
if (pm.objExists('display_CTRL')):
displayCtrl = pm.ls('display_CTRL')[0]
levelGrp = [self.controlsGrp, self.secControlsGrp]
pm.addAttr(displayCtrl,
ln=prefix,
at='enum',
enumName='none:block:all',
k=1,
dv=1)
pm.setAttr(displayCtrl + '.' + prefix, cb=1)
common.setDrivenKey(displayCtrl + '.' + prefix, [0, 1, 2],
levelGrp[0] + '.v', [0, 1, 1])
common.setDrivenKey(displayCtrl + '.' + prefix, [0, 1, 2],
levelGrp[1] + '.v', [0, 0, 1])
# parent module
if baseObj:
pm.parent(self.topGrp, baseObj.modulesGrp)
def jointonselection(obj=list(), prnt=False, pivot=False):
if not obj:
obj = pm.ls(sl=True)
if obj:
retJoints = list()
retCtrl = list()
for i in range(len(obj)):
pm.select(cl=True)
jnt = pm.joint(n=obj[i] + '_Jnt')
retJoints.append(jnt)
endJnt = pm.joint(n=obj[i] + '_EndJnt', p=(0, 1, 0))
prntConst = obj[i]
if pivot:
prntConst = pm.cluster(obj[i])
pm.select(cl=True)
pm.delete(pm.parentConstraint(prntConst, jnt))
pm.select(cl=True)
if pivot:
pm.delete(prntConst)
pm.hide(jnt)
offsetJnt = pm.joint(n='FKOffset' + obj[i])
retCtrl.append(offsetJnt)
pm.setAttr(offsetJnt + '.drawStyle', 2)
pm.delete(pm.parentConstraint(jnt, offsetJnt))
ExtraGrp = pm.group(n='FKExtra' + obj[i], em=True)
pm.delete(pm.parentConstraint(offsetJnt, ExtraGrp))
pm.parent(ExtraGrp, offsetJnt)
CTRL = pm.circle(n=obj[i] + '_CTRL', ch=False, nr=(0, 1, 0))
pm.delete(pm.parentConstraint(jnt, CTRL))
pm.parent(CTRL, ExtraGrp)
jntNul = pm.joint(n='FK' + obj[i])
pm.setAttr(jntNul + '.drawStyle', 2)
pm.parentConstraint(CTRL, jnt)
bind = pm.skinCluster(obj[i], jnt)
print "Done...",
if not prnt:
return retJoints, retCtrl
else:
return retJoints, jntNul
else:
print "Please Select Object",
return False, False
def advancedTwist(start, end, baseCtrl, endCtrl, ik):
# Setup advanced twist
startAxis = duplicate(start, po=True)[0]
startAxis.rename('startAxis')
startAxis.setParent(baseCtrl)
pdil.dagObj.lock(startAxis)
endAxis = duplicate(start, po=True)[0]
endAxis.rename('endAxis')
endAxis.setParent(endCtrl)
endAxis.t.set(0, 0, 0)
pdil.dagObj.lock(endAxis)
hide(startAxis, endAxis)
ik.dTwistControlEnable.set(1)
ik.dWorldUpType.set(4)
startAxis.worldMatrix[0] >> ik.dWorldUpMatrix
endAxis.worldMatrix[0] >> ik.dWorldUpMatrixEnd
def generateBoids(model_lst, x1, y1, z1, x2, y2, z2, vMin, vMax, numOfBoids):
boids = []
for i in range(numOfBoids):
model = model_lst[random.randint(0, len(model_lst)-1)]
x = random.randint(x1, x2)
y = random.randint(y1, y2)
z = random.randint(z1, z2)
vx = random.randint(vMin, vMax)
vy = random.randint(vMin, vMax)
vz = random.randint(vMin, vMax)
new_boid = pm.duplicate(model)
#print(new_boid,new_boid[0], randX, randY, randZ)
pm.move(x, y, z, new_boid[0], worldSpace = True)
boids.append(Boid(new_boid, x, y, z, vx, vy, vz))
for m in model_lst:
pm.hide(m)
return boids
def createMatcher(ctrl, target):
'''
Creates an object that follows target, based on ctrl so ctrl can match it
easily.
'''
matcher = duplicate(ctrl, po=True)[0]
parentConstraint(target, matcher, mo=True)
matcher.rename(ctrl.name() + '_matcher')
hide(matcher)
if not ctrl.hasAttr('matcher'):
ctrl.addAttr('matcher', at='message')
matcher.message >> ctrl.matcher
if matcher.hasAttr('fossilCtrlType'):
matcher.deleteAttr('fossilCtrlType')
return matcher
def getTrueWorld():
''' Make a node that stays in world space.
'''
main = find.mainGroup()
if not main:
return None
for child in main.listRelatives():
if pdil.shortName(child) == 'trueWorld':
return child
grp = group(em=True, name='trueWorld')
for t in 'trs':
for a in 'xyz':
grp.attr(t + a).setKeyable(False)
hide(grp)
grp.setParent(main)
grp.inheritsTransform.set(False)
return grp
def measure(start, end, name='measureLocs'):
'''
Given 2 objects, makes and point constrains locators to them and measures.
'''
a = spaceLocator()
pointConstraint(start, a)
b = spaceLocator()
pointConstraint(end, b)
dist = distanceDimension(a, b)
hide(a, b, dist)
grp = group(em=True, name=name)
grp.inheritsTransform.set(False)
a.setParent(grp)
b.setParent(grp)
return dist.getParent(), grp
def show_group(shown_group):
group_image = {'up_eye_locator_grp': 'thumb_upeye.png',
'low_eye_locator_grp': 'thumb_loweye.png',
'up_lip_locator_grp': 'thumb_upmouth.png',
'low_lip_locator_grp': 'thumb_lowmouth.png',
'head_locator_grp': 'thumb_jaw_head.png',
'cheek_locator_grp': 'thumb_cheek.png'}
if shown_group == 'all':
py.showHidden('up_eye_locator_grp',
'low_eye_locator_grp',
'up_lip_locator_grp',
'low_lip_locator_grp',
'head_locator_grp',
'cheek_locator_grp')
else:
py.hide('up_eye_locator_grp',
'low_eye_locator_grp',
'up_lip_locator_grp',
'low_lip_locator_grp',
'head_locator_grp',
'cheek_locator_grp')
py.showHidden(shown_group)
guide_gui(group_image[shown_group])
def hide(self):
pm.hide('%s' % (self.light))
def run():
RawMovementVector = IntVector2( 0, 0 )
numEnemies = 15
playSpaceMinMaxX = 50
playSpaceMinMaxY = 50
enemyList = []
# Init SDL
if sdl2.SDL_Init(sdl2.SDL_INIT_TIMER|sdl2.SDL_INIT_GAMECONTROLLER|sdl2.SDL_INIT_EVENTS) != 0:
print(sdl2.SDL_GetError())
return -1
# Init Controller
controller = sdl2.SDL_GameController()
for i in range(sdl2.SDL_NumJoysticks()):
if sdl2.SDL_IsGameController(i):
controller = sdl2.SDL_GameControllerOpen(i)
# Create SDL Window
ctrlWindow = sdl2.SDL_CreateWindow( b"Control", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 200, 150, sdl2.SDL_WINDOW_INPUT_FOCUS|sdl2.SDL_WINDOW_HIDDEN )
if not ctrlWindow:
print(sdl2.GetError())
return -1
# Init Player
player = pm.polyCube( name="Player", w=1, h=1, d=1, cuv=0, ax=(0,1,0), sx=1, sy=1, sz=1 )
if player is None:
print "ERROR! Player not created!"
return -1
else:
pm.selectType( pv=True )
pm.polySelectConstraint( type=0x0001, mode=3 )
pm.select()
pVs = pm.ls( selection=True, fl=True )
pm.select( cl=True )
for v in range(len(pVs)):
pm.polyColorPerVertex( pVs[v], colorRGB=(1.0,0.0,0.0), alpha=1.0, cdo=True, notUndoable=True )
pSpeed = 40.0
for i in range(numEnemies):
thisE = spawnEnemy(-(playSpaceMinMaxX), playSpaceMinMaxX)
enemyList.append(thisE)
print enemyList
# Start Ticks
lastTime = 0
cTime = sdl2.SDL_GetTicks()
activeEnemies = numEnemies
playerScale = 1.0
# Start Game Loop
running = True
while running:
# See if Yout Won achieved
#print activeEnemies
if activeEnemies < 1:
sdl2.SDL_DestroyWindow(ctrlWindow)
sdl2.SDL_Quit()
pm.select( all=True )
pm.delete()
return "You Won!"
#Calculate Delta Time
lastTime = cTime
cTime = sdl2.SDL_GetTicks()
dTime = cTime - lastTime
if dTime > 16:
dTime = 16
deltaM = float(dTime)/float(1000)
ButtonPressed = False
# Process Input
evnt = sdl2.SDL_Event()
while sdl2.SDL_PollEvent(ctypes.byref(evnt)) != 0:
if evnt.type == sdl2.SDL_QUIT:
running = False
break
elif evnt.type == sdl2.SDL_CONTROLLERAXISMOTION:
if evnt.caxis.axis == sdl2.SDL_CONTROLLER_AXIS_LEFTX:
RawMovementVector.x = evnt.caxis.value
break
elif evnt.caxis.axis == sdl2.SDL_CONTROLLER_AXIS_LEFTY:
RawMovementVector.y = evnt.caxis.value
break
elif evnt.type == sdl2.SDL_CONTROLLERBUTTONDOWN:
if evnt.cbutton.button == sdl2.SDL_CONTROLLER_BUTTON_A:
ButtonPressed = True
break
elif evnt.type == sdl2.SDL_CONTROLLERBUTTONUP:
if evnt.cbutton.button == sdl2.SDL_CONTROLLER_BUTTON_A:
ButtonPressed = False
break
elif evnt.type == sdl2.SDL_KEYDOWN:
if evnt.key.keysym.sym == sdl2.SDLK_ESCAPE:
sdl2.SDL_DestroyWindow(ctrlWindow)
sdl2.SDL_Quit()
break
#print RawMovementVector.x, RawMovementVector.y, ButtonPressed
# Remap Raw Movement to -1 to 1 in float
Movement = RemapMovement( RawMovementVector.x, RawMovementVector.y )
#print Movement.x, Movement.y
pMoveX = Movement.x * (deltaM*pSpeed)
pMoveY = Movement.y * (deltaM*pSpeed)
moveObj( player[0], pMoveX, 0.0, pMoveY)
for i in range(len(enemyList)):
testList = enemyList
testList[i] = updateEnemy( testList[i], playSpaceMinMaxX, playSpaceMinMaxY, deltaM )
if detectCollision( player[0], testList[i][0][0] ) == True:
vis = pm.getAttr( testList[i][0][0]+'.visibility' )
if vis == True:
pm.hide( enemyList[i][0][0] )
activeEnemies = activeEnemies - 1
playerScale = playerScale + 0.5
pm.xform( player[0], scale=[playerScale, playerScale, playerScale] )
# redraw viewport
pm.refresh( cv=True )
sdl2.SDL_DestroyWindow(ctrlWindow)
sdl2.SDL_Quit()
return 0
def create(cls, base_flaps, num_images,
rows, columns, radius, layout_index=0):
'''
:param base_flaps: Base flaps to choose from
:param num_images: Number of images in sequence
:param rows: Number of rows in layout
:param columns: Number of columns in layout
:param radius: Radius
:param layout_index: Index in row column layout
'''
ProgressBar.setup(
title='Creating Split Flaps',
text='...',
maximum=100,
parent=utils.get_maya_window()
)
flaps = utils.create_flaps(
num_images,
base_flaps,
layout_index,
rows,
columns)
ProgressBar.set(10, 'Creating cloth flaps...')
cloth_flaps = [utils.create_cloth_flap(flaps[0])]
cloth_flaps.extend([cloth_flaps[0].duplicate(rc=True)[0]
for i in xrange(num_images - 1)])
ProgressBar.set(20, 'Radially arranging flaps...')
utils.radial_arrangement(flaps, radius)
ProgressBar.set(30, 'Radially arranging cloth flaps')
utils.radial_arrangement(cloth_flaps, radius)
r, c = utils.get_row_col(layout_index, None, columns)
rowcol = '{:02d}{:02d}'.format(int(r), int(c))
cloth_name = 'cloth_flap_{}'.format(rowcol)
flaps_name = 'flaps_{}'.format(rowcol)
ProgressBar.set(50, 'Combining cloth geo...')
cloth = pm.polyUnite(
cloth_flaps,
ch=False,
mergeUVSets=True,
name=cloth_name + '_geo',
)[0]
ProgressBar.set(60, 'Combining flap geo...')
flaps = pm.polyUnite(
flaps,
ch=False,
mergeUVSets=True,
name=flaps_name + '_geo',
)[0]
pm.hide(cloth)
# Create colliders
ProgressBar.set(70, 'Creating Collider...')
collider = utils.create_collider(flaps, radius)
ProgressBar.set(80, 'Grouping geometry...')
flaps_grp = pm.group([flaps, collider],
name='flaps_{}_geo_grp'.format(rowcol))
rotate_grp = pm.group(cloth, name='rotate_{}_grp'.format(rowcol))
copy_grp = pm.group(em=True, name='copy_{}_grp'.format(rowcol))
split_flap = pm.group(
[copy_grp, rotate_grp, flaps_grp],
name=flaps_name + '_grp'
)
ProgressBar.set(90, 'Adding attributes...')
split_flap.addAttr('split_flap', at='bool', dv=True)
split_flap.addAttr('layout_index', at='long', dv=layout_index)
split_flap.addAttr('layout_row', at='long', dv=r)
split_flap.addAttr('layout_column', at='long', dv=c)
split_flap.addAttr('number_of_rows', at='long', dv=rows)
split_flap.addAttr('number_of_columns', at='long', dv=columns)
split_flap.addAttr('flaps', at='message')
split_flap.addAttr('cloth', at='message')
split_flap.addAttr('collider', at='message')
split_flap.addAttr('rotate_grp', at='message')
split_flap.addAttr('copy_grp', at='message')
copy_grp.message.connect(split_flap.copy_grp)
rotate_grp.message.connect(split_flap.rotate_grp)
flaps.message.connect(split_flap.flaps)
cloth.message.connect(split_flap.cloth)
collider.message.connect(split_flap.collider)
# Rename hierarchy
ProgressBar.set(95, 'Renaming hierarchy')
utils.replace_in_hierarchy(split_flap, r'\d+', 'BASE')
ProgressBar.set(100, 'Done!')
ProgressBar.hide()
return cls(split_flap)
def make_offset_groups(**kwargs):
py.showHidden('baseoffset')
py.hide('master_locator_grp')
delete_bool = kwargs.setdefault('delete', False)
if delete_bool is True:
for key in cl.EcGroup.group_offset_dict:
for i in range(0, len(cl.EcGroup.group_offset_dict[key])):
try:
print 'deleting %s' % key
py.delete(cl.EcGroup.group_offset_dict[key][i].group_name)
except:
print 'Tried to delete %s' % key
py.delete('cn_head_jnt', 'low_jaw_grp')
py.showHidden('master_locator_grp')
py.hide('baseoffset')
locator_placement_gui()
else:
master_jaw_grp = cl.EcGroup(groupName='low_jaw_grp').set_parent(operation='offset', parent='master_offset_grp')\
.match(DriveObject='cn_head_low_jaw_jnt').match(DrivenObject='master_offset_grp', DriveObject='cn_head_jnt',
type='parent', maintainOffset=True)\
.match(DrivenObject='follicles_grp', DriveObject='cn_head_jnt', type='parent', maintainOffset=True)
for key in cl.EcGroup.loc_name_pos_dict:
num = 2
parent = 'master_offset_grp'
side = ['rt_', 'lf_']
if key == 'head_low_jaw' or key == 'head':
main_offset = [None]
elif key == 'mouth_center_up':
main_offset = []
main_offset.append(cl.EcGroup(groupName='cn_'+key+'_m_grp'))
offset_group = cl.EcGroup(groupName='cn_'+key+'_offset_grp')
main_offset[0].set_parent(operation='offset', parent=parent)\
.match(DriveObject='cn_'+key+'_jnt')
offset_group.set_parent(operation='offset', parent=main_offset[0].group_name)\
.match(DriveObject='cn_'+key+'_jnt')\
.match(DriveObject='cn_'+key+'_f', deleteConstraint=False, maintainOffset=True)
offset = cl.EcOffset(key, 'cn_', offset_group.group_name)
elif 'mouth' in key:
if 'low' in key:
if key == 'mouth_center_low':
side = ['cn_']
num = 1
parent = 'low_jaw_grp'
else:
parent = 'low_jaw_grp'
main_offset = []
for i in range(0, num):
main_offset.append(cl.EcGroup(groupName=side[i]+key+'_m_grp'))
offset_group = cl.EcGroup(groupName=side[i]+key+'_offset_grp')
main_offset[i].set_parent(operation='offset', parent=parent)\
.match(DriveObject=side[i]+key+'_jnt')
offset_group.set_parent(operation='offset', parent=main_offset[i].group_name)\
.match(DriveObject=side[i]+key+'_jnt')\
.match(DriveObject=side[i]+key+'_f', deleteConstraint=False, maintainOffset=True)
rotate_offset = cl.EcGroup(groupName=side[i]+key+'_rotate_grp')\
.set_parent(operation='offset', parent=offset_group.group_name)
if 'low' in key:
rotate_offset.match(DriveObject='cn_head_low_jaw_jnt', deleteConstraint=False, type='parent')
offset = cl.EcOffset(key, side[i], rotate_offset.group_name).freeze()
else:
main_offset = []
for i in range(0, num):
main_offset.append(cl.EcGroup(groupName=side[i]+key+'_m_grp'))
offset_group = cl.EcGroup(groupName=side[i]+key+'_offset_grp')
main_offset[i].set_parent(operation='offset', parent=parent)\
.match(DriveObject=side[i]+key+'_jnt')
offset_group.set_parent(operation='offset', parent=main_offset[i].group_name)\
.match(DriveObject=side[i]+key+'_jnt')\
.match(DriveObject=side[i]+key+'_f', deleteConstraint=False, maintainOffset=True)
offset = cl.EcOffset(key, side[i], offset_group.group_name)
cl.EcGroup.group_offset_dict[key] = main_offset
py.hide('baseoffset')
offset_gui()
pm.parentConstraint(ctrls[i], jnt) Colorize(ctrls[i],color='r') # parent first and last lower joints to first and last upper controls curves pm.parentConstraint(ctrls[0], lowControlJnts[-1]) pm.parentConstraint(ctrls[4], lowControlJnts[0]) # create extra groups above control curves ctrlZeroGrps = ZeroGrp(ctrls)[0] # make controls more animation friendly by parenting them under each other pm.parentConstraint(ctrls[0], ctrls[2], ctrlZeroGrps[1], mo=True) pm.parentConstraint(ctrls[2], ctrls[4], ctrlZeroGrps[3], mo=True) pm.parentConstraint(ctrls[0], ctrls[2], ctrlZeroGrps[1], mo=True) pm.parentConstraint(ctrls[4], ctrls[6], ctrlZeroGrps[5], mo=True) pm.parentConstraint(ctrls[6], ctrls[0], ctrlZeroGrps[7], mo=True) # cleanup outliner # ========================================================================= lidSkinJnts_grp = pm.group( uppJnts, lowJnts, name=prefix+"_lidSkinJnts_grp" ) lidControlJnts_grp = pm.group( uppControlJnts, lowControlJnts, name=prefix+"_lidControlJnts_grp" ) lidLocs_grp = pm.group( uppLocs, lowLocs, name=prefix+"_lidLocs_grp" ) lidCtrls_grp = pm.group( ctrlZeroGrps, name=prefix+"_lidCtrls_grp" ) pm.hide(uppLocs, lowLocs, uppControlJnts, lowControlJnts) # mirror everthing # ========================================================================= lid_rig_grp = pm.group(lidSkinJnts_grp, lidControlJnts_grp, lidLocs_grp, lidCtrls_grp, uppCurve, lowCurve, center, upVec, upVec, name=prefix+"_lid_rig_grp") pm.xform(lid_rig_grp, os=True, piv=(0,0,0)) otherSide_lid_rig_grp = pm.duplicate(lid_rig_grp,rr=True,un=True)[0] otherSide_lid_rig_grp.scaleX.set(-1) mel.eval( 'searchReplaceNames "L_" "R_" "hierarchy"' ) mel.eval( 'searchReplaceNames "grp1" "grp" "selected"' )
