def mirror_controlShape(source=None,
target=None,
colorDirection='right',
controlType='main'):
_str_func = "mirror_controlShape"
if target is None:
_sel = mc.ls(sl=True)
if len(_sel) == 2:
return mirror_controlShape(_sel[0], _sel[1])
if not source:
raise ValueError, "|{0}| >> Must have a source".format(_str_func)
if not target:
raise ValueError, "|{0}| >> Must have a target".format(_str_func)
_dup_curve = mc.duplicate(source)[0]
for child in TRANS.children_get(_dup_curve, True):
mc.delete(child)
ATTR.set_standardFlags(_dup_curve, lock=False, keyable=True, visible=True)
_grp = mc.group(em=True)
_dup_curve = TRANS.parent_set(_dup_curve, _grp)
ATTR.set(_grp, 'scaleX', -1)
_dup_curve = TRANS.parent_set(_dup_curve, False)
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=False)
return
shapeParent_in_place(target, _dup_curve, True, True)
mc.delete(_grp)
colorControl(target, colorDirection, controlType)
mc.select(target)
return target
def define(self):
_short = self.mNode
ATTR.set(_short, 'translate', [0, 0, 0])
ATTR.set(_short, 'rotate', [0, 0, 0])
ATTR.set_standardFlags(self.mNode,
attrs=['translate', 'rotate', 'sx', 'sz'])
for a in ['x', 'z']:
ATTR.connect("{0}.sy".format(_short), "{0}.s{1}".format(_short, a))
ATTR.set_alias(_short, 'sy', 'blockScale')
def groups_verify(self):
try:
_str_func = "groups_verify".format()
log.debug("|{0}| >> ...".format(_str_func))
mMasterNull = self.masterNull
if not mMasterNull:
raise ValueError, "No masterNull"
for attr in [
'rig', 'deform', 'noTransform', 'geo', 'skeleton', 'parts',
'worldSpaceObjects', 'puppetSpaceObjects'
]:
_link = attr + 'Group'
mGroup = mMasterNull.getMessage(_link,
asMeta=True) # Find the group
if mGroup: mGroup = mGroup[0]
if not mGroup:
mGroup = mMasterNull.doCreateAt(setClass=True)
mGroup.connectParentNode(mMasterNull.mNode, 'puppet',
attr + 'Group')
mGroup.rename(attr)
log.debug("|{0}| >> attr: {1} | mGroup: {2}".format(
_str_func, attr, mGroup))
# Few Case things
#----------------------------------------------------
if attr in ['rig', 'geo', 'skeleton']:
mGroup.p_parent = mMasterNull
elif attr in ['deform', 'puppetSpaceObjects'
] and self.getMessage('masterControl'):
mGroup.p_parent = self.getMessage('masterControl')[0]
else:
mGroup.p_parent = mMasterNull.rigGroup
ATTR.set_standardFlags(mGroup.mNode)
if attr == 'worldSpaceObjects':
mGroup.addAttr('cgmAlias', 'world')
elif attr == 'puppetSpaceObjects':
mGroup.addAttr('cgmAlias', 'puppet')
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
mPlug_attrBridgeDriver.p_combinedShortName)
mPlug_attrBridgeDriven.p_locked = True
mPlug_attrBridgeDriven.p_hidden = True
mPlug_attrBridgeDriven.p_keyable = False
NodeF.argsToNodes(arg_attributeBridge).doBuild()
#lock N Hide ============================================================================================
if mi_control.hasAttr('visibility'):
mi_control.visibility = True
if autoLockNHide:
if mi_control.hasAttr('cgmTypeModifier'):
if mi_control.cgmTypeModifier.lower() == 'fk':
ATTR.set_standardFlags(
mi_control.mNode,
attrs=['tx', 'ty', 'tz', 'sx', 'sy', 'sz'])
if mi_control.cgmName.lower() == 'cog':
ATTR.set_standardFlags(mi_control.mNode,
attrs=['sx', 'sy', 'sz'])
cgmMeta.cgmAttr(mi_control, 'visibility', lock=True, hidden=True)
if mi_control.hasAttr('cgmIterator'):
ATTR.set_standardFlags(mi_control.mNode, attrs=['cgmIterator'])
str_base = mi_control.p_nameBase
for i, mShape in enumerate(mi_control.getShapes(asMeta=True)):
mShape.rename("{0}_shape_{1}".format(str_base, i))
#mShape.doName()
#return ============================================================================================
// Warning: line 0: Unrecognized node type for node 'ProductionRapidFur'; preserving node information during this session. //
// Warning: line 0: Unrecognized node type for node 'ProductionRapidHair'; preserv
#Finger unlock -----------------------------------------------------------------
import cgm.core.cgm_Meta as cgmMeta
import cgm.core.lib.attribute_utils as ATTR
import maya.cmds as mc
for m in 'l_thumb_part','l_index_part','l_middle_part','l_ring_part','l_pinky_part','r_thumb_part','r_index_part','r_middle_part','r_ring_part','r_pinky_part':
m1 = cgmMeta.asMeta(m)
ml_blend = m1.rigNull.msgList_get('blendJoints')
ml_fk = m1.rigNull.msgList_get('fkJoints')
ml_ik = m1.rigNull.msgList_get('ikJoints')
for mJnt in ml_fk:
ATTR.set_standardFlags(mJnt.mNode,visible=True,keyable=True,lock=False)
try:ATTR.break_connection(mJnt.mNode,'translateZ')
except:pass
for i,mJnt in enumerate(ml_blend):
mJnt.segmentScaleCompensate = False
ATTR.set_standardFlags(mJnt.mNode,['scale'],visible=True,keyable=True,lock=False)
mc.scaleConstraint([ml_fk[i].mNode], mJnt.mNode)
m1 = cgmMeta.asMeta('l_thumb_part')
#Tassel control simplification --------------------------------------------------
import cgm.core.lib.transform_utils as TRANS
sel = mc.ls(sl=True)
import cgm.core.lib.math_utils as MATH
MODULECONTROL.register(mControl,
addDynParentGroup=True,
mirrorSide='Centre',
mirrorAxis="translateX,rotateY,rotateZ")
mControl.masterGroup.parent = mPuppet.masterNull.deformGroup
mMasterControl.controlVis.addAttr('rootMotionControl',
value=True,
keyable=False)
mMasterControl.rootMotionControl = 0
mControl.doConnectIn(
'v', "{0}.rootMotionControl".format(
mMasterControl.controlVis.mNode))
ATTR.set_standardFlags(mControl.mNode, ['v'])
#DynParent group ====================================================================
ml_dynParents = [
mMasterNull.puppetSpaceObjectsGroup,
mMasterNull.worldSpaceObjectsGroup
]
#mMasterGroup = mMasterControl.masterGroup
#ml_dynParents.append(mMasterGroup)
#Add our parents
mDynGroup = mControl.dynParentGroup
log.debug("|{0}| >> Motion Joint | dynParentSetup : {1}".format(
_str_func, mDynGroup))
mDynGroup.dynMode = 0
def rig_cleanUp(self):
try:
_short = self.d_block['shortName']
_str_func = 'rig_cleanUp'.format(_short)
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
log.debug("{0}".format(self))
#_start = time.clock()
mBlock = self.mBlock
mMasterControl = self.d_module['mMasterControl']
mMasterDeformGroup = self.d_module['mMasterDeformGroup']
mMasterNull = self.d_module['mMasterNull']
mPlug_globalScale = self.d_module['mPlug_globalScale']
_spacePivots = mBlock.numSpacePivots
ml_controlsAll = []
#MasterControl =======================================================================
log.debug(
"|{0}| >> MasterConrol | dynParent setup...".format(_str_func))
#reload(MODULECONTROL)
if not _spacePivots:
mConstrainGroup = mMasterControl.doGroup(True,
True,
asMeta=True,
typeModifier='constrain')
mConstrainGroup.addAttr(
'cgmAlias', '{0}_constrain'.format(mMasterNull.puppet.cgmName))
else:
MODULECONTROL.register(mMasterControl,
addDynParentGroup=True,
addSpacePivots=_spacePivots,
mirrorSide='Centre',
mirrorAxis="translateX,rotateY,rotateZ",
noFreeze=True)
mMasterControl.masterGroup.setAttrFlags()
ml_dynParents = [mMasterNull]
ml_spacePivots = mMasterControl.msgList_get('spacePivots',
asMeta=True)
for mPivot in ml_spacePivots:
mDup = mPivot.doDuplicate(po=False)
mDup.scale = .25, .25, .25
CORERIG.shapeParent_in_place(mPivot.mNode, mDup.mNode, False,
True)
ml_dynParents.extend(ml_spacePivots)
mDynGroup = mMasterControl.dynParentGroup
mDynGroup.dynMode = 0
for o in ml_dynParents:
mDynGroup.addDynParent(o)
mDynGroup.rebuild()
#mMasterGroup = mMasterControl.masterGroup
#ml_dynParents.append(mMasterGroup)
#Add our parents
mPuppet = mBlock.moduleTarget
#Motion Joint ==========================================================================
if mBlock.addMotionJoint:
if not skeleton_check(mBlock):
skeleton_build(mBlock)
mRootMotionHelper = mBlock.rootMotionHelper
mMasterNull = mPuppet.masterNull
#Make joint =================================================================
mJoint = mBlock.moduleTarget.getMessage('rootJoint',
asMeta=True)[0]
mJoint.p_parent = mBlock.moduleTarget.masterNull.skeletonGroup
#Make the handle ===========================================================
log.debug("|{0}| >> Motion Joint | Main control shape...".format(
_str_func))
mControl = mRootMotionHelper.doCreateAt()
CORERIG.shapeParent_in_place(mControl, mRootMotionHelper.mNode,
True)
mControl = cgmMeta.validateObjArg(mControl,
'cgmObject',
setClass=True)
mControl.parent = False
#ATTR.copy_to(mBlock.moduleTarget.mNode,'cgmName',mControl.mNode,driven='target')
mControl.doStore('cgmName', 'rootMotion')
mControl.doName()
#Color ---------------------------------------------------------------
log.debug("|{0}| >> Motion Joint | Color...".format(_str_func))
#_side = mBlock.atBlockUtils('get_side')
#CORERIG.colorControl(mControl.mNode,_side,'main')
#Register ------------------------------------------------------------
log.debug("|{0}| >> Motion Joint | Register...".format(_str_func))
MODULECONTROL.register(mControl,
addDynParentGroup=True,
mirrorSide='Centre',
mirrorAxis="translateX,rotateY,rotateZ")
mControl.masterGroup.parent = mPuppet.masterNull.deformGroup
mMasterControl.controlVis.addAttr('rootMotionControl',
value=True,
keyable=False)
mMasterControl.rootMotionControl = 0
mControl.doConnectIn(
'v', "{0}.rootMotionControl".format(
mMasterControl.controlVis.mNode))
ATTR.set_standardFlags(mControl.mNode, ['v'])
#DynParent group ====================================================================
ml_dynParents = [
mMasterNull.puppetSpaceObjectsGroup,
mMasterNull.worldSpaceObjectsGroup
]
#mMasterGroup = mMasterControl.masterGroup
#ml_dynParents.append(mMasterGroup)
#Add our parents
mDynGroup = mControl.dynParentGroup
log.debug("|{0}| >> Motion Joint | dynParentSetup : {1}".format(
_str_func, mDynGroup))
mDynGroup.dynMode = 0
for o in ml_dynParents:
mDynGroup.addDynParent(o)
mDynGroup.rebuild()
#>>>>> INDEX CONTROLS
#>>>>> Setup VIS
mJoint.connectChildNode(mControl.mNode, 'rigJoint', 'sourceJoint')
"""
mc.parentConstraint(mControl.mNode,
mJoint.mNode,
maintainOffset = True)
mc.scaleConstraint(mControl.mNode,
mJoint.mNode,
maintainOffset = True)
"""
ml_controlsAll.append(mControl)
mPuppet.connectChildNode(mControl, 'rootMotionHandle',
'puppet') #Connect
mMasterControl.connectChildNode(mControl, 'rootMotionHandle',
'puppet') #Connect
for mCtrl in ml_controlsAll:
if mCtrl.hasAttr('radius'):
ATTR.set(mCtrl.mNode, 'radius', 0)
ml_pivots = mCtrl.msgList_get('spacePivots')
if ml_pivots:
log.debug("|{0}| >> Coloring spacePivots for: {1}".format(
_str_func, mCtrl))
for mPivot in ml_pivots:
mHandleFactory.color(mPivot.mNode, controlType='sub')
ml_controlsAll.append(mPivot)
#Connect -------------------------------------------------------------
mPuppet.msgList_connect('controlsAll', ml_controlsAll)
mPuppet.puppetSet.extend(ml_controlsAll)
#self.atBuilderUtils('register_mirrorIndices', ml_controlsAll)
self.atBuilderUtils('check_nameMatches', ml_controlsAll)
#Connections =======================================================================================
#ml_controlsAll = mBlock.atBuilderUtils('register_mirrorIndices', ml_controlsAll)
#mRigNull.msgList_connect('controlsAll',ml_controlsAll)
#mRigNull.moduleSet.extend(ml_controlsAll)
self.v = 0
#mRigNull.version = self.d_block['buildVersion']
#mRigNull.version = __version__
mBlock.blockState = 'rig'
mBlock.template = True
mBlock.noTransFormNull.template = True
self.UTILS.rigNodes_store(self)
self.version = self.d_block['buildVersion']
mMasterControl.doStore('version', self.d_block['buildVersion'])
#log.info("|{0}| >> Time >> = {1} seconds".format(_str_func, "%0.3f"%(time.clock()-_start)))
#except Exception,err:cgmGEN.cgmExceptCB(Exception,err)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def create_axisProxy(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_axisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(obj)
if VALID.is_shape(obj):
l_shapes = [obj]
else:
l_shapes = TRANS.shapes_get(_dag, True)
_parent = TRANS.parent_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#TRANS.pivots_recenter(_dup)
_dup = TRANS.parent_set(_dup, False)
ATTR.set_standardFlags(_dup, lock=False, keyable=True)
#Get some values...
l_reset = ['t', 'r', 's', 'shear', 'rotateAxis']
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
ra = ATTR.get(_dup, 'rotateAxis')
if ATTR.has_attr(_dup, 'jointOrient'):
l_reset.append('jointOrient')
jo = ATTR.get(_dup, 'jointOrient')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
ATTR.reset(_dup, l_reset)
_size = POS.get_bb_size(_dup, True)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
#Now Put it back
_dup = TRANS.parent_set(_dup, TRANS.parent_get(_dag))
_proxy = TRANS.parent_set(_proxy, _dup)
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
#ATTR.set(_dup,'s',(0,0,0))
ATTR.reset(_dup, ['s', 'shear'])
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
_proxy = TRANS.parent_set(_proxy, _dag)
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
#match_transform(_proxy,_dag)
#SNAP.go(_proxy,_dag,pivot='bb')
#cgmGEN.func_snapShot(vars())
_proxy = TRANS.parent_set(_proxy, False)
mc.delete(_dup)
#match_transform(_proxy,_dag)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def shapeParent_in_place(obj,
shapeSource,
keepSource=True,
replaceShapes=False,
snapFirst=False):
"""
Shape parent a curve in place to a obj transform
:parameters:
obj(str): Object to modify
shapeSource(str): Curve to shape parent
keepSource(bool): Keep the curve shapeParented as well
replaceShapes(bool): Whether to remove the obj's original shapes or not
snapFirst(bool): whether to snap source to obj before transfer
:returns
success(bool)
"""
_str_func = 'shapeParent_in_place'
l_shapes = VALID.listArg(shapeSource)
obj = VALID.mNodeString(obj)
log.debug(
"|{0}| >> obj: {1} | shapeSource: {2} | keepSource: {3} | replaceShapes: {4}"
.format(_str_func, obj, shapeSource, keepSource, replaceShapes))
if replaceShapes:
_l_objShapes = mc.listRelatives(obj, s=True, fullPath=True)
if _l_objShapes:
log.debug("|{0}| >> Removing obj shapes...| {1}".format(
_str_func, _l_objShapes))
mc.delete(_l_objShapes)
mc.select(cl=True)
#mc.refresh()
for c in l_shapes:
try:
_shapeCheck = SEARCH.is_shape(c)
if not _shapeCheck and not mc.listRelatives(
c, f=True, shapes=True, fullPath=True):
raise ValueError, "Has no shapes"
if coreNames.get_long(obj) == coreNames.get_long(c):
raise ValueError, "Cannot parentShape self"
if VALID.get_mayaType(c) == 'nurbsCurve':
mc.ls(['%s.ep[*]' % (c)], flatten=True)
#This is for a really weird bug in 2016 where offset curve shapes don't work right unless they're components are queried.
if _shapeCheck:
_dup_curve = duplicate_shape(c)[0]
log.debug("|{0}| >> shape duplicate".format(_str_func))
if snapFirst:
SNAP.go(_dup_curve, obj)
else:
log.debug("|{0}| >> regular duplicate".format(_str_func))
_dup_curve = mc.duplicate(c)[0]
for child in TRANS.children_get(_dup_curve, True):
mc.delete(child)
if snapFirst:
SNAP.go(_dup_curve, obj)
_l_parents = SEARCH.get_all_parents(obj)
ATTR.set_standardFlags(_dup_curve,
lock=False,
visible=True,
keyable=True)
_dup_curve = parent_set(_dup_curve, False)
copy_pivot(_dup_curve, obj)
#piv_pos = mc.xform(obj, q=True, ws=True, rp = True)
#mc.xform(_dup_curve,ws=True, rp = piv_pos)
pos = mc.xform(obj, q=True, os=True, rp=True)
curveScale = mc.xform(_dup_curve, q=True, s=True, r=True)
objScale = mc.xform(obj, q=True, s=True, r=True)
#account for freezing
#mc.makeIdentity(_dup_curve,apply=True,translate =True, rotate = True, scale=False)
# make our zero out group
#group = rigging.groupMeObject(obj,False)
group = create_at(obj, 'null')
_dup_curve = mc.parent(_dup_curve, group)[0]
# zero out the group
mc.xform(group, ws=True, t=pos)
#mc.xform(group,roo = 'xyz', p=True)
mc.xform(group, ra=[0, 0, 0], p=False)
mc.xform(group, ro=[0, 0, 0], p=False)
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=False)
#main scale fix
baseMultiplier = [0, 0, 0]
baseMultiplier[0] = (curveScale[0] / objScale[0])
baseMultiplier[1] = (curveScale[1] / objScale[1])
baseMultiplier[2] = (curveScale[2] / objScale[2])
mc.setAttr(_dup_curve + '.sx', baseMultiplier[0])
mc.setAttr(_dup_curve + '.sy', baseMultiplier[1])
mc.setAttr(_dup_curve + '.sz', baseMultiplier[2])
#parent scale fix
if _l_parents:
_l_parents.reverse()
multiplier = [
baseMultiplier[0], baseMultiplier[1], baseMultiplier[2]
]
for p in _l_parents:
scaleBuffer = mc.xform(p, q=True, s=True, r=True)
multiplier[0] = ((multiplier[0] / scaleBuffer[0]))
multiplier[1] = ((multiplier[1] / scaleBuffer[1]))
multiplier[2] = ((multiplier[2] / scaleBuffer[2]))
mc.setAttr(_dup_curve + '.sx', multiplier[0])
mc.setAttr(_dup_curve + '.sy', multiplier[1])
mc.setAttr(_dup_curve + '.sz', multiplier[2])
_dup_curve = parent_set(_dup_curve, False)
mc.delete(group)
#freeze for parent shaping
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=True)
shape = mc.listRelatives(_dup_curve,
f=True,
shapes=True,
fullPath=True)
mc.parent(shape, obj, add=True, shape=True)
mc.delete(_dup_curve)
if not keepSource:
mc.delete(c)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
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()
#lock N Hide ============================================================================================
if mi_control.hasAttr('visibility'):
mi_control.visibility = True
if autoLockNHide:
if mi_control.hasAttr('cgmTypeModifier'):
if mi_control.cgmTypeModifier.lower() == 'fk':
ATTR.set_standardFlags(mi_control.mNode,attrs=['tx','ty','tz','sx','sy','sz'])
if mi_control.cgmName.lower() == 'cog':
ATTR.set_standardFlags(mi_control.mNode,attrs=['sx','sy','sz'])
cgmMeta.cgmAttr(mi_control,'visibility',lock=True,hidden=True)
if mi_control.hasAttr('cgmIterator'):
ATTR.set_standardFlags(mi_control.mNode,attrs=['cgmIterator'])
str_base = mi_control.p_nameBase
for i,mShape in enumerate(mi_control.getShapes(asMeta=True)):
mShape.rename("{0}_shape_{1}".format(str_base,i))
#mShape.doName()
#return ============================================================================================
#pprint.pprint(vars())
return {'mObj':mi_control,'instance':mi_control,'ml_groups':ml_groups,'ml_constraintGroups':ml_constraintGroups}
except Exception,err: cgmGeneral.cgmExceptCB(Exception,err)
