def _mirrorAttributeBridges_(self):
addForwardBack = self.d_kws['addForwardBack']
if addForwardBack:
mPlug_forwardBackDriver = cgmMeta.cgmAttr(self.mi_control,
"forwardBack",
attrType='float',
keyable=True)
try:
mPlug_forwardBackDriven = cgmMeta.validateAttrArg(
[self.mi_control, addForwardBack])['mi_plug']
except Exception, error:
raise StandardError, "push pull driver | %s" % (error)
if self.str_mirrorSide.lower() == 'right':
arg_forwardBack = "%s = -%s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
else:
arg_forwardBack = "%s = %s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
mPlug_forwardBackDriven.p_locked = True
mPlug_forwardBackDriven.p_hidden = True
mPlug_forwardBackDriven.p_keyable = False
NodeF.argsToNodes(arg_forwardBack).doBuild()
def _mirrorAttributeBridges_(self):
addForwardBack = self.d_kws['addForwardBack']
if addForwardBack:
mPlug_forwardBackDriver = cgmMeta.cgmAttr(self.mi_control,"forwardBack",attrType = 'float',keyable=True)
try:
mPlug_forwardBackDriven = cgmMeta.validateAttrArg([self.mi_control,addForwardBack])['mi_plug']
except Exception,error:raise StandardError,"push pull driver | %s"%(error)
if self.str_mirrorSide.lower() == 'right':
arg_forwardBack = "%s = -%s"%(mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
else:
arg_forwardBack = "%s = %s"%(mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
mPlug_forwardBackDriven.p_locked = True
mPlug_forwardBackDriven.p_hidden = True
mPlug_forwardBackDriven.p_keyable = False
NodeF.argsToNodes(arg_forwardBack).doBuild()
if self._addMirrorAttributeBridges:
for l_bridge in self._addMirrorAttributeBridges:
_attrName = VALID.stringArg(l_bridge[0])
_attrToBridge = VALID.stringArg(l_bridge[1])
if not self.mi_control.hasAttr(_attrToBridge):
raise StandardError,"['%s' lacks the bridge attr '%s']"%(self.mi_control.p_nameShort,_attrToBridge)
mPlug_attrBridgeDriver = cgmMeta.cgmAttr(self.mi_control,_attrName,attrType = 'float',keyable=True)
try:
mPlug_attrBridgeDriven = cgmMeta.validateAttrArg([self.mi_control,_attrToBridge])['mi_plug']
except Exception,error:raise StandardError,"[validate control attribute bridge attr]{%s}"%(error)
if self.str_mirrorSide.lower() == 'right':
arg_attributeBridge = "%s = -%s"%(mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
else:
arg_attributeBridge = "%s = %s"%(mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
mPlug_attrBridgeDriven.p_keyable = False
NodeF.argsToNodes(arg_attributeBridge).doBuild()
def _mirrorAttributeBridges_(self):
addForwardBack = self.d_kws['addForwardBack']
if addForwardBack:
mPlug_forwardBackDriver = cgmMeta.cgmAttr(self.mi_control,"forwardBack",attrType = 'float',keyable=True)
try:
mPlug_forwardBackDriven = cgmMeta.validateAttrArg([self.mi_control,addForwardBack])['mi_plug']
except Exception,error:raise StandardError,"push pull driver | %s"%(error)
if self.str_mirrorSide.lower() == 'right':
arg_forwardBack = "%s = -%s"%(mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
else:
arg_forwardBack = "%s = %s"%(mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
mPlug_forwardBackDriven.p_locked = True
mPlug_forwardBackDriven.p_hidden = True
mPlug_forwardBackDriven.p_keyable = False
NodeF.argsToNodes(arg_forwardBack).doBuild()
if self._addMirrorAttributeBridges:
for l_bridge in self._addMirrorAttributeBridges:
_attrName = cgmValid.stringArg(l_bridge[0])
_attrToBridge = cgmValid.stringArg(l_bridge[1])
if not self.mi_control.hasAttr(_attrToBridge):
raise StandardError,"['%s' lacks the bridge attr '%s']"%(self.mi_control.p_nameShort,_attrToBridge)
mPlug_attrBridgeDriver = cgmMeta.cgmAttr(self.mi_control,_attrName,attrType = 'float',keyable=True)
try:
mPlug_attrBridgeDriven = cgmMeta.validateAttrArg([self.mi_control,_attrToBridge])['mi_plug']
except Exception,error:raise StandardError,"[validate control attribute bridge attr]{%s}"%(error)
if self.str_mirrorSide.lower() == 'right':
arg_attributeBridge = "%s = -%s"%(mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
else:
arg_attributeBridge = "%s = %s"%(mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
mPlug_attrBridgeDriven.p_keyable = False
NodeF.argsToNodes(arg_attributeBridge).doBuild()
def register(
controlObject=None, #(mObject - None) -- The object to use as a control
typeModifier=None, #(string - None) -- Tag for cgmTypeModifier for naming
copyTransform=None, #(mObject - None) -- Object to copy the transform of for our control object
copyPivot=None, #(mObject - None) -- Object to copy the pivot of for our control object
shapeParentTo=None, #'(mObject - None) -- Object to shape parent our control curve to to use that transform
useShape=None, #'(mObject - None) -- Object to use the curve shape of for our control
setRotateOrder=None, #'(rotateOrder - None) -- Argument for a rotate order to set
autoLockNHide=None, #'(bool - None) -- Try to set lock and hide
mirrorAxis=None, #'(string - None) -- Mirror axis to set - using red9's setup terms
mirrorSide=None, #'(string/int - None) -- Mirror side - using red9's setup terms
makeMirrorable=True, #'(bool - True) -- Setup for mirrorability (using red9) -- implied by other mirror args
addDynParentGroup=False, #'(False) -- Add a dynParent group setup
addExtraGroups=False, #'(int - False) -- Number of nested extra groups desired
addConstraintGroup=False, #'(bool - False) -- If a group just above the control is desired for consraining
freezeAll=False, #'(bool - False) -- Freeze all transforms on the control object
noFreeze=False,
addSpacePivots=False, #'(int - False) -- Number of space pivots to generate and connect
controlType=None, #'(string - None) -- Tag for cgmType
aim=None, #'(string/int - None) -- aim axis to use
up=None, #'(string/int - None) -- up axis to use
out=None, #'(string/int - None) -- out axis to use
makeAimable=None, #'(mObject - False) -- Make object aimable -- implied by aim/up/out):
**kws):
_str_func = 'register'
"""
[{'step':'validate','call':self._validate},
{'step':'Copy Transform','call':self._copyTransform},
{'step':'Shape Parent','call':self._shapeParent},
{'step':'Copy Pivot','call':self._copyPivot},
{'step':'Naming','call':self._naming},
{'step':'Aim Setup','call':self._aimSetup},
{'step':'Rotate Order','call':self._rotateOrder},
{'step':'Initial Freeze','call':self._initialFreeze},
{'step':'Groups Setup','call':self._groupsSetup},
{'step':'Space Pivot','call':self._spacePivots},
{'step':'Mirror Setup','call':self._mirrorSetup},
{'step':'Freeze','call':self._freeze},
{'step':'Mirror Attribute Bridges','call':self._mirrorAttributeBridges_},
{'step':'lock N Hide','call':self._lockNHide},
{'step':'Return build','call':self._returnBuild}]
"""
try:
#Validate ================================================================================================
mi_control = cgmMeta.validateObjArg(controlObject,
'cgmControl',
setClass=True)
str_mirrorAxis = VALID.stringArg(mirrorAxis, calledFrom=_str_func)
str_mirrorSide = cgmGeneral.verify_mirrorSideArg(
mirrorSide) #VALID.stringArg(mirrorSide,calledFrom = _str_func)
b_makeMirrorable = VALID.boolArg(makeMirrorable, calledFrom=_str_func)
_addMirrorAttributeBridges = kws.get('addMirrorAttributeBridges',
False)
addForwardBack = kws.get('addForwardBack', False)
if _addMirrorAttributeBridges:
if type(_addMirrorAttributeBridges) not in [list, tuple]:
raise ValueError, "[Bad addMirrorAttributeBridge arg]{arg: %s}" % _addMirrorAttributeBridge
for i, l in enumerate(_addMirrorAttributeBridges):
if type(l) not in [list, tuple]:
raise ValueError, "[Bad addMirrorAttributeBridge arg: %s]{arg: %s}" % (
i, l)
# Running lists ------------------------------------------------------------------------------------------
ml_groups = [] #Holder for groups
ml_constraintGroups = []
ml_spacePivots = []
#Copy Transform ================================================================================================
if copyTransform is not None:
mTarget = cgmMeta.validateObjArg(copyTransform,
'cgmObject',
noneValid=True)
if not mTarget:
raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyTransform
#Need to move this to default cgmNode stuff
mBuffer = mi_control
i_newTransform = cgmMeta.cgmObject(
rigging.groupMeObject(mTarget.mNode, False))
for a in mc.listAttr(mi_control.mNode, userDefined=True):
ATTR.copy_to(mi_control.mNode, a, i_newTransform.mNode)
curves.parentShapeInPlace(i_newTransform.mNode,
mi_control.mNode) #Parent shape
i_newTransform.parent = mi_control.parent #Copy parent
mi_control = cgmMeta.asMeta(i_newTransform,
'cgmControl',
setClass=True)
mc.delete(mBuffer.mNode)
#ShapeParent ================================================================================================
if shapeParentTo:
i_target = cgmMeta.validateObjArg(shapeParentTo, 'cgmObject')
CORERIG.shapeParent_in_place(i_target.mNode, mi_control.mNode)
i_target = cgmMeta.asMeta(i_target, 'cgmControl', setClass=True)
#mi_control.delete()
mi_control = i_target #replace the control with the joint
if useShape is not None:
i_shape = cgmMeta.validateObjArg(useShape,
cgmMeta.cgmObject,
mayaType='nurbsCurve')
curves.parentShapeInPlace(mi_control.mNode, i_shape.mNode)
#Copy Pivot ============================================================================================
if copyPivot is not None:
if issubclass(type(copyPivot), cgmMeta.cgmNode):
i_target = copyPivot
elif mc.objExists(copyPivot):
i_target = cgmMeta.cgmObject(copyPivot)
else:
raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyPivot
#Need to move this to default cgmNode stuff
mi_control.doCopyPivot(i_target.mNode)
#Naming ============================================================================================
mi_control.addAttr('cgmType', 'controlAnim', lock=True)
if typeModifier is not None:
mi_control.addAttr('cgmTypeModifier', str(typeModifier), lock=True)
mi_control.doName() #mi_control.doName(nameShapes=True)
#Rotate Order ============================================================================================
_rotateOrder = False
if setRotateOrder is not None:
_rotateOrder = setRotateOrder
elif controlType in __d_rotateOrderDefaults__.keys():
_rotateOrder = __d_rotateOrderDefaults__[controlType]
elif mi_control.getAttr('cgmName') in __d_rotateOrderDefaults__.keys():
_rotateOrder = __d_rotateOrderDefaults__[mi_control.getAttr(
'cgmName')]
else:
log.debug("|{0}| >> Rotate order not set on: {1}".format(
_str_func, mi_control.p_nameShort))
#Set it ---------------------------------------------------------------
if _rotateOrder:
mRotateOrder = VALID.simpleOrientation(_rotateOrder)
#dictionary.validateRotateOrderString(_rotateOrder)
mc.xform(mi_control.mNode, rotateOrder=mRotateOrder.p_string)
#Initial Freeze ============================================================================================
if freezeAll:
mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=1, s=1, n=0)
#Groups ============================================================================================
if addDynParentGroup or addSpacePivots or mi_control.getAttr(
'cgmName') == 'cog' or _addMirrorAttributeBridges:
mi_control.addAttr('________________',
attrType='int',
keyable=False,
hidden=False,
lock=True)
ATTR.reorder(mi_control.mNode, '________________', top=True)
#Aim Setup ============================================================================================
if aim is not None or up is not None or makeAimable:
mi_control._verifyAimable()
#First our master group:
i_masterGroup = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
i_masterGroup.doStore('cgmName', mi_control)
i_masterGroup.addAttr('cgmTypeModifier', 'master', lock=True)
i_masterGroup.doName()
mi_control.connectChildNode(i_masterGroup, 'masterGroup', 'groupChild')
if addDynParentGroup:
i_dynGroup = (cgmMeta.cgmObject(mi_control.doGroup(True)))
i_dynGroup = cgmRigMeta.cgmDynParentGroup(dynChild=mi_control,
dynGroup=i_dynGroup)
i_dynGroup.doName()
"""
i_zeroGroup = (cgmMeta.cgmObject(mi_control.doGroup(True)))
i_zeroGroup.addAttr('cgmTypeModifier','zero',lock=True)
i_zeroGroup.doName()
mi_control.connectChildNode(i_zeroGroup,'zeroGroup','groupChild')"""
if addExtraGroups:
for i in range(addExtraGroups):
i_group = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
if type(
addExtraGroups
) == int and addExtraGroups > 1: #Add iterator if necessary
i_group.addAttr('cgmIterator', str(i + 1), lock=True)
i_group.doName()
ml_groups.append(i_group)
mi_control.msgList_connect("extraGroups", ml_groups, 'groupChild')
if addConstraintGroup: #ConstraintGroups
i_constraintGroup = (cgmMeta.asMeta(mi_control.doGroup(True),
'cgmObject',
setClass=True))
i_constraintGroup.addAttr('cgmTypeModifier',
'constraint',
lock=True)
i_constraintGroup.doName()
ml_constraintGroups.append(i_constraintGroup)
mi_control.connectChildNode(i_constraintGroup, 'constraintGroup',
'groupChild')
#Space Pivot ============================================================================================
if addSpacePivots:
parent = mi_control.getMessage('masterGroup')[0]
for i in range(int(addSpacePivots)):
#i_pivot = rUtils.create_spaceLocatorForObject(mi_control.mNode,parent)
i_pivot = SPACEPIVOTS.create(mi_control.mNode, parent)
ml_spacePivots.append(i_pivot)
#log.info("spacePivot created: {0}".format(i_pivot.p_nameShort))
#Mirror Setup ============================================================================================
if str_mirrorSide is not None or b_makeMirrorable:
for mObj in [mi_control] + ml_spacePivots:
mi_control._verifyMirrorable()
l_enum = cgmMeta.cgmAttr(mi_control, 'mirrorSide').p_enum
if str_mirrorSide in l_enum:
#log.debug("|{0}| >> Rotate order not set on: {1}".format(_str_func,mi_control.p_nameShort))
#log.debug("%s >> %s >> found in : %s"%(_str_funcCombined, "mirrorSetup", l_enum))
mi_control.mirrorSide = l_enum.index(str_mirrorSide)
if str_mirrorAxis:
mi_control.mirrorAxis = str_mirrorAxis
for mObj in mi_control.msgList_get('spacePivots'):
mObj._verifyMirrorable()
mi_control.doConnectOut('mirrorAxis',
mObj.mNode + '.mirrorAxis')
mi_control.doConnectOut('mirrorSide',
mObj.mNode + '.mirrorSide')
#cgmMeta.cgmAttr(mObj,'mirrorSide').doConnectIn(mi_control,'mirrorSide')
#cgmMeta.cgmAttr(mi_control,'mirrorAxis').doCopyTo(mObj,connectTargetToSource = 1)
#ATTR.connect(mObj.mNode + '.mirrorAxis',"{0}.mirrorAxis".format(mi_control.mNode))
#ATTR.connect(mObj.mNode + 'mirrorSide',"{0}.mirrorSide".format(mi_control.mNode))
#Freeze ============================================================================================
if not shapeParentTo and noFreeze is not True:
if not freezeAll:
if mi_control.getAttr(
'cgmName'
) == 'cog' or controlType in __l_fullFreezeTypes__:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=1,
s=1,
n=0)
else:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=0,
s=1,
n=0)
else:
mc.makeIdentity(mi_control.mNode,
apply=True,
t=1,
r=1,
s=1,
n=0)
#Mirror attriubte Bridges ==========================================================================
if addForwardBack:
mPlug_forwardBackDriver = cgmMeta.cgmAttr(mi_control,
"forwardBack",
attrType='float',
keyable=True)
try:
mPlug_forwardBackDriven = cgmMeta.validateAttrArg(
[mi_control, addForwardBack])['mi_plug']
except Exception, error:
raise StandardError, "push pull driver | %s" % (error)
if str_mirrorSide.lower() == 'right':
arg_forwardBack = "%s = -%s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
else:
arg_forwardBack = "%s = %s" % (
mPlug_forwardBackDriven.p_combinedShortName,
mPlug_forwardBackDriver.p_combinedShortName)
mPlug_forwardBackDriven.p_locked = True
mPlug_forwardBackDriven.p_hidden = True
mPlug_forwardBackDriven.p_keyable = False
NodeF.argsToNodes(arg_forwardBack).doBuild()
if _addMirrorAttributeBridges:
for l_bridge in _addMirrorAttributeBridges:
_attrName = VALID.stringArg(l_bridge[0])
_attrToBridge = VALID.stringArg(l_bridge[1])
if not mi_control.hasAttr(_attrToBridge):
raise StandardError, "['%s' lacks the bridge attr '%s']" % (
mi_control.p_nameShort, _attrToBridge)
mPlug_attrBridgeDriver = cgmMeta.cgmAttr(mi_control,
_attrName,
attrType='float',
keyable=True)
try:
mPlug_attrBridgeDriven = cgmMeta.validateAttrArg(
[mi_control, _attrToBridge])['mi_plug']
except Exception, error:
raise StandardError, "[validate control attribute bridge attr]{%s}" % (
error)
if str_mirrorSide.lower() == 'right':
arg_attributeBridge = "%s = -%s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
else:
arg_attributeBridge = "%s = %s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
mPlug_attrBridgeDriven.p_keyable = False
NodeF.argsToNodes(arg_attributeBridge).doBuild()
import cgm.core
cgm.core._reload()
from cgm.core import cgm_Meta as cgmMeta
obj = mc.ls(sl=True)[0] or False
obj = ''
objList = []
orientation = ['xyz']
orientation[1]
cgmMeta.cgmObject(mc.ls(sl=True)[0]).doName()
mi_obj = cgmMeta.cgmObject(obj)
cgmMeta.validateObjArg(mi_obj,cgmMeta.cgmObject)
cgmMeta.validateObjArg(mi_obj)
cgmMeta.validateAttrArg([mi_obj,'tx'])
cgmMeta.validateAttrArg([obj,'tx'])
cgmMeta.validateAttrArg("%s.tx"%obj)
from cgm.core import cgm_Meta as cgmMeta
n1 = cgmMeta.cgmNode(nodeType='transform')#This will create a cgmNode instance of a new transform node
@cgmGeneral.Timer
def check(arg):
issubclass(arg,cgmMeta.cgmNode):
return True
def plug_insertNewValues(driven = None, drivers = [], replace = False, mode = 'multiply'):
"""
Given an attribute, add in new values to it. If it has a plug, use that
"""
try:
_str_func = 'plug_insertNewValues'
log.debug("|{0}| >> ".format(_str_func)+ '-'*80)
if mode not in ['multiply']:
raise ValueError,"Mode not supported: {0}".format(mode)
d_driven = cgmMeta.validateAttrArg(driven)
mPlug = d_driven['mPlug']
ml_drivers = []
mPreDriver = mPlug.getDriver(asMeta=True)
log.debug("|{0}| >> Pre Driver: {1}".format(_str_func,mPreDriver))
for d in drivers:
d_driver = cgmMeta.validateAttrArg(d)
if d_driver:
ml_drivers.append(d_driver['mPlug'])
log.debug("|{0}| >> Driver: {1}".format(_str_func,d_driver['mPlug']))
else:
log.debug("|{0}| >> Failed to validate: {1}".format(_str_func,d))
if not ml_drivers:
raise ValueError, "No drivers validated"
if not replace:
ml_drivers.insert(0,mPreDriver[0])
if len(ml_drivers) < 2:
raise ValueError,"Must have more than two drivers. Found: {0}".format(ml_drivers)
ATTR.break_connection(mPlug.p_combinedName)
lastNode = None
for i,mDriver in enumerate(ml_drivers[:-1]):
if not lastNode:
lastNode = mc.createNode('multDoubleLinear')
mDriver.doConnectOut(lastNode + '.input1')
ml_drivers[i+1].doConnectOut(lastNode + '.input2')
else:
newNode = mc.createNode('multDoubleLinear')
ATTR.connect(lastNode+'.output',newNode + '.input1')
ml_drivers[i+1].doConnectOut(newNode + '.input2')
lastNode=newNode
ATTR.connect(lastNode+'.output',mPlug.p_combinedName)
except Exception,err:
#pprint.pprint(vars())
cgmGEN.cgmExceptCB(Exception,err,msg=vars())
raise Exception,err
def matchValue_iterator(matchObj = None,
matchAttr = None,
drivenObj = None,
drivenAttr = None,
driverAttr = None,
minIn = -179, maxIn = 179, maxIterations = 40, matchValue = None,
iterMode = 'step'):
"""
Started with Jason Schleifer's afr js_iterator and 'tweaked'
matchObj - The object to match to the driven
driven - the object moved by the driver
"""
_str_func = 'matchValue_iterator'
log.debug("|{0}| >> ...".format(_str_func))
if type(minIn) not in [float,int]:raise ValueError,"matchValue_iterator>>> bad minIn: %s"%minIn
if type(maxIn) not in [float,int]:raise ValueError,"matchValue_iterator>>> bad maxIn: %s"%maxIn
__matchMode__ = False
#>>> Data gather and arg check
mi_matchObj = cgmMeta.validateObjArg(matchObj,'cgmObject',noneValid=True)
d_matchAttr = cgmMeta.validateAttrArg(matchAttr,noneValid=True)
if mi_matchObj:
__matchMode__ = 'matchObj'
minValue = minIn
maxValue = maxIn
elif d_matchAttr:
__matchMode__ = 'matchAttr'
elif matchValue is not None:
__matchMode__ = 'value'
else:
raise ValueError,"|{0}| >> No match given. No matchValue given".format(_str_func)
__drivenMode__ = False
mi_drivenObj = None
if drivenObj and drivenAttr:
d_drivenAttr = cgmMeta.validateAttrArg("{0}.{1}".format(drivenObj,drivenAttr),noneValid=True)
else:
mi_drivenObj = cgmMeta.validateObjArg(drivenObj,'cgmObject',noneValid=True)
d_drivenAttr = cgmMeta.validateAttrArg(drivenAttr,noneValid=True)
if mi_drivenObj and not drivenAttr:#not an object match but a value
__drivenMode__ = 'object'
elif d_drivenAttr:
__drivenMode__ = 'attr'
mPlug_driven = d_drivenAttr['mi_plug']
f_baseValue = mPlug_driven.value
minRange = float(f_baseValue - 10)
maxRange = float(f_baseValue + 10)
mPlug_driven
log.debug("|{0}| >> Attr mode. Attr: {1} | baseValue: {2} ".format(_str_func,mPlug_driven.p_combinedShortName,f_baseValue))
else:
raise ValueError,"|{0}| >> No driven given".format(_str_func)
d_driverAttr = cgmMeta.validateAttrArg(driverAttr,noneValid=False)
mPlug_driver = d_driverAttr['mi_plug']
if not mPlug_driver:
raise ValueError,"|{0}| >> No driver given".format(_str_func)
log.debug("|{0}| >> Source mode: {1} | Target mode: {2}| Driver: {3}".format(_str_func,__matchMode__,__drivenMode__,mPlug_driver.p_combinedShortName))
# Meat ==========================================================================================
b_autoFrameState = mc.autoKeyframe(q=True, state = True)
if b_autoFrameState:
mc.autoKeyframe(state = False)
minValue = float(minIn)
maxValue = float(maxIn)
minUse = copy.copy(minValue)
maxUse = copy.copy(maxValue)
f_lastClosest = None
f_lastValue = None
cnt_sameValue = 0
b_matchFound = None
b_firstIter = True
d_valueToSetting = {}
#Source type: value
for i in range(maxIterations):
if __matchMode__ == 'value':
if __drivenMode__ == 'attr':
if iterMode == 'bounce':
log.debug("matchValue_iterator>>> Step : %s | min: %s | max: %s | baseValue: %s | current: %s"%(i,minValue,maxValue,f_baseValue,mPlug_driven.value))
if MATH.is_float_equivalent(mPlug_driven.value,matchValue,3):
log.debug("matchValue_iterator>>> Match found: %s == %s | %s: %s | step: %s"%(mPlug_driven.p_combinedShortName,matchValue,mPlug_driver.p_combinedShortName,minValue,i))
b_matchFound = minValue
break
f_currentDist = abs(matchValue-mPlug_driven.value)
mPlug_driver.value = minValue#Set to min
f_minDist = abs(matchValue-mPlug_driven.value)#get Dif
f_minSetValue = mPlug_driven.value
mPlug_driver.value = maxValue#Set to max
f_maxDist = abs(matchValue-mPlug_driven.value)#Get dif
f_maxSetValue = mPlug_driven.value
f_half = ((maxValue-minValue)/2.0) + minValue#get half
#First find range
if f_minSetValue > matchValue or f_maxSetValue < matchValue:
log.error("Bad range, alternate range find. minSetValue = %s > %s < maxSetValue = %s"%(f_minSetValue,matchValue,f_maxSetValue))
if not MATH.is_float_equivalent(matchValue,0) and not MATH.is_float_equivalent(minValue,0) and not MATH.is_float_equivalent(f_minSetValue,0):
#if none of our values are 0, this is really fast
minValue = (minValue * matchValue)/f_minSetValue
log.debug("matchValue_iterator>>> Equated: %s"%minValue)
f_closest = f_minDist
mPlug_driver.value = minValue#Set to min
else:
if f_minDist>f_maxDist:#if min dif greater, use half as new min
if f_half < minIn:
raise StandardError, "half min less than minValue"
f_half = minIn
minValue = f_half
#log.debug("matchValue_iterator>>>Going up")
f_closest = f_minDist
else:
if f_half > maxIn:
raise StandardError, "half max less than maxValue"
f_half = maxIn
maxValue = f_half
#log.debug("matchValue_iterator>>>Going down")
f_closest = f_maxDist
elif iterMode == 'step':
currentDriven = mPlug_driven.value
if i == 0:
log.debug("|{0}| >> First step getting base data...".format(_str_func))
f_lastValue = currentDriven
_stepSmall = .000001
minStep = _stepSmall
_stepBig = 10
f_stepBase = mPlug_driver.value
f_stepEnd = f_stepBase + _stepBig
"""
mPlug_driver.value = currentDriven + .1
f_up = mPlug_driven.value
mPlug_driver.value = currentDriven - .1
f_down = mPlug_driven.value
diff_up = abs(f_baseValue - f_down)
diff_dn = abs(f_baseValue - f_up)
log.debug("|{0}| >> up :{1} | down: {2}".format(_str_func,diff_up,diff_dn))
if diff_up > diff_dn:
_dir = 'up'
_mult = 1
else:
_dir = 'dn'
_mult = -1"""
log.info(cgmGEN._str_subLine)
log.debug("|{0}| >> Iter :{1} | stepBase: {2} | stepEnd: {5} | step: {6} | current: {3} | match: {4}".format(_str_func,
i,
f_stepBase,
currentDriven,
matchValue,
f_stepEnd,
_stepBig))
if MATH.is_float_equivalent(currentDriven,matchValue,3):
log.debug("|{0}| >> Match found...".format(_str_func))
b_matchFound = f_stepBase
break
f_currentDist = (matchValue-currentDriven)
mPlug_driver.value = f_stepBase#setp min
f_minValue = mPlug_driven.value
f_minDist = (matchValue-mPlug_driven.value)#get Dif
mPlug_driver.value = f_stepEnd
f_maxDist = (matchValue-mPlug_driven.value)#Get dif
f_maxValue = mPlug_driven.value
f_stepHalf = f_stepBase + ((_stepBig/2.0))
f_half = f_stepHalf
mPlug_driver.value = f_half
f_halfDist = (matchValue-mPlug_driven.value)#Get dif
f_halfValue = mPlug_driven.value
log.debug("|{0}| >> minValue: {1} | halfValue: {3} | maxValue: {2} | current: {4}".format(_str_func,f_minValue,f_maxValue,f_halfValue,currentDriven))
log.debug("|{0}| >> minDist: {1} | halfDist: {3} | maxDist: {2} | | currentDist: {4}".format(_str_func,f_minDist,f_maxDist,f_halfDist,f_currentDist))
log.debug("|{0}| >> baseStep: {1} | halfStep: {3} | endStep: {2} | ".format(_str_func,f_stepBase,f_stepEnd,f_stepHalf))
if matchValue > f_minValue and matchValue < f_maxValue:
log.debug("|{0}| >> Between...".format(_str_func))
#(minStep *_mult)
if matchValue < f_halfValue:
log.debug("|{0}| >> Less than half".format(_str_func))
f_stepBase = f_stepBase
f_stepEnd = f_stepHalf
elif matchValue > f_halfValue:
log.debug("|{0}| >> more than half".format(_str_func))
f_stepBase = f_stepHalf
f_stepEnd = f_stepBase + (_stepBig)
else:
f_stepBase = f_stepBase + (_stepSmall)
_stepBig = _stepBig/2.0
#minStep = f_lastValue + minStep
elif matchValue > f_maxValue:
log.debug("|{0}| >> Greater".format(_str_func))
_dir = 'up'
_mult = 1
_stepBig = 10
f_stepBase = f_stepEnd
f_stepEnd = f_stepEnd + (_stepBig)
elif matchValue < f_minValue:
log.debug("|{0}| >> Less...".format(_str_func))
_dir = 'dn'
_stepBig = -10
f_stepBase = f_stepBase + (_stepBig)
f_stepEnd = f_stepBase + (_stepBig)
else:
raise ValueError,"nope"
f_closest = f_stepBase
#Old method
"""
mPlug_driver.value = minValue#Set to min
f_minDist = abs(matchValue-mPlug_driven.value)#get Dif
f_minSetValue = mPlug_driven.value
mPlug_driver.value = maxValue#Set to max
f_maxDist = abs(matchValue-mPlug_driven.value)#Get dif
f_maxSetValue = mPlug_driven.value
f_half = ((maxValue-minValue)/2.0) + minValue#get half
#First find range
if not MATH.is_float_equivalent(matchValue,0) and not MATH.is_float_equivalent(minValue,0) and not MATH.is_float_equivalent(f_minSetValue,0):
#if none of our values are 0, this is really fast
minValue = (minValue * matchValue)/f_minSetValue
log.debug("matchValue_iterator>>> Equated: %s"%minValue)
f_closest = f_minDist
mPlug_driver.value = minValue#Set to min
elif b_firstIter:
log.debug("matchValue_iterator>>> first iter. Trying matchValue: %s"%minValue)
b_firstIter = False
minValue = matchValue
f_closest = f_minDist
elif f_minSetValue > matchValue or f_maxSetValue < matchValue:
log.debug("matchValue_iterator>>> Finding Range....")
if matchValue < mPlug_driven.value:
#Need to shift our range down
log.debug("matchValue_iterator>>> Down range: minSetValue: %s"%f_minSetValue)
f_baseValue = f_maxDist
minValue = f_baseValue - f_minDist
maxValue = f_baseValue + f_minDist
f_closest = f_minDist
elif matchValue > mPlug_driven.value:
#Need to shift our range up
log.debug("matchValue_iterator>>> Up range: maxSetValue: %s"%f_maxSetValue)
f_baseValue = f_minDist
minValue = f_baseValue - f_maxDist
maxValue = f_baseValue + f_maxDist
f_closest = f_maxDist
else:
if f_minDist>f_maxDist:#if min dif greater, use half as new min
if f_half < minIn:f_half = minIn
minValue = f_half
#log.debug("matchValue_iterator>>>Going up")
f_closest = f_minDist
else:
if f_half > maxIn:f_half = maxIn
maxValue = f_half
#log.debug("matchValue_iterator>>>Going down")
f_closest = f_maxDist"""
#log.debug("matchValue_iterator>>>f1: %s | f2: %s | f_half: %s"%(f_minDist,f_maxDist,f_half))
#log.debug("#"+'-'*50)
if f_closest == f_lastClosest:
cnt_sameValue +=1
if cnt_sameValue >3:
log.error("matchValue_iterator>>> Value unchanged. Bad Driver. lastValue: %s | currentValue: %s"%(f_lastValue,mPlug_driven.value))
break
else:
cnt_sameValue = 0
f_lastClosest = f_closest
else:
log.warning("matchValue_iterator>>> driven mode not implemented with value mode: %s"%__drivenMode__)
break
#>>>>>matchObjMode
elif __matchMode__ == 'matchObj':
pos_match = mc.xform(mi_matchObj.mNode, q=True, ws=True, rp=True)
pos_driven = mc.xform(mi_drivenObj.mNode, q=True, ws=True, rp=True)
log.debug("matchValue_iterator>>> min: %s | max: %s | pos_match: %s | pos_driven: %s"%(minValue,maxValue,pos_match,pos_driven))
if MATH.is_vector_equivalent(pos_match,pos_driven,2):
log.debug("matchValue_iterator>>> Match found: %s <<pos>> %s | %s: %s | step: %s"%(mi_matchObj.getShortName(),mi_drivenObj.getShortName(),mPlug_driver.p_combinedShortName,minValue,i))
b_matchFound = mPlug_driver.value
break
mPlug_driver.value = minValue#Set to min
pos_min = mc.xform(mi_drivenObj.mNode, q=True, ws=True, rp=True)
#f_minDist = MATH.mag( MATH.list_subtract(pos_match,pos_min))#get Dif
f_minDist = distance.returnDistanceBetweenObjects(mi_drivenObj.mNode,mi_matchObj.mNode)
mPlug_driver.value = maxValue#Set to max
pos_max = mc.xform(mi_drivenObj.mNode, q=True, ws=True, rp=True)
f_maxDist = distance.returnDistanceBetweenObjects(mi_drivenObj.mNode,mi_matchObj.mNode)
f_half = ((maxValue-minValue)/2.0) + minValue#get half
if f_minDist>f_maxDist:#if min dif greater, use half as new min
minValue = f_half
f_closest = f_minDist
else:
maxValue = f_half
f_closest = f_maxDist
if f_minDist==f_maxDist:
minValue = minValue + .1
if f_closest == f_lastClosest:
cnt_sameValue +=1
if cnt_sameValue >3:
log.error("matchValue_iterator>>> Value unchanged. Bad Driver. lastValue: %s | currentValue: %s"%(f_lastValue,mPlug_driver.value))
break
else:
cnt_sameValue = 0
f_lastClosest = f_closest
log.debug("matchValue_iterator>>>f1: %s | f2: %s | f_half: %s"%(f_minDist,f_maxDist,f_half))
log.debug("#"+'-'*50)
else:
log.warning("matchValue_iterator>>> matchMode not implemented: %s"%__matchMode__)
break
#>>> Check autokey back on
if b_autoFrameState:
mc.autoKeyframe(state = True)
if b_matchFound is not None:
return b_matchFound
#log.warning("matchValue_iterator>>> Failed to find value for: %s"%mPlug_driven.p_combinedShortName)
return False
def blendChainsBy(l_jointChain1 = None,
l_jointChain2 = None,
l_blendChain = None,
driver = None,
l_constraints = ['point','orient'],
d_scale = {},
d_point = {},
d_parent = {},
d_orient = {},
maintainOffset = False):
"""
:parameters:
l_jointChain1 - First set of objects
l_jointChain2 - Second set of objects
l_blendChain - blend set
driver - Attribute to drive our blend
l_constraints - constraints to be driven by the setup. Default is ['point','orient']
:returns:
:raises:
Exception | if reached
"""
_str_func = 'blendChainsBy'
d_funcs = {'point':mc.pointConstraint,
'orient':mc.orientConstraint,
'scale':mc.scaleConstraint,
'parent':mc.parentConstraint}
for c in l_constraints:
if c not in ['point','orient','scale','parent']:
log.warning("|{0}| >> Bad constraint arg. Removing: {1}".format(_str_func, c))
l_constraints.remove(c)
if not l_constraints:
raise StandardError,"Need valid constraints"
ml_jointChain1 = cgmMeta.validateObjListArg(l_jointChain1,'cgmObject',noneValid=False)
ml_jointChain2 = cgmMeta.validateObjListArg(l_jointChain2,'cgmObject',noneValid=False)
ml_blendChain = cgmMeta.validateObjListArg(l_blendChain,'cgmObject',noneValid=False)
d_driver = cgmMeta.validateAttrArg(driver,noneValid=True)
d_blendReturn = {}
mi_driver = False
if d_driver:
mi_driver = d_driver.get('mi_plug') or False
else:
raise ValueError,"Invalid driver: {0}".format(driver)
if not len(ml_jointChain1) >= len(ml_blendChain) or not len(ml_jointChain2) >= len(ml_blendChain):
raise StandardError,"Joint chains aren't equal lengths: l_jointChain1: %s | l_jointChain2: %s | l_blendChain: %s"%(len(l_jointChain1),len(l_jointChain2),len(l_blendChain))
ml_nodes = []
#>>> Actual meat ===========================================================
_creates = []
for i,i_jnt in enumerate(ml_blendChain):
log.debug(i_jnt)
for constraint in l_constraints:
_d = {}
if constraint == 'scale':
_d = d_scale
"""
log.debug("connectBlendChainByConstraint>>> %s || %s = %s | %s"%(ml_jointChain1[i].mNode,
ml_jointChain2[i].mNode,
ml_blendChain[i].mNode,
constraint))"""
_buff = d_funcs[constraint]([ml_jointChain2[i].mNode,ml_jointChain1[i].mNode],
ml_blendChain[i].mNode,
maintainOffset = maintainOffset,**_d)
#func = getattr(mc,'{0}Constraint'.format(constraint))
#_buff = func([ml_jointChain2[i].mNode,ml_jointChain1[i].mNode],
# ml_blendChain[i].mNode,
# maintainOffset = maintainOffset,**_d)
_creates.append(_buff)
mConst = cgmMeta.cgmNode(_buff[0])
if constraint in ['parent','orient']:
mConst.interpType = 2
targetWeights = d_funcs[constraint](mConst.mNode,q=True, weightAliasList=True)
if len(targetWeights)>2:
raise StandardError,"Too many weight targets: obj: %s | weights: %s"%(i_jnt.mNode,targetWeights)
if mi_driver:
d_blendReturn = NODEFACTORY.createSingleBlendNetwork(mi_driver,
[mConst.mNode,'result_%s_%s'%(constraint,ml_jointChain1[i].getBaseName())],
[mConst.mNode,'result_%s_%s'%(constraint,ml_jointChain2[i].getBaseName())],
keyable=True)
#Connect
d_blendReturn['d_result1']['mi_plug'].doConnectOut('%s.%s' % (mConst.mNode,targetWeights[0]))
d_blendReturn['d_result2']['mi_plug'].doConnectOut('%s.%s' % (mConst.mNode,targetWeights[1]))
ml_nodes.append(mConst)
d_blendReturn['ml_nodes'] = ml_nodes
#pprint.pprint(vars())
return d_blendReturn
NodeF.argsToNodes(arg_forwardBack).doBuild()
if self._addMirrorAttributeBridges:
for l_bridge in self._addMirrorAttributeBridges:
_attrName = VALID.stringArg(l_bridge[0])
_attrToBridge = VALID.stringArg(l_bridge[1])
if not self.mi_control.hasAttr(_attrToBridge):
raise StandardError, "['%s' lacks the bridge attr '%s']" % (
self.mi_control.p_nameShort, _attrToBridge)
mPlug_attrBridgeDriver = cgmMeta.cgmAttr(self.mi_control,
_attrName,
attrType='float',
keyable=True)
try:
mPlug_attrBridgeDriven = cgmMeta.validateAttrArg(
[self.mi_control, _attrToBridge])['mi_plug']
except Exception, error:
raise StandardError, "[validate control attribute bridge attr]{%s}" % (
error)
if self.str_mirrorSide.lower() == 'right':
arg_attributeBridge = "%s = -%s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
else:
arg_attributeBridge = "%s = %s" % (
mPlug_attrBridgeDriven.p_combinedShortName,
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
]:
m1 = r9Meta.MetaClass(m).doRig()
reload(rigging)
from cgm.lib import attributes
attributes.doBreakConnection('l_wrist_fk_anim', 'inverseScale')
i_rig.buildModule.__build__(i_rig)
m1.rigConnect()
m1.rig_getReport()
i_rig = Rig.go(m1, forceNew=False, autoBuild=False) #call to do general rig
m1.setState('skeleton', forceNew=True)
m1.doRig()
i_rig = Rig.go(m1, forceNew=False) #call to do general rig
m1.templateNull.handles
reload(Rig)
range(4, 5)
cgmMeta.validateAttrArg([i_rig._i_rigNull.controlIK, 'length'],
noneValid=False)
m1.rigNull.controlIK.select()
i_rig.build(i_rig, buildTo='')
i_rig.build(i_rig, buildTo='skeleton')
i_rig.build(i_rig, buildTo='shapes')
i_rig.build(i_rig, buildTo='controls')
i_rig.buildModule.build_rigSkeleton(i_rig)
i_rig.buildModule.build_shapes(i_rig)
i_rig.buildModule.build_controls(i_rig)
i_rig.buildModule.build_FKIK(i_rig)
i_rig.buildModule.build_deformation(i_rig)
i_rig.buildModule.build_rig(i_rig)
i_rig.buildModule.__build__(i_rig)
from cgm.lib import distance
l_constrainTargetJoints = [
u'l_left_index_1_blend_jnt', u'l_left_index_2_blend_jnt',
