def _validate(self): """ Validate the args, get our data """ self.mi_baseCurve = cgmMeta.validateObjArg(self.d_kws['baseCurve'],mayaType='nurbsCurve',noneValid=False) self.mi_targetCurve = cgmMeta.validateObjArg(self.d_kws['targetCurve'],mayaType='nurbsCurve',noneValid=True) self.f_threshold = cgmValid.valueArg(self.d_kws['mirrorThreshold'],calledFrom = self._str_funcCombined) self.str_mirrorAcross = cgmValid.stringArg(self.d_kws['mirrorAcross'],noneValid=True) self.int_across = 0#This is the index to check -- ie pos[0] for x if self.str_mirrorAcross.lower() != 'x': raise NotImplementedError, "Only implmeneted x mirror so far | kw: %s"%self.str_mirrorAcross
def _validate(self):
#>> validate ============================================================================
self.mi_crv = cgmMeta.validateObjArg(self.d_kws['crvToLoft'],cgmMeta.cgmObject,noneValid=False,mayaType = ['nurbsCurve'])
try:self.mi_target = cgmMeta.validateObjArg(self.d_kws['aimPointObject'],cgmMeta.cgmObject,noneValid=False)
except:
cgmValid.valueArg
#self._str_funcCombined = self._str_funcCombined + "(%s,%s)"%(self.mi_obj.p_nameShort,self.mi_targetSurface.p_nameShort)
self.f_offset = cgmValid.valueArg(self.d_kws['f_offset'], calledFrom=self._str_funcCombined)
self.d_info = {'l_eps':self.mi_crv.getComponents('ep'),
'l_cvs':self.mi_crv.getComponents('cv'),
'l_constraints':[],
'ml_locators':[],
'l_locPos':[]}
#Running Lists ============================================================================
self.md_return = {}
def __func__(self):
"""
"""
self.mi_baseCurve = cgmMeta.validateObjArg(self.d_kws['baseCurve'],mayaType='nurbsCurve',noneValid=False)
self._str_funcCombined = self._str_funcCombined + "(%s)"%self.mi_baseCurve.p_nameShort
self.str_arg = cgmValid.stringArg(self.d_kws['arg'],noneValid=True)
self.b_keepOriginal = cgmValid.boolArg(self.d_kws['keepOriginal'], calledFrom=self._str_funcCombined)
if isEP(self.mi_baseCurve):
log.warning("%s %s already an ep curve"%(self._str_reportStart,self.mi_baseCurve.p_nameShort))
return False
mi_crv = self.mi_baseCurve
if self.str_arg.lower() == 'ep':
l_pos = []
for cv in mi_crv.getComponents('cv'):
locatorName = locators.locMeObject(cv)
pos = distance.returnClosestUPosition(locatorName,mi_crv.mNode)
mc.delete(locatorName)
l_pos.append( pos )
if not self.b_keepOriginal:mi_crv.delete()
return mc.curve(d = 2,ep = l_pos, os = True)
#return curves.curveFromPosList(l_pos)
raise NotImplementedError,"arg: %s"%self.str_arg
def getUParamOnCurve(obj = None, crv = None):
"""
Props to Marco Giordano for this method. Oddly, the distance method is faster....
@Parameters
curve -- must be a curve instance or obj string
points -- number of points you want on the curve
returns param
"""
_str_funcName = 'getUParamOnCurve'
log.info(">>> %s >> "%_str_funcName + "="*75)
mi_obj = cgmValid.objString(obj)
mi_crv = cgmValid.objString(crv,mayaType='nurbsCurve')
mi_shape = cgmMeta.validateObjArg(mc.listRelatives(mi_crv,shapes = True)[0],mayaType='shape')
pos = mc.xform(mi_obj,q=True, t=True, ws=True)
point = OpenMaya.MPoint(pos[0],pos[1],pos[2])
#object.__getattribute__(self, "_MObject")
curveFN = OpenMaya.MFnNurbsCurve(mi_shape.__getattribute__("_MObject"))
paramUtil = OpenMaya.MScriptUtil()
paramPtr = paramUtil.asDoublePtr()
isOnCurve = curveFN.isPointOnCurve(point)
if isOnCurve:
curveFN.getParamAtPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject)
else:
point = curveFN.closestPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject)
curveFN.getParamAtPoint(point,paramPtr,0.001,OpenMaya.MSpace.kObject)
buffer = paramPtr
del(paramPtr)
return paramUtil.getDouble(buffer)
def duplicateJointInPlace(joint, asMeta = True):
"""
:parameters:
joint | str/instance
Joint to duplicate
asMeta | bool
What to return as
:returns:
str or instance of new joint
:raises:
TypeError | if 'arg' is not a joint
"""
_str_func_ = 'duplicateJointInPlace'
try:
mJoint = cgmMeta.validateObjArg(joint, mayaType = 'joint', mType = 'cgmObject')
#dup = mc.joint()
mDup = mJoint.doDuplicate(parentOnly=True)
#mDup.parent = mJoint.parent
#mc.delete(mc.parentConstraint(mJoint.mNode,mDup.mNode))
'''
('rotateOrder','rotateAxisX','rotateAxisY','rotateAxisZ',
'inheritsTransform','drawStyle','radius',
'jointTypeX','jointTypeY','jointTypeZ',
'stiffnessX','stiffnessY','stiffnessZ',
'preferredAngleX','preferredAngleY','preferredAngleZ',
'jointOrientX','jointOrientY','jointOrientZ','segmentScaleCompensate','showManipDefault',
'displayHandle','displayLocalAxis','selectHandleX','selectHandleY','selectHandleZ'),
'''
mDup.rotateOrder = mJoint.rotateOrder
mDup.jointOrient = mJoint.jointOrient
mDup.rotateAxis = mJoint.rotateAxis
mDup.inheritsTransform = mJoint.inheritsTransform
mDup.radius = mJoint.radius
mDup.stiffness = mJoint.stiffness
mDup.preferredAngle = mJoint.preferredAngle
mDup.segmentScaleCompensate = mJoint.segmentScaleCompensate
#mDup.displayHandle = mJoint.displayHandle
#mDup.selectHandle = mJoint.selectHandle
#Inverse scale...
mAttr_inverseScale = cgmMeta.cgmAttr(mJoint,'inverseScale')
_driver = mAttr_inverseScale.getDriver()
if mAttr_inverseScale.getDriver():
cgmMeta.cgmAttr(mDup,"inverseScale").doConnectIn(_driver)
mAttr_inverseScale.getDriver(mJoint)
for attr in mJoint.getUserAttrs():
cgmMeta.cgmAttr(mJoint,attr).doCopyTo(mDup.mNode)
if asMeta:
return mDup
return mDup.mNode
except Exception,error:
raise Exception,"{0} | {1}".format(_str_func_,error)
def _shapeParent(self):
shapeParentTo = self.d_kws['shapeParentTo']
if shapeParentTo:
try:
i_target = cgmMeta.validateObjArg(shapeParentTo,cgmMeta.cgmObject)
curves.parentShapeInPlace(i_target.mNode,self.mi_control.mNode)
i_target = cgmMeta.asMeta(i_target,'cgmControl',setClass = True)
#self.mi_control.delete()
self.mi_control = i_target#replace the control with the joint
except Exception,error:raise StandardError,"shapeParentTo | %s"%error
useShape = self.d_kws['useShape']
if useShape is not None:
try:
i_shape = cgmMeta.validateObjArg(useShape,cgmMeta.cgmObject,mayaType='nurbsCurve')
curves.parentShapeInPlace(self.mi_control.mNode,i_shape.mNode)
except Exception,error:raise StandardError,"useShape | %s"%error
def __func__(self):
"""
"""
self.mi_crv = cgmMeta.validateObjArg(self.d_kws['curve'],mayaType='nurbsCurve',noneValid=False)
self._str_funcCombined = self._str_funcCombined + "(%s)"%self.mi_crv.p_nameShort
l_cvs = self.mi_crv.getComponents('cv')
if len(l_cvs)-len(self.mi_crv.getComponents('ep')) < 2:
return True
else: return False
def createMeshSliceCurve(mesh, mi_obj,latheAxis = 'z',aimAxis = 'y+',
points = 12, curveDegree = 3, minRotate = None, maxRotate = None, rotateRange = None,
posOffset = 0, markHits = False,rotateBank = None, closedCurve = True, maxDistance = 1000,
initialRotate = 0, offsetMode = 'vector', midMeshCast = False,
l_specifiedRotates = None, closestInRange = True,
returnDict = False,axisToCheck = ['x','y'],**kws):
"""
This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits.
it then uses this information to build a curve shape.
:parameters:
mesh(string) | Surface to cast at
mi_obj(string/mObj) | our casting object
latheAxis(str) | axis of the objec to lathe TODO: add validation
aimAxis(str) | axis to shoot out of
points(int) | how many points you want in the curve
curveDegree(int) | specified degree
minRotate(float) | let's you specify a valid range to shoot
maxRotate(float) | let's you specify a valid range to shoot
posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface
markHits(bool) | whether to keep the hit markers
returnDict(bool) | whether you want all the infomation from the process.
rotateBank (float) | let's you add a bank to the rotation object
l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings
maxDistance(float) | max distance to cast rays
closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range.
:returns:
Dict ------------------------------------------------------------------
'source'(double3) | point from which we cast
'hit'(double3) | world space points | active during single return
'hits'(list) | world space points | active during multi return
'uv'(double2) | uv on surface of hit | only works for mesh surfaces
:raises:
Exception | if reached
"""
_str_funcName = 'createMeshSliceCurve'
try:
mi_obj = cgmMeta.validateObjArg(mi_obj,mType = cgmMeta.cgmObject, noneValid = True)
if not mi_obj:
return False
log.debug("mi_obj: {0}".format(mi_obj.mNode))
mesh = cgmValid.objStringList(mesh,['mesh','nurbsSurface'], calledFrom = _str_funcName)
#if len(mc.ls(mesh))>1:
#log.error("{0}>>> More than one mesh named. Using first: {1}".format(_str_funcName,mesh))
#mesh = mesh[0]
log.debug("mesh: {0}".format(mesh))
log.debug("points: {0}".format(points))
except Exception,error:
raise ValueError,"Validation fail | {0}".format(error)
def __func__(self):
"""
"""
self.f_factor = cgmValid.valueArg(self.d_kws['factor'],minValue=0,maxValue=1.0)
self.mi_crv = cgmMeta.validateObjArg(self.d_kws['curve'],mayaType='nurbsCurve',noneValid=False)
#self._str_funcCombined = self._str_funcCombined + "('{0}')".format(self.mi_crv.p_nameShort)
try:self.str_bufferU = mc.ls("{0}{1}".format(self.mi_crv.mNode,".u[*]"))[0]
except Exception,error:raise Exception,"ls fail | error: {0}".format(error)
self.f_maxU = float(self.str_bufferU.split(':')[-1].split(']')[0])
return mc.pointPosition("%s.u[%f]"%(self.mi_crv.mNode,self.f_maxU*self.f_factor), w=True)
def get_orientChild(targetJoint):
mi_targetJoint = cgmMeta.validateObjArg(targetJoint,cgmMeta.cgmObject,mayaType='joint')
ml_childrenJoints = cgmMeta.validateObjListArg(mi_targetJoint.getChildren(),cgmMeta.cgmObject,mayaType='joint')
if not ml_childrenJoints:
log.warning("%s.get_orientChild >> failed to find children joints to check"%(mi_targetJoint.p_nameShort))
return False
for i_j in ml_childrenJoints:
"""
Measure dist
"""
pass
def _gatherInfo_(self):
mi_go = self._go#Rig Go instance link
self.md_rigList = {}
self.mi_helper = cgmMeta.validateObjArg(mi_go._mi_module.getMessage('helper'),noneValid=True)
if not self.mi_helper:raise StandardError,"No suitable helper found"
try:#verify eye look
mi_go._verify_eyeLook()
except Exception,error: raise StandardError,"[Faied to verify eye look]{%s}"%error
#>> Find our joint lists ===================================================================
self.md_jointLists = {}
self.ml_rigJoints = mi_go._mi_module.rigNull.msgList_get('rigJoints')
self.md_rigList['eyeOrbJoint'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'eyeOrb')[0]
self.md_rigList['eyeJoint'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'eye')[0]
if self.mi_helper.buildIris:
self.md_rigList['irisJoint'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'iris')[0]
try:self.md_rigList['controlIris'] = mi_go._i_rigNull.controlIris
except Exception,error:raise StandardError,"iris fail]{%s}"%(error)
if self.mi_helper.buildPupil:
self.md_rigList['pupilJoint'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'pupil')[0]
try:self.md_rigList['controlPupil'] = mi_go._i_rigNull.controlPupil
except Exception,error:raise StandardError,"pupil fail]{%s}"%(error)
#>> Running lists ===========================================================================
try:self.md_rigList['eyeLook'] = mi_go._get_eyeLook()
except Exception,error:raise StandardError,"[eyeLook fail]{%s}"%(error)
try:self.md_rigList['controlIK'] = mi_go._i_rigNull.controlIK
except Exception,error:raise StandardError,"controlIK fail]{%s}"%(error)
try:self.md_rigList['controlFK'] = mi_go._i_rigNull.controlFK
except Exception,error:raise StandardError,"controlFK fail]{%s}"%(error)
try:self.md_rigList['settings'] = mi_go._i_rigNull.settings
except Exception,error:raise StandardError,"controlIK fail]{%s}"%(error)
try:self.md_rigList['eyeMove'] = mi_go._i_rigNull.eyeMove
except Exception,error:raise StandardError,"eyeMove fail]{%s}"%(error)
#Settings
self.mPlug_FKIK = cgmMeta.cgmAttr(self.md_rigList['settings'].mNode,'blend_FKIK')
def _validate(self):
#>> validate ============================================================================
self.mi_obj = cgmMeta.validateObjArg(self.d_kws['objToAttach'],cgmMeta.cgmObject,noneValid=False)
self.mi_targetSurface = cgmMeta.validateObjArg(self.d_kws['targetSurface'],mayaType='nurbsSurface',noneValid=False)
self.mi_orientation = cgmValid.simpleOrientation( self.d_kws['orientation'] )
self._str_funcCombined = self._str_funcCombined + "(%s,%s)"%(self.mi_obj.p_nameShort,self.mi_targetSurface.p_nameShort)
self.l_shapes = mc.listRelatives(self.mi_targetSurface.mNode,shapes=True)
if len(self.l_shapes)>1:
log.debug( "More than one shape found. Using 0. targetSurface : %s | shapes: %s"%(self.mi_targetSurface.p_nameShort,self.l_shapes) )
self.mi_shape = cgmMeta.validateObjArg(self.l_shapes[0],cgmMeta.cgmNode,noneValid=False)
self.b_createControlLoc = cgmValid.boolArg(self.d_kws['createControlLoc'],calledFrom=self._str_funcCombined)
self.b_createUpLoc = cgmValid.boolArg(self.d_kws['createUpLoc'],calledFrom=self._str_funcCombined)
self.b_parentToFollowGroup = cgmValid.boolArg(self.d_kws['parentToFollowGroup'],calledFrom=self._str_funcCombined)
self.b_attachControlLoc = cgmValid.boolArg(self.d_kws['attachControlLoc'],calledFrom=self._str_funcCombined)
self.b_connectOffset = cgmValid.boolArg(self.d_kws['connectOffset'],calledFrom=self._str_funcCombined)
self.b_pointAttach = cgmValid.boolArg(self.d_kws['pointAttach'],calledFrom=self._str_funcCombined)
self.f_offset = cgmValid.valueArg(self.d_kws['f_offset'], calledFrom=self._str_funcCombined)
#Get info ============================================================================
self.d_closestInfo = distance.returnClosestPointOnSurfaceInfo(self.mi_obj.mNode,self.mi_targetSurface.mNode)
#Running Lists ============================================================================
self.md_return = {}
def __init__(self,*args,**kws):
"""
"""
super(fncWrap, self).__init__(*args, **kws)
if args:self.mi_control = cgmMeta.validateObjArg(args[0],cgmMeta.cgmObject,noneValid=False)
try:self._str_funcName = "registerControl(%s)"%self.mi_control.p_nameShort
except:self._str_funcName = "registerControl"
self._l_ARGS_KWS_DEFAULTS = [{'kw':'controlObject', "default":None, 'help':"The object to use as a control", "argType":"mObject"},
{'kw':'copyTransform', "default":None, 'help':"Object to copy the transform of for our control object", "argType":"mObject"},
{'kw':'copyPivot', "default":None, 'help':"Object to copy the pivot of for our control object", "argType":"mObject"},
{'kw':'shapeParentTo',"default":None,'help':"Object to shape parent our control curve to to use that transform","argType":"mObject"},
{'kw':'useShape',"default":None,'help':"Object to use the curve shape of for our control","argType":"mObject"},
{'kw':'setRotateOrder',"default":None,'help':"Argument for a rotate order to set","argType":"rotateOrder"},
{'kw':'autoLockNHide',"default":None,'help':"Try to set lock and hide","argType":"bool"},
{'kw':'mirrorAxis',"default":None,'help':"Mirror axis to set - using red9's setup terms","argType":"string"},
{'kw':'mirrorSide',"default":None,'help':"Mirror side - using red9's setup terms","argType":"string/int"},
{'kw':'makeMirrorable',"default":True,'help':"Setup for mirrorability (using red9) -- implied by other mirror args","argType":"bool"},
{'kw':'addDynParentGroup',"default":False,'help':"Add a dynParent group setup"},
{'kw':'addExtraGroups',"default":False,'help':"Number of nested extra groups desired","argType":"int"},
{'kw':'addConstraintGroup',"default":False,'help':"If a group just above the control is desired for consraining","argType":"bool"},
{'kw':'freezeAll',"default":False,'help':"Freeze all transforms on the control object","argType":"bool"},
{'kw':'addSpacePivots',"default":False,'help':"Number of space pivots to generate and connect","argType":"int"},
{'kw':'controlType',"default":None,'help':"Tag for cgmType","argType":"string"},
{'kw':'typeModifier', "default":None, 'help':"Tag for cgmTypeModifier for naming", "argType":"string"},
{'kw':'addForwardBack',"default":None,'help':"Forward Back driver setup. Looking for an attribute to drive","argType":"mAttr"},
{'kw':'addMirrorAttributeBridges',"default":None,'help':"Attribute to drive the same channel on mirrored objects. Looking for an nested list [[attrName,attr],...]","argType":"nested list"},
{'kw':'aim',"default":None,'help':"aim axis to use","argType":"string/int"},
{'kw':'up',"default":None,'help':"up axis to use","argType":"string/int"},
{'kw':'out',"default":None,'help':"out axis to use","argType":"string/int"},
{'kw':'makeAimable',"default":False,'help':"Make object aimable -- implied by aim/up/out","argType":"mObject"},]
self.__dataBind__(*args,**kws)
#=================================================================
self.l_funcSteps = [{'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}]
def _gatherInfo_(self):
mi_go = self._go#Rig Go instance link
self.md_rigList = {}
self.str_mirrorSide = mi_go.verify_mirrorSideArg(mi_go._direction)#Get the mirror side, shakes fist @ "Centre"
self.mi_helper = cgmMeta.validateObjArg(mi_go._mi_module.getMessage('helper'),noneValid=True)
if not self.mi_helper:raise StandardError,"No suitable helper found"
if not mi_go.isShaped():
raise StandardError,"Needs shapes to build controls"
if not mi_go.isRigSkeletonized():
raise StandardError,"Needs shapes to build controls"
self.md_rigList['fk_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_eyeballFK'),cgmMeta.cgmObject)
self.md_rigList['ik_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_eyeballIK'),cgmMeta.cgmObject)
self.md_rigList['settings_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_settings'),cgmMeta.cgmObject)
self.md_rigList['eyeMove_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_eyeMove'),cgmMeta.cgmObject)
self.md_rigList['pupil_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_pupil'),cgmMeta.cgmObject)
self.md_rigList['iris_shape'] = cgmMeta.validateObjArg(mi_go._i_rigNull.getMessage('shape_iris'),cgmMeta.cgmObject)
#>> Find our joint lists ===================================================================
self.md_jointLists = {}
self.ml_rigJoints = mi_go._mi_module.rigNull.msgList_get('rigJoints')
self.md_rigList['eyeOrb'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'eyeOrb')[0]
self.md_rigList['eye'] = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'eye')[0]
l_pupil = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'pupil')
if l_pupil:
self.md_rigList['pupil'] = l_pupil[0]
else:
#self.md_rigList['pupil_shape'].delete()
self.md_rigList['pupil'] = False
l_iris = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName = 'iris')
if l_iris:
self.md_rigList['iris'] = l_iris[0]
else:
#self.md_rigList['iris_shape'].delete()
self.md_rigList['iris'] = False
#>> Running lists ===========================================================================
self.ml_directControls = []
self.ml_controlsAll = []
def ik_end(self,
ikEnd=None,
ml_handleTargets=None,
ml_rigJoints=None,
ml_fkShapes=None,
ml_ikJoints=None,
ml_fkJoints=None,
shapeArg=None):
try:
_str_func = 'ik_end'
#Mid IK...---------------------------------------------------------------------------------
log_start(_str_func)
mBlock = self.mBlock
ml_formHandles = self.ml_formHandles
if ml_handleTargets == None:
raise ValueError, "{0} | ml_handleTargets required".format(
_str_func)
if ikEnd == None:
ikEnd = mBlock.getEnumValueString('ikEnd')
if ml_formHandles[-1].getMessage('proxyHelper'):
log.debug("|{0}| >> proxyHelper IK shape...".format(_str_func))
mProxyHelper = ml_formHandles[-1].getMessage('proxyHelper',
asMeta=True)[0]
#bb_ik = mHandleFactory.get_axisBox_size(mProxyHelper.mNode)
bb_ik = POS.get_bb_size(mProxyHelper.mNode, True, mode='max')
_ik_shape = CURVES.create_fromName('cube', size=bb_ik)
ATTR.set(_ik_shape, 'scale', 1.5)
mIKShape = cgmMeta.validateObjArg(_ik_shape,
'cgmObject',
setClass=True)
mIKShape.doSnapTo(mProxyHelper)
pos_ik = POS.get_bb_center(mProxyHelper.mNode)
mIKShape.p_position = pos_ik
mIKCrv = ml_handleTargets[self.int_handleEndIdx].doCreateAt()
CORERIG.shapeParent_in_place(mIKCrv.mNode, mIKShape.mNode, False)
elif ikEnd in ['tipBase', 'tipEnd', 'tipMid']:
log.debug("|{0}| >> tip shape...".format(_str_func))
ml_curves = []
if ikEnd == 'tipBase':
mIKCrv = mBlock.ikEndHandle.doCreateAt(
) #ml_handleTargets[self.int_handleEndIdx]
elif ikEnd == 'tipMid':
mIKCrv = mBlock.ikEndHandle.doCreateAt()
pos = DIST.get_average_position([
ml_rigJoints[self.int_segBaseIdx].p_position,
ml_rigJoints[-1].p_position
])
mIKCrv.p_position = pos
else:
mIKCrv = mBlock.ikEndHandle.doCreateAt()
if shapeArg is not None:
mIK_formHandle = ml_formHandles[
self.int_handleEndIdx] #self.int_handleEndIdx ]
bb_ik = POS.get_bb_size(mIK_formHandle.mNode, True, mode='max')
_ik_shape = CURVES.create_fromName(shapeArg, size=bb_ik * 1.5)
#ATTR.set(_ik_shape,'scale', 4.0)
mIKShape = cgmMeta.validateObjArg(_ik_shape,
'cgmObject',
setClass=True)
mIKShape.doSnapTo(mIK_formHandle)
CORERIG.shapeParent_in_place(mIKCrv.mNode, mIKShape.mNode,
False)
else:
CORERIG.shapeParent_in_place(mIKCrv.mNode,
ml_fkShapes[-1].mNode, True)
elif ikEnd == 'shapeArg':
mIK_formHandle = ml_formHandles[self.int_handleEndIdx]
bb_ik = POS.get_bb_size(mIK_formHandle.mNode, True, mode='max')
_ik_shape = CURVES.create_fromName(shapeArg, size=bb_ik + 1.3)
#ATTR.set(_ik_shape,'scale', 1.1)
mIKShape = cgmMeta.validateObjArg(_ik_shape,
'cgmObject',
setClass=True)
mIKShape.doSnapTo(mIK_formHandle)
mIKCrv = ml_ikJoints[self.int_handleEndIdx].doCreateAt()
CORERIG.shapeParent_in_place(mIKCrv.mNode, mIKShape.mNode, False)
else:
log.debug("|{0}| >> default IK shape...".format(_str_func))
mIK_formHandle = ml_formHandles[self.int_handleEndIdx]
bb_ik = POS.get_bb_size(mIK_formHandle.mNode, True, mode='max')
_ik_shape = CURVES.create_fromName('cube', size=bb_ik)
ATTR.set(_ik_shape, 'scale', 1.1)
mIKShape = cgmMeta.validateObjArg(_ik_shape,
'cgmObject',
setClass=True)
mIKShape.doSnapTo(mIK_formHandle)
mIKCrv = ml_ikJoints[self.int_handleEndIdx].doCreateAt()
CORERIG.shapeParent_in_place(mIKCrv.mNode, mIKShape.mNode, False)
self.mHandleFactory.color(mIKCrv.mNode,
controlType='main',
transparent=True)
mIKCrv.doCopyNameTagsFromObject(
ml_fkJoints[self.int_handleEndIdx].mNode,
ignore=['cgmType', 'cgmTypeModifier'])
mIKCrv.doStore('cgmTypeModifier', 'ik')
mIKCrv.doStore('cgmType', 'handle')
mIKCrv.doName()
self.mHandleFactory.color(mIKCrv.mNode, controlType='main')
self.mRigNull.connectChildNode(mIKCrv, 'controlIK',
'rigNull') #Connect
log.debug(cgmGEN._str_subLine)
return mIKCrv
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def build_old(self):#================================================================================
if not self._go.isShaped():
raise Exception,"%s.build_controls>>> needs shapes to build controls"%self._go._strShortName
if not self._go.isRigSkeletonized():
raise Exception,"%s.build_controls>>> needs shapes to build controls"%self._go._strShortName
"""
__d_controlShapes__ = {'shape':['controlsFK','midIK','settings','hand'],
'pivot':['toe','heel','ball','inner','outer
for shape in __d_controlShapes__['shape']:
self._go.__dict__['mi_%s'%shape] = cgmMeta.validateObjArg(self._go._i_rigNull.msgList_getMessage('shape_%s'%shape),noneValid=False)
log.info(self._go.__dict__['mi_%s'%shape] )"""
ml_controlsFK = cgmMeta.validateObjListArg(self._go._i_rigNull.msgList_getMessage('shape_controlsFK'),cgmMeta.cgmObject)
ml_segmentIK = cgmMeta.validateObjListArg(self._go._i_rigNull.msgList_getMessage('shape_segmentIK'),cgmMeta.cgmObject)
#self._go._i_rigNull.msgList_connect(self._go._md_controlShapes['segmentIK'],'shape_segmentIK_%s'%i,"rigNull")
l_segmentIKChains = []
ml_segmentIKChains = []
for i in range(50):
buffer = self._go._i_rigNull.msgList_getMessage('shape_segmentIK_%s'%i)
if buffer:
l_segmentIKChains.append(buffer)
ml_segmentIKChains.append(cgmMeta.validateObjListArg(buffer,cgmMeta.cgmObject))
else:
break
#mi_midIK = cgmMeta.validateObjArg(self._go._i_rigNull.getMessage('shape_midIK'),cgmMeta.cgmObject)
mi_settings= cgmMeta.validateObjArg(self._go._i_rigNull.getMessage('shape_settings'),cgmMeta.cgmObject)
ml_fkJoints = cgmMeta.validateObjListArg(self._go._i_rigNull.msgList_getMessage('fkJoints'),cgmMeta.cgmObject)
mi_cap = cgmMeta.validateObjArg(self._go._i_rigNull.getMessage('shape_moduleCap'),cgmMeta.cgmObject)
log.info("mi_settings: '%s'"%mi_settings.getShortName())
log.info("mi_cap: '%s'"%mi_cap.getShortName())
log.info("ml_fkJoints: %s"%[i_o.getShortName() for i_o in ml_fkJoints])
#>>>Make a few extra groups for storing controls and what not to in the deform group
for grp in ['controlsFK','controlsIK']:
i_dup = self._go._i_constrainNull.doDuplicateTransform(True)
i_dup.parent = self._go._i_constrainNull.mNode
i_dup.addAttr('cgmTypeModifier',grp,lock=True)
i_dup.doName()
self._go._i_constrainNull.connectChildNode(i_dup,grp,'owner')
l_controlsAll = []
#==================================================================
try:#>>>> FK Segments
if len( ml_controlsFK )<3:
raise Exception,"%s.build_controls>>> Must have at least three fk controls"%self._go._strShortName
#for i,i_obj in enumerate(ml_controlsFK[1:]):#parent
#i_obj.parent = ml_controlsFK[i].mNode
ml_fkJoints[0].parent = self._go._i_constrainNull.controlsFK.mNode
for i,i_obj in enumerate(ml_controlsFK):
d_buffer = mControlFactory.registerControl(i_obj,shapeParentTo=ml_fkJoints[i],setRotateOrder=3,
mirrorSide=self._go._str_mirrorDirection, mirrorAxis="translateX",
makeAimable=True,typeModifier='fk',)
i_obj = d_buffer['instance']
i_obj.axisAim = "%s+"%self._go._jointOrientation[0]
i_obj.axisUp= "%s+"%self._go._jointOrientation[1]
i_obj.axisOut= "%s+"%self._go._jointOrientation[2]
i_obj.drawStyle = 6#Stick joint draw style
cgmMeta.cgmAttr(i_obj,'radius',hidden=True)
for i_obj in ml_controlsFK:
i_obj.delete()
#ml_controlsFK[0].masterGroup.parent = self._go._i_constrainNull.mNode
self._go._i_rigNull.msgList_connect(ml_fkJoints,'controlsFK',"rigNull")
l_controlsAll.extend(ml_fkJoints[:-1])
except Exception,error:
log.error("%s.build_controls>>> Build fk fail!"%self._go._strShortName)
raise Exception,error
def add_defHelpJoint(targetJoint,childJoint = None, helperType = 'halfPush',
orientation = 'zyx',doSetup = True, forceNew = False):
"""
Add helper joints to other joints
@KWS
targetJoint(string/inst)
helperType(str) --
'halfHold' -- like a regular bend joint that needs a holder at it's root, like a finger
'childRootHold' -- holds form on a hard rotate, like a finger root
jointUp(str) --
orientation(str)
forceNew(bool) -- delete if exists
"""
mi_posLoc = False
if orientation != 'zyx':
raise NotImplementedError, "add_defHelpJoints >> only currently can do orienation of 'zyx'"
#Validate base info
mi_targetJoint = cgmMeta.validateObjArg(targetJoint,cgmMeta.cgmObject,mayaType='joint')
log.debug(">>> %s.add_defHelpJoint >> "%mi_targetJoint.p_nameShort + "="*75)
#>>Child joint
#TODO -- implement child guessing
mi_childJoint = cgmMeta.validateObjArg(childJoint,cgmMeta.cgmObject,mayaType='joint',noneValid=True)
log.debug("%s.add_defHelpJoints >> Child joint : '%s'"%(mi_targetJoint.p_nameShort,mi_childJoint))
str_plugHook = 'defHelp_joints'
#Validate some data
d_typeChecks = {'halfHold':[mi_childJoint],'childRootHold':[mi_childJoint],'halfPush':[mi_childJoint]}
if helperType in d_typeChecks.keys():
for k in d_typeChecks[helperType]:
if not k:
log.warning("%s.add_defHelpJoints >> must have valid %s for helperType: '%s'"%(mi_targetJoint.p_nameShort,k,helperType))
return False
#>Register
#----------------------------------------------------------------
#First see if we have one
ml_dynDefHelpJoints = cgmMeta.validateObjListArg(mi_targetJoint.getMessage(str_plugHook),cgmMeta.cgmObject,noneValid=True)
i_matchJnt = False
for i_jnt in ml_dynDefHelpJoints:
log.debug(i_jnt.p_nameShort)
if i_jnt.getAttr('defHelpType') == helperType and i_jnt.getMessage('defHelp_target') == [mi_targetJoint.p_nameLong]:
i_matchJnt = i_jnt
log.debug("%s.add_defHelpJoints >> Found match: '%s'"%(mi_targetJoint.p_nameShort,i_matchJnt.p_nameShort))
break
if i_matchJnt:#if we have a match
if forceNew:
log.debug("%s.add_defHelpJoints >> helper exists, no force new : '%s'"%(mi_targetJoint.p_nameShort,i_matchJnt.p_nameShort))
ml_dynDefHelpJoints.remove(i_matchJnt)
mc.delete(i_matchJnt.mNode)
else:
log.debug("%s.add_defHelpJoints >> helper exists, no force new : '%s'"%(mi_targetJoint.p_nameShort,i_matchJnt.p_nameShort))
if not i_matchJnt:
log.debug("No match joint")
#i_dupJnt = mi_targetJoint.doDuplicate(incomingConnections = False)#Duplicate
i_dupJnt= duplicateJointInPlace(mi_targetJoint)
i_dupJnt.addAttr('cgmTypeModifier',helperType)#Tag
i_dupJnt.addAttr('defHelpType',helperType,lock=True)#Tag
i_dupJnt.doName()#Rename
i_dupJnt.parent = mi_targetJoint#Parent
ml_dynDefHelpJoints.append(i_dupJnt)#append to help joint list
i_dupJnt.connectChildNode(mi_childJoint,"defHelp_childTarget")#Connect Child target
mi_targetJoint.msgList_append(ml_dynDefHelpJoints,str_plugHook,'defHelp_target')#Connect
else:
i_dupJnt = i_matchJnt
#------------------------------------------------------------
log.debug("%s.add_defHelpJoints >> Created helper joint : '%s'"%(mi_targetJoint.p_nameShort,i_dupJnt.p_nameShort))
if doSetup:
try:setup_defHelpJoint(i_dupJnt,orientation)
except StandardError,error:
log.warning("%s.add_defHelpJoints >> Failed to setup | %s"%(i_dupJnt.p_nameShort,error))
def metaFreezeJointOrientation(targetJoints):
"""
Copies joint orietnations from one joint to others
"""
try:
if type(targetJoints) not in [list,tuple]:targetJoints=[targetJoints]
ml_targetJoints = cgmMeta.validateObjListArg(targetJoints,cgmMeta.cgmObject,mayaType='joint')
'''
for i_jnt in ml_targetJoints:
if i_jnt.getConstraintsTo():
log.warning("freezeJointOrientation>> target joint has constraints. Can't change orientation. Culling from targets: '%s'"%i_jnt.getShortName())
return False
'''
#buffer parents and children of
d_children = {}
d_parent = {}
mi_parent = cgmMeta.validateObjArg(ml_targetJoints[0].parent,noneValid=True)
for i_jnt in ml_targetJoints:
d_children[i_jnt] = cgmMeta.validateObjListArg( mc.listRelatives(i_jnt.mNode, path=True, c=True),cgmMeta.cgmObject,True) or []
d_parent[i_jnt] = cgmMeta.validateObjArg(i_jnt.parent,noneValid=True)
for i_jnt in ml_targetJoints:
for i,i_c in enumerate(d_children[i_jnt]):
#log.debug(i_c.getShortName())
#log.debug("freezeJointOrientation>> parented '%s' to world to orient parent"%i_c.mNode)
i_c.parent = False
if mi_parent:
ml_targetJoints[0].parent = False
#Orient
for i,i_jnt in enumerate(ml_targetJoints):
"""
So....jointOrient is always in xyz rotate order
dup,rotate order
Unparent, add rotate & joint rotate, push value, zero rotate, parent back, done
"""
log.debug("parent...")
if i != 0 and d_parent.get(i_jnt):
i_jnt.parent = d_parent.get(i_jnt)#parent back first before duping
log.debug("dup...")
i_dup= duplicateJointInPlace(i_jnt)
i_dup.rotateOrder = 0
#New method ----
log.debug("loc...")
mi_zLoc = i_jnt.doLoc()#Make some locs
mi_yLoc = i_jnt.doLoc()
log.debug("group...")
str_group = mi_zLoc.doGroup() #group for easy move
mi_yLoc.parent = str_group
mi_zLoc.tz = 1#Move
mi_yLoc.ty = 1
mc.makeIdentity(i_dup.mNode, apply = 1, jo = 1)#Freeze
#Aim
log.debug("constrain...")
str_const = mc.aimConstraint(mi_zLoc.mNode,i_dup.mNode,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpVector = [0,1,0], worldUpObject = mi_yLoc.mNode, worldUpType = 'object' )[0]
i_jnt.rotate = [0,0,0] #Move to joint
i_jnt.jointOrient = i_dup.rotate
log.debug("delete...")
mc.delete([str_const,str_group])#Delete extra stuff
i_dup.delete()
#reparent
if mi_parent:
try:ml_targetJoints[0].parent = mi_parent
except Exception,error: raise StandardError,"Failed to parent back %s"%error
for i_jnt in ml_targetJoints:
for i_c in d_children[i_jnt]:
log.debug("freezeJointOrientation>> parented '%s' back"%i_c.getShortName())
i_c.parent = i_jnt.mNode
cgmMeta.cgmAttr(i_c,"inverseScale").doConnectIn("%s.scale"%i_jnt.mNode )
return True
except Exception,error:raise Exception,"bring data local fail | {0} ".format(error)
def get_meshFromNurbs(nurbSurface=None,
mode='default',
uNumber=10,
vNumber=10):
mMesh = cgmMeta.validateObjArg(nurbSurface, mayaType='nurbsSurface')
mDup = mMesh.doDuplicate(po=False)
#mNew = self.doCreateAt(setClass='cgmObject')
newShapes = []
for mShape in mDup.getShapes(asMeta=1):
if mode == 'default':
d_kws = {}
_res = mc.nurbsToPoly(mShape.mNode,
mnd=1,
ch=0,
f=3,
pt=1,
pc=200,
chr=0.9,
ft=0.01,
mel=0.001,
d=0.1,
ut=1,
un=3,
vt=1,
vn=3,
uch=0,
ucr=0,
cht=0.2,
es=0,
ntr=0,
mrt=0,
uss=1)
elif mode == 'general':
d_kws = {
'mnd': 1,
'ch': 0,
'f': 2,
'pt': 1, #quad
'pc': 200,
'chr': 0.9,
'ft': 0.01,
'mel': 0.001,
'd': 0.1,
'ut': 1,
'un': uNumber,
'vt': 1,
'vn': vNumber,
'uch': 0,
'ucr': 0,
'cht': 0.2,
'es': 0,
'ntr': 0,
'mrt': 0,
'uss': 1
}
_res = mc.nurbsToPoly(mShape.mNode, **d_kws)
else:
raise ValueError, "get_meshFromNurbs | Unknown mode: {0}".format(
mode)
newShapes.append(_res[0])
if len(newShapes) > 1:
_mesh = mc.polyUnite(newShapes, ch=False)[0]
else:
_mesh = newShapes[0]
mNew = cgmMeta.asMeta(_mesh)
#for s in newShapes:
mDup.delete()
return mNew
def createMeshSliceCurve(mesh,
mi_obj,
latheAxis='z',
aimAxis='y+',
points=12,
curveDegree=3,
minRotate=None,
maxRotate=None,
rotateRange=None,
posOffset=None,
vectorOffset=None,
markHits=False,
rotateBank=None,
closedCurve=True,
maxDistance=1000,
initialRotate=0,
offsetMode='vector',
midMeshCast=False,
l_specifiedRotates=None,
closestInRange=True,
returnDict=False,
axisToCheck=['x', 'y'],
**kws):
"""
This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits.
it then uses this information to build a curve shape.
:parameters:
mesh(string) | Surface to cast at
mi_obj(string/mObj) | our casting object
latheAxis(str) | axis of the objec to lathe TODO: add validation
aimAxis(str) | axis to shoot out of
points(int) | how many points you want in the curve
curveDegree(int) | specified degree
minRotate(float) | let's you specify a valid range to shoot
maxRotate(float) | let's you specify a valid range to shoot
posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface
markHits(bool) | whether to keep the hit markers
returnDict(bool) | whether you want all the infomation from the process.
rotateBank (float) | let's you add a bank to the rotation object
l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings
maxDistance(float) | max distance to cast rays
closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range.
:returns:
Dict ------------------------------------------------------------------
'source'(double3) | point from which we cast
'hit'(double3) | world space points | active during single return
'hits'(list) | world space points | active during multi return
'uv'(double2) | uv on surface of hit | only works for mesh surfaces
:raises:
Exception | if reached
"""
_str_func = 'createMeshSliceCurve'
try:
mi_obj = cgmMeta.validateObjArg(mi_obj,
mType='cgmObject',
noneValid=True)
if not mi_obj:
return False
log.debug("mi_obj: {0}".format(mi_obj.mNode))
mesh = VALID.objStringList(mesh, ['mesh', 'nurbsSurface'],
calledFrom=_str_func)
#if len(mc.ls(mesh))>1:
#log.error("{0}>>> More than one mesh named. Using first: {1}".format(_str_func,mesh))
#mesh = mesh[0]
log.debug("mesh: {0}".format(mesh))
log.debug("points: {0}".format(points))
except Exception, error:
raise ValueError, "Validation fail | {0}".format(error)
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
addSDKGroup=False,
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 = cgmGEN.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 = []
ml_children = mi_control.getChildren(asMeta=1)
if ml_children:
for mChild in ml_children:
mChild.p_parent = False
#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_master = mi_control.getMessageAsMeta('masterGroup')
if not i_master:
i_masterGroup = mi_control.doGroup(True,
True,
asMeta=True,
typeModifier='master',
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 addSDKGroup:
log.debug('addSDKGroup...')
mConstrain = mi_control.doGroup(True,
True,
asMeta=True,
typeModifier='sdk',
setClass=True)
if addDynParentGroup:
log.debug('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:
log.debug('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
log.debug('addConstraintGroup...')
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:
log.debug('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 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)
else:
log.error("mirrorSide {0} | mControl: {1}".format(
str_mirrorSide, mObj))
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:
l_cons = CONSTRAINTS.get_constraintsTo(mi_control.mNode)
if l_cons:
mc.delete(l_cons)
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()
def gatherInfo(self):
mi_go = self._go#Rig Go instance link
self.mi_helper = cgmMeta.validateObjArg(mi_go._mi_module.getMessage('helper'),noneValid=True)
if not self.mi_helper:raise StandardError,"No suitable helper found"
def metaFreezeJointOrientation(targetJoints):
"""
Freeze joint orientations in place.
"""
try:
_str_funcName = "metaFreezeJointOrientation"
#t1 = time.time()
if type(targetJoints) not in [list,tuple]:targetJoints=[targetJoints]
ml_targetJoints = cgmMeta.validateObjListArg(targetJoints,'cgmObject',mayaType='joint')
#log.info("{0}>> meta'd: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1)))
#t1 = time.time()
'''
for i_jnt in ml_targetJoints:
if i_jnt.getConstraintsTo():
log.warning("freezeJointOrientation>> target joint has constraints. Can't change orientation. Culling from targets: '%s'"%i_jnt.getShortName())
return False
'''
#buffer parents and children of
d_children = {}
d_parent = {}
mi_parent = cgmMeta.validateObjArg(ml_targetJoints[0].parent,noneValid=True)
#log.info('validate')
for i,i_jnt in enumerate(ml_targetJoints):
_relatives = mc.listRelatives(i_jnt.mNode, path=True, c=True)
log.debug("{0} relatives: {1}".format(i,_relatives))
d_children[i_jnt] = cgmMeta.validateObjListArg( _relatives ,'cgmObject',True) or []
d_parent[i_jnt] = cgmMeta.validateObjArg(i_jnt.parent,noneValid=True)
for i_jnt in ml_targetJoints:
for i,i_c in enumerate(d_children[i_jnt]):
#log.debug(i_c.getShortName())
#log.debug("freezeJointOrientation>> parented '%s' to world to orient parent"%i_c.mNode)
i_c.parent = False
if mi_parent:
ml_targetJoints[0].parent = False
#log.info('gather data')
#log.info("{0}>> parent data: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1)))
#t1 = time.time()
#Orient
t_loop = time.time()
for i,i_jnt in enumerate(ml_targetJoints):
"""
So....jointOrient is always in xyz rotate order
dup,rotate order
Unparent, add rotate & joint rotate, push value, zero rotate, parent back, done
"""
log.debug("parent...")
if i != 0 and d_parent.get(i_jnt):
i_jnt.parent = d_parent.get(i_jnt)#parent back first before duping
#log.info('{0} parent'.format(i))
#log.info("{0}>> {2} parent: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
log.debug("dup...")
#i_dup = duplicateJointInPlace(i_jnt)
i_dup = i_jnt.doDuplicate(parentOnly = True)
#log.debug("{0} | UUID: {1}".format(i_jnt.mNode,i_jnt.getMayaAttr('UUID')))
#log.debug("{0} | UUID: {1}".format(i_dup.mNode,i_dup.getMayaAttr('UUID')))
i_dup.parent = i_jnt.parent
i_dup.rotateOrder = 0
#log.info("{0}>> {2} dup: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
#New method ----
log.debug("loc...")
mi_zLoc = i_jnt.doLoc(fastMode = True)#Make some locs
#mi_yLoc = mi_zLoc.doDuplicate()
"""mi_zLoc = cgmMeta.cgmObject(mc.spaceLocator()[0])
objTrans = mc.xform(i_jnt.mNode, q=True, ws=True, sp=True)
objRot = mc.xform(i_jnt.mNode, q=True, ws=True, ro=True)
mc.move (objTrans[0],objTrans[1],objTrans[2], mi_zLoc.mNode)
mc.rotate (objRot[0], objRot[1], objRot[2], mi_zLoc.mNode, ws=True)
mi_zLoc.rotateOrder = i_jnt.rotateOrder"""
mi_yLoc = mi_zLoc.doDuplicate()
#log.info('{0} loc'.format(i))
#log.info("{0}>> {2} loc: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
log.debug("group...")
str_group = mi_zLoc.doGroup() #group for easy move
mi_yLoc.parent = str_group
#log.info('{0} group'.format(i))
#log.info("{0}>> {2} group: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
mi_zLoc.tz = 1#Move
mi_yLoc.ty = 1
mc.makeIdentity(i_dup.mNode, apply = 1, jo = 1)#Freeze
#Aim
log.debug("constrain...")
str_const = mc.aimConstraint(mi_zLoc.mNode,i_dup.mNode,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpVector = [0,1,0], worldUpObject = mi_yLoc.mNode, worldUpType = 'object' )[0]
#log.info('{0} constrain'.format(i))
#log.info("{0}>> {2} constraint: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
i_jnt.rotate = [0,0,0] #Move to joint
i_jnt.jointOrient = i_dup.rotate
#log.info('{0} delete'.format(i))
log.debug("delete...")
mc.delete([str_const,str_group])#Delete extra stuff str_group
i_dup.delete()
#log.info("{0}>> {2} clean: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1), i_jnt.p_nameShort))
#t1 = time.time()
#log.info("{0}>> orienting: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t_loop)))
#t1 = time.time()
#reparent
if mi_parent:
try:ml_targetJoints[0].parent = mi_parent
except Exception,error: raise StandardError,"Failed to parent back %s"%error
for i,i_jnt in enumerate(ml_targetJoints):
for ii,i_c in enumerate(d_children[i_jnt]):
#log.info("{0} | {1}".format(i,ii))
#log.info(i_c)
log.debug("freezeJointOrientation>> parented '%s' back"%i_c.getShortName())
i_c.parent = i_jnt.mNode
cgmMeta.cgmAttr(i_c,"inverseScale").doConnectIn("%s.scale"%i_jnt.mNode )
#log.info('reparent')
#log.info("{0}>> reparent: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1)))
#t1 = time.time()
return True
except Exception,error:raise Exception,"metaFreezeJointOrientation | {0} ".format(error)
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 resize_masterShape(self,sizeBy=None,resize=False):
try:
_short = self.p_nameShort
_str_func = '[{0}] resize_masterShape'.format(_short)
log.debug("|{0}| >> ".format(_str_func)+ '-'*80)
_sel = mc.ls(sl=True)
_bb = False
_bb = self.baseSize
if resize:
if _sel:
_bb = TRANS.bbSize_get(_sel,False)
#elif self.getBlockChildren():
# sizeBy = mc.ls(self.getBlockChildren(asMeta=False))
# _bb = TRANS.bbSize_get(sizeBy,False)
self.baseSize = _bb
log.debug("|{0}| >> _bb: {1}".format(_str_func,_bb))
mHandleFactory = self.asHandleFactory(_short)
mc.delete(self.getShapes())
_average = MATH.average([_bb[0],_bb[2]])
_size = _average * 1.5
_offsetSize = _average * .01
_blockScale = self.blockScale
mFormNull = self.atUtils('stateNull_verify','form')
mNoTransformNull = self.atUtils('noTransformNull_verify','form')
if resize or self.controlOffset == .9999:
self.controlOffset = _offsetSize
#Main curve ===========================================================================
_crv = CURVES.create_fromName(name='circle',direction = 'y+', size = 1)
mCrv = cgmMeta.asMeta(_crv)
SNAP.go(mCrv.mNode,self.mNode,rotation=False)
TRANS.scale_to_boundingBox(mCrv.mNode, [_bb[0],None,_bb[2]])
#mDup = mCrv.doDuplicate(po=False)
#mDup.p_position = MATH.list_add(mDup.p_position, [0,_offsetSize,0])
RIG.shapeParent_in_place(self.mNode,_crv,False)
#RIG.shapeParent_in_place(self.mNode,mDup.mNode,False)
mHandleFactory.color(self.mNode,'center','main',transparent = False)
#Bounding box ==================================================================
if self.getMessage('bbHelper'):
self.bbHelper.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,'cubeOpen', size = 1, sizeMode='fixed')
_bb_newSize = MATH.list_mult(self.baseSize,[_blockScale,_blockScale,_blockScale])
TRANS.scale_to_boundingBox(_bb_shape,_bb_newSize)
mBBShape = cgmMeta.validateObjArg(_bb_shape, 'cgmObject',setClass=True)
mBBShape.p_parent = mFormNull
mBBShape.inheritsTransform = False
mc.parentConstraint(self.mNode,mBBShape.mNode,maintainOffset=False)
SNAPCALLS.snap( mBBShape.mNode,self.mNode,objPivot='axisBox',objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode,self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
#mHandleFactory.color(mBBShape.mNode,controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType','bbVisualize')
mBBShape.doName()
mBBShape.template = True
self.connectChildNode(mBBShape.mNode,'bbHelper')
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
#Need to guess our offset size based on bounding box volume
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance = 1, ch=True )
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0],'center','sub',transparent = False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0], 'cgmObject',setClass=True)
mOffsetShape.p_parent = mNoTransformNull
#mOffsetShape.doSnapTo(self)
#mc.pointConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
#mc.orientConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
mOffsetShape.inheritsTransform = False
mOffsetShape.dagLock()
_arg = '{0}.distance = -{1}.controlOffset'.format(l_return[1],
self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType','offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode,'offsetHelper')
return
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance = 1, ch=True )
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0],'center','sub',transparent = False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0], 'cgmObject',setClass=True)
mOffsetShape.p_parent = mFormNull
mOffsetShape.inheritsTransform = False
mc.parentConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=False)
#mOffsetShape.setAttrFlags()
_arg = '{0}.distance = -{1}.controlOffset * {1}.blockScale'.format(l_return[1],
self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType','offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode,'offsetHelper')
return
_crv = CURVES.create_fromName(name='squareOpen',direction = 'y+', size = 1)
TRANS.scale_to_boundingBox(_crv, [_bb[0],None,_bb[2]])
mHandleFactory.color(_crv,'center','sub',transparent = False)
mCrv = cgmMeta.validateObjArg(_crv,'cgmObject')
l_offsetCrvs = []
for shape in mCrv.getShapes():
offsetShape = mc.offsetCurve(shape, distance = -_offsetSize, ch=True )[0]
mHandleFactory.color(offsetShape,'center','main',transparent = False)
l_offsetCrvs.append(offsetShape)
RIG.combineShapes(l_offsetCrvs + [_crv], True)
SNAP.go(_crv,self.mNode)
RIG.shapeParent_in_place(self.mNode,_crv,True)
self.baseSize = _bb
#Bounding box ==================================================================
if self.getMessage('offsetVisualize'):
self.bbVisualize.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,'cubeOpen', size = 1.0, sizeMode='fixed')
mBBShape = cgmMeta.validateObjArg(_bb_shape, 'cgmObject',setClass=True)
mBBShape.p_parent = mFormNull
SNAPCALLS.snap( mBBShape.mNode,self.mNode,objPivot='axisBox',objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode,self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
mHandleFactory.color(mBBShape.mNode,controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType','bbVisualize')
mBBShape.doName()
self.connectChildNode(mBBShape.mNode,'bbHelper')
return True
except Exception,err:
cgmGEN.cgmExceptCB(Exception,err,localDat=vars())
def returnNormalizedUV(mesh, uValue, vValue):
"""
uv Values from many functions need to be normalized to be correct when using those values for other functions
The calculcaion for doing so is
size = maxV - minV
sum = rawV + minV
normalValue = sum / size
:parameters:
mesh(string) | Surface to normalize to
uValue(float) | uValue to normalize
vValue(float) | vValue to normalize
:returns:
Dict ------------------------------------------------------------------
'uv'(double2) | point from which we cast
'uValue'(float) | normalized uValue
'vValue'(float) | normalized vValue
:raises:
Exception | if reached
"""
try:
_str_funcName = 'returnNormalizedUV'
try:#Validation ----------------------------------------------------------------
mesh = cgmValid.objString(mesh,'nurbsSurface', calledFrom = _str_funcName)
if len(mc.ls(mesh))>1:
raise StandardError,"{0}>>> More than one mesh named: {1}".format(_str_funcName,mesh)
_str_objType = search.returnObjectType(mesh)
l_shapes = mc.listRelatives(mesh, shapes=True)
if len(l_shapes)>1:
log.debug( "More than one shape found. Using 0. targetSurface : %s | shapes: %s"%(mesh,l_shapes) )
mi_shape = cgmMeta.validateObjArg(l_shapes[0],cgmMeta.cgmNode,noneValid=False)
uMin = mi_shape.mnu
uMax = mi_shape.mxu
vMin = mi_shape.mnv
vMax = mi_shape.mxv
except Exception,error:raise Exception,"Validation failure | {0}".format(error)
try:#Calculation ----------------------------------------------------------------
uSize = uMax - uMin
vSize = vMax - vMin
uSum = uMin + uValue
vSum = vMin + vValue
uNormal = uSum / uSize
vNormal = vSum / vSize
except Exception,error:raise Exception,"Calculation |{0}".format(error)
try:
d_return = {'uv':[uNormal,vNormal],'uValue':uNormal,'vValue':vNormal}
return d_return
except Exception,error:raise Exception,"Return prep |{0}".format(error)
except Exception,error:
log.error(">>> {0} >> Failure! mesh: '{1}' | uValue: {2} | vValue {3}".format(_str_funcName,mesh,uValue,vValue))
log.error(">>> {0} >> error: {1}".format(_str_funcName,error))
return None
timeStart_objectList = time.clock()
if self.ml_objList:
self.d_objectsInfo = {}
#first we validate
#First we're gonna gather all of the data
#=========================================================================================
for i,i_o in enumerate(self.ml_objList):
if i >= int_maxObjects:
log.warning("More than %s objects select, only loading first %s for speed"%(int_maxObjects,int_maxObjects))
break
d_buffer = {}
#>>> Space switching ------------------------------------------------------------------
if i_o.getMessage('dynParentGroup'):
i_dynParent = cgmMeta.validateObjArg(i_o.getMessage('dynParentGroup')[0],cgmRigMeta.cgmDynParentGroup,True)
d_buffer['dynParent'] = {'mi_dynParent':i_dynParent,'attrs':[],'attrOptions':{}}#Build our data gatherer
if i_dynParent:
for a in cgmRigMeta.d_DynParentGroupModeAttrs[i_dynParent.dynMode]:
if i_o.hasAttr(a):
d_buffer['dynParent']['attrs'].append(a)
lBuffer_attrOptions = []
for i,o in enumerate(cgmMeta.cgmAttr(i_o.mNode,a).p_enum):
lBuffer_attrOptions.append(o)
d_buffer['dynParent']['attrOptions'][a] = lBuffer_attrOptions
self.d_objectsInfo[i_o] = d_buffer
#>>> Module --------------------------------------------------------------------------
if self.BuildModuleOptionVar.value or self.BuildPuppetOptionVar.value:
if i_o.getMessage('rigNull'):
_mi_rigNull = i_o.rigNull
def setup_defHelpJoint(targetJoint, orientation='zyx'):
"""
Setup a helper joint
@KWS
targetJoint(string/inst) -- must be helper joint
orientation(str)
forceNew(bool) -- delete if exists
helperTypes --
'halfHold' -- like a regular bend joint that needs a holder at it's root, like a finger
'childRootHold' -- holds form on a hard rotate, like a finger root
'halfPush' -- like a regular bend joint that needs a holder at it's root, like a finger
"""
mi_posLoc = False
if orientation != 'zyx':
raise NotImplementedError, "add_defHelpJoints >> only currently can do orienation of 'zyx'"
#Validate base info
mi_helperJoint = cgmMeta.validateObjArg(targetJoint,
cgmMeta.cgmObject,
mayaType='joint')
mi_targetJoint = cgmMeta.validateObjArg(
mi_helperJoint.getMessage('defHelp_target'),
cgmMeta.cgmObject,
mayaType='joint')
mi_childJoint = cgmMeta.validateObjArg(
mi_helperJoint.getMessage('defHelp_childTarget'),
cgmMeta.cgmObject,
mayaType='joint')
str_helperType = mi_helperJoint.getAttr('defHelpType')
if not str_helperType in __l_helperTypes__:
log.warning(
"%s.setup_defHelpJoint >> '%s' not a valid helperType: %s" %
(mi_helperJoint.p_nameShort, str_helperType, __l_helperTypes__))
return False
log.debug(">>> %s.setup_defHelpJoint >> " % mi_helperJoint.p_nameShort +
"=" * 75)
#>Setup
#----------------------------------------------------------------
if str_helperType == 'halfHold':
mi_helperJoint.tx = mi_childJoint.tx * .5
mi_helperJoint.ty = mi_childJoint.ty * .5
mi_helperJoint.tz = mi_childJoint.tz * .5
mi_helperJoint.__setattr__("t%s" % orientation[1],
(-mi_childJoint.tz * .2))
#Setup sd
'''
""" set our keyframes on our curve"""
for channel in :
mc.setKeyframe (attributeHolder,sqshStrchAttribute, time = cnt, value = 1)
""" making the frame cache nodes """
frameCacheNodes.append(nodes.createNamedNode(jointChain[jnt],'frameCache'))
cnt+=1
""" connect it """
for cacheNode in frameCacheNodes:
mc.connectAttr((sqshStrchAttribute),(cacheNode+'.stream'))
cnt=1
""" set the vary time """
for cacheNode in frameCacheNodes:
mc.setAttr((cacheNode+'.varyTime'),cnt)
cnt+=1
'''
#With half hold, our driver is the child joint
str_driverRot = "%s.r%s" % (mi_childJoint.mNode, orientation[2])
str_drivenTransAim = "%s.t%s" % (mi_helperJoint.mNode, orientation[0])
f_baseTransValue = mi_helperJoint.getAttr("t%s" % (orientation[0]))
f_sdkTransValue = f_baseTransValue + (f_baseTransValue * .3)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=0,
value=f_baseTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=110,
value=f_sdkTransValue)
elif str_helperType == 'halfPush':
mi_helperJoint.tx = mi_childJoint.tx * .5
mi_helperJoint.ty = mi_childJoint.ty * .5
mi_helperJoint.tz = mi_childJoint.tz * .5
mi_helperJoint.__setattr__("t%s" % orientation[1],
-(mi_childJoint.tz * .2))
#With half push, our driver is the target joint
str_driverRot = "%s.r%s" % (mi_targetJoint.mNode, orientation[2])
str_drivenTransAim = "%s.t%s" % (mi_helperJoint.mNode, orientation[0])
f_baseTransValue = mi_helperJoint.getAttr("t%s" % (orientation[0]))
f_sdkTransValue = f_baseTransValue + (f_baseTransValue * .3)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=0,
value=f_baseTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=110,
value=f_sdkTransValue)
elif str_helperType == 'childRootHold':
'''mi_helperJoint.__setattr__("t%s"%orientation[1],(-mi_childJoint.getMayaAttr("t%s"%(orientation[0])) *.2))
mi_helperJoint.parent = mi_targetJoint.parent
if not mi_posLoc:mi_posLoc = mi_helperJoint.doLoc()#Make sure we have a loc
mi_posLoc.parent = mi_helperJoint.mNode#Parent loc to i_dup to make sure we're in same space
f_baseUpTransValue = mi_helperJoint.getAttr("t%s"%(orientation[1]))
f_sdkUpTransValue = mi_childJoint.getAttr("t%s"%(orientation[0])) * -.25
f_baseAimTransValue = mi_helperJoint.getAttr("t%s"%(orientation[0]))
f_sdkAimTransValue = mi_childJoint.getAttr("t%s"%(orientation[0])) * -.5'''
mi_helperJoint.__setattr__(
"t%s" % orientation[1],
(-mi_childJoint.getMayaAttr("t%s" % (orientation[0])) * .2))
mi_helperJoint.__setattr__(
"t%s" % orientation[0],
(-mi_childJoint.getMayaAttr("t%s" % (orientation[0])) * .1))
mi_helperJoint.parent = mi_targetJoint.parent
if not mi_posLoc:
mi_posLoc = mi_helperJoint.doLoc() #Make sure we have a loc
mi_posLoc.parent = mi_helperJoint.mNode #Parent loc to i_dup to make sure we're in same space
f_baseUpTransValue = mi_helperJoint.getAttr("t%s" % (orientation[1]))
f_sdkUpTransValue = mi_targetJoint.getAttr("t%s" %
(orientation[0])) * -.05
f_baseAimTransValue = mi_helperJoint.getAttr("t%s" % (orientation[0]))
f_sdkAimTransValue = mi_targetJoint.getAttr("t%s" %
(orientation[0])) * -.25
#Move the pos loc for our pose ----------------------------------
mi_posLoc.__setattr__("t%s" % orientation[0], f_sdkAimTransValue)
mi_posLoc.__setattr__("t%s" % orientation[1], f_sdkUpTransValue)
mi_posLoc.parent = mi_helperJoint.parent
#With childRootHold, our driver is the target joint --------------
str_driverRot = "%s.r%s" % (mi_targetJoint.mNode, orientation[2])
#Up ---------------------------------------------------------------
str_drivenTransUp = "%s.t%s" % (mi_helperJoint.mNode, orientation[1])
mc.setDrivenKeyframe(str_drivenTransUp,
currentDriver=str_driverRot,
driverValue=0,
value=f_baseUpTransValue)
mc.setDrivenKeyframe(str_drivenTransUp,
currentDriver=str_driverRot,
driverValue=120,
value=mi_posLoc.getAttr("t%s" % orientation[1]))
#Aim ---------------------------------------------------------------
str_drivenTransAim = "%s.t%s" % (mi_helperJoint.mNode, orientation[0])
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=0,
value=f_baseAimTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver=str_driverRot,
driverValue=120,
value=mi_posLoc.getAttr("t%s" % orientation[0]))
if mi_posLoc: mi_posLoc.delete()
return
def returnBaseControlSize(mi_obj,mesh,axis=True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Figure out the base size for a control from a point in space within a mesh
ARGUMENTS:
mi_obj(cgmObject instance)
mesh(obj) = ['option1','option2']
axis(list) -- what axis to check
RETURNS:
axisDistances(dict) -- axis distances, average
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
try:#>>Figure out the axis to do
log.info(mi_obj)
mi_obj = cgmMeta.validateObjArg(mi_obj,cgmMeta.cgmObject,noneValid = True)
if not mi_obj:
raise ValueError,"mi_obj kw: {0} ".format(mi_obj)
_str_funcName = "returnBaseControlSize(%s)"%mi_obj.p_nameShort
log.debug(">> %s "%(_str_funcName) + "="*75)
start = time.clock()
log.debug("%s >> mesh: %s "%(_str_funcName,mesh))
log.debug("%s >> axis: %s "%(_str_funcName,axis))
try:
d_axisToDo = {}
if axis == True:
axis = ['x','y','z']
if type(axis) in [list,tuple]:
for a in axis:
if a in dictionary.stringToVectorDict.keys():
if list(a)[0] in d_axisToDo.keys():
d_axisToDo[list(a)[0]].append( a )
else:
d_axisToDo[list(a)[0]] = [ a ]
elif type(a) is str and a.lower() in ['x','y','z']:
buffer = []
buffer.append('%s+'%a.lower())
buffer.append('%s-'%a.lower())
d_axisToDo[a.lower()] = buffer
else:
log.warning("Don't know what with: '%s'"%a)
log.debug("%s >> d_axisToDo: %s "%(_str_funcName,d_axisToDo))
if not d_axisToDo:return False
except Exception,error:
raise Exception,"Axis check | {0}".format(error)
#>>
d_returnDistances = {}
for axis in d_axisToDo:
log.debug("Checking: %s"%axis)
directions = d_axisToDo[axis]
if len(directions) == 1:#gonna multiply our distance
try:
info = RayCast.findMeshIntersectionFromObjectAxis(mesh,mi_obj.mNode,directions[0])
d_returnDistances[axis] = (distance.returnDistanceBetweenPoints(info['hit'],mi_obj.getPosition()) *2)
except Exception,error:
raise Exception,"raycast | %s"%error
else:
try:
info1 = RayCast.findMeshIntersectionFromObjectAxis(mesh,mi_obj.mNode,directions[0])
info2 = RayCast.findMeshIntersectionFromObjectAxis(mesh,mi_obj.mNode,directions[1])
if info1 and info2:
d_returnDistances[axis] = distance.returnDistanceBetweenPoints(info1['hit'],info2['hit'])
except Exception,error:
raise Exception,"raycast | %s"%error
def returnBaseControlSize(mi_obj, mesh, axis=True, closestInRange=True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Figure out the base size for a control from a point in space within a mesh
ARGUMENTS:
mi_obj(cgmObject instance)
mesh(obj) = ['option1','option2']
axis(list) -- what axis to check
RETURNS:
axisDistances(dict) -- axis distances, average
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
try: #>>Figure out the axis to do
log.info(mi_obj)
mi_obj = cgmMeta.validateObjArg(mi_obj,
cgmMeta.cgmObject,
noneValid=True)
if not mi_obj:
raise ValueError, "mi_obj kw: {0} ".format(mi_obj)
_str_func = "returnBaseControlSize(%s)" % mi_obj.p_nameShort
log.debug(">> %s " % (_str_func) + "=" * 75)
start = time.clock()
log.debug("%s >> mesh: %s " % (_str_func, mesh))
log.debug("%s >> axis: %s " % (_str_func, axis))
try:
d_axisToDo = {}
if axis == True:
axis = ['x', 'y', 'z']
if type(axis) in [list, tuple]:
for a in axis:
if a in dictionary.stringToVectorDict.keys():
if list(a)[0] in d_axisToDo.keys():
d_axisToDo[list(a)[0]].append(a)
else:
d_axisToDo[list(a)[0]] = [a]
elif type(a) is str and a.lower() in ['x', 'y', 'z']:
buffer = []
buffer.append('%s+' % a.lower())
buffer.append('%s-' % a.lower())
d_axisToDo[a.lower()] = buffer
else:
log.warning("Don't know what with: '%s'" % a)
log.debug("%s >> d_axisToDo: %s " % (_str_func, d_axisToDo))
if not d_axisToDo: return False
except Exception, error:
raise Exception, "Axis check | {0}".format(error)
#>>
d_returnDistances = {}
for axis in d_axisToDo:
log.debug("Checking: %s" % axis)
directions = d_axisToDo[axis]
if len(directions) == 1: #gonna multiply our distance
try:
info = RayCast.findMeshIntersectionFromObjectAxis(
mesh, mi_obj.mNode, directions[0])
d_returnDistances[axis] = (
distance.returnDistanceBetweenPoints(
info['near'], mi_obj.getPosition()) * 2)
except Exception, error:
raise Exception, "raycast | %s" % error
else:
try:
info1 = RayCast.findMeshIntersectionFromObjectAxis(
mesh, mi_obj.mNode, directions[0])
info2 = RayCast.findMeshIntersectionFromObjectAxis(
mesh, mi_obj.mNode, directions[1])
if info1 and info2:
d_returnDistances[
axis] = distance.returnDistanceBetweenPoints(
info1['near'], info2['near'])
except Exception, error:
raise Exception, "raycast | %s" % error
def settings(self, settingsPlace=None, ml_targets=None):
try:
_str_func = 'rp'
log_start(_str_func)
log.debug("|{0}| >> settings: {1}...".format(_str_func, settingsPlace))
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
if settingsPlace == None:
settingsPlace = mBlock.getEnumValueString('settingsPlace')
if settingsPlace == 'cog':
mCog = mRigNull.getMessageAsMeta('rigRoot')
if mCog:
log.debug("|{0}| >> Settings is cog...".format(_str_func))
mRigNull.connectChildNode(mCog, 'settings',
'rigNull') #Connect
return mCog
else:
log.warning(
"|{0}| >> Settings. Cog option but no cog found...".format(
_str_func))
settingsPlace = 'start'
mSettingsHelper = mBlock.getMessageAsMeta('settingsHelper')
if settingsPlace in ['start', 'end']:
if settingsPlace == 'start':
_mTar = ml_targets[0]
else:
_mTar = ml_targets[self.int_handleEndIdx]
#_settingsSize = _offset * 2
if not mSettingsHelper:
mMesh_tmp = mBlock.atUtils('get_castMesh')
str_meshShape = mMesh_tmp.getShapes()[0]
d_directions = {
'up': 'y+',
'down': 'y-',
'in': 'x+',
'out': 'x-'
}
str_settingsDirections = d_directions.get(
mBlock.getEnumValueString('settingsDirection'), 'y+')
pos = RAYS.get_cast_pos(_mTar.mNode,
str_settingsDirections,
shapes=str_meshShape)
if not pos:
log.debug(
cgmGEN.logString_msg(_str_func, 'standard IK end'))
pos = _mTar.getPositionByAxisDistance(
str_settingsDirections, _offset * 5)
vec = MATH.get_vector_of_two_points(_mTar.p_position, pos)
newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4)
_settingsSize = _offset * 2
mSettingsShape = cgmMeta.validateObjArg(CURVES.create_fromName(
'gear',
_settingsSize,
'{0}+'.format(_jointOrientation[2]),
baseSize=1.0),
'cgmObject',
setClass=True)
mSettingsShape.doSnapTo(_mTar.mNode)
#SNAPCALLS.get_special_pos([_mTar,str_meshShape],'castNear',str_settingsDirections,False)
mSettingsShape.p_position = newPos
mMesh_tmp.delete()
SNAP.aim_atPoint(
mSettingsShape.mNode,
_mTar.p_position,
aimAxis=_jointOrientation[0] + '+',
mode='vector',
vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-'))
else:
mSettingsShape = mSettingsHelper.doDuplicate(po=False)
mSettingsShape.parent = _mTar
mSettings = mSettingsShape
CORERIG.match_orientation(mSettings.mNode, _mTar.mNode)
ATTR.copy_to(self.mModule.mNode,
'cgmName',
mSettings.mNode,
driven='target')
mSettings.doStore('cgmTypeModifier', 'settings')
mSettings.doName()
self.mHandleFactory.color(mSettings.mNode, controlType='sub')
mRigNull.connectChildNode(mSettings, 'settings',
'rigNull') #Connect
#cgmGEN.func_snapShot(vars())
#mSettings.select()
else:
raise ValueError, "Unknown settingsPlace: {1}".format(
settingsPlace)
return mSettings
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def attach_toShape(obj=None,
targetShape=None,
connectBy='parent',
driver=None):
"""
:parameters:
obj - transform to attach
targetShape(str) - Curve, Nurbs, Mesh
connectBy(str)
parent - parent to track transform
parentGroup - parent to group and have group follow
conPoint - just point contraint
conPointGroup - pointConstrain group
conPointOrientGroup - point/orient constrain group
conParentGroup - parent Constrain group
None - just the tracker nodes
:returns:
resulting dat
"""
try:
_str_func = 'attach_toShape'
mObj = cgmMeta.validateObjArg(obj, 'cgmObject')
mDriver = cgmMeta.validateObjArg(driver, 'cgmObject', noneValid=True)
targetShape = VALID.mNodeString(targetShape)
log.debug("targetShape: {0}".format(targetShape))
#Get our data...
d_closest = DIST.get_closest_point_data(targetShape, mObj.mNode)
log.debug("|{0}| >> jnt: {1} | {2}".format(_str_func, mObj.mNode,
d_closest))
#pprint.pprint(d_closest)
md_res = {}
if d_closest['type'] in ['mesh', 'nurbsSurface']:
log.debug("|{0}| >> Follicle mode...".format(_str_func))
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
log.debug("_shape: {0}".format(_shape))
l_follicleInfo = NODES.createFollicleOnMesh(_shape)
i_follicleTrans = cgmMeta.asMeta(l_follicleInfo[1],
'cgmObject',
setClass=True)
i_follicleShape = cgmMeta.asMeta(l_follicleInfo[0], 'cgmNode')
#> Name...
i_follicleTrans.doStore('cgmName', mObj)
i_follicleTrans.doStore('cgmTypeModifier', 'surfaceTrack')
i_follicleTrans.doName()
_trackTransform = i_follicleTrans.mNode
#>Set follicle value...
if d_closest['type'] == 'mesh':
i_follicleShape.parameterU = d_closest['parameterU']
i_follicleShape.parameterV = d_closest['parameterV']
else:
i_follicleShape.parameterU = d_closest['normalizedU']
i_follicleShape.parameterV = d_closest['normalizedV']
_res = [i_follicleTrans.mNode, i_follicleShape.mNode]
md_res['mFollicle'] = i_follicleTrans
md_res['mFollicleShape'] = i_follicleShape
else:
log.debug("|{0}| >> Curve mode...".format(_str_func))
#d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv)
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
mPOCI = cgmMeta.cgmNode(nodeType='pointOnCurveInfo')
mc.connectAttr("%s.worldSpace" % _shape,
"%s.inputCurve" % mPOCI.mNode)
mPOCI.parameter = d_closest['parameter']
mTrack = mObj.doCreateAt()
mTrack.doStore('cgmName', mObj)
mTrack.doStore('cgmType', 'surfaceTrack')
mTrack.doName()
_trackTransform = mTrack.mNode
mc.connectAttr("%s.position" % mPOCI.mNode,
"%s.t" % _trackTransform)
mPOCI.doStore('cgmName', mObj)
mPOCI.doName()
_res = [mTrack.mNode, mPOCI.mNode]
if mDriver:
if d_closest['type'] in ['nurbsSurface']:
mFollicle = i_follicleTrans
mFollShape = i_follicleShape
minU = ATTR.get(_shape, 'minValueU')
maxU = ATTR.get(_shape, 'maxValueU')
minV = ATTR.get(_shape, 'minValueV')
maxV = ATTR.get(_shape, 'maxValueV')
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
#mLoc = mObj.doLoc()
str_baseName = "{0}_to_{1}".format(mDriver.p_nameBase,
mObj.p_nameBase)
mPlug_normalizedU = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumU = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_normalizedV = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumV = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
#res_closest = DIST.create_closest_point_node(mLoc.mNode, mCrv_reparam.mNode,True)
log.debug("|{0}| >> Closest info {1}".format(_str_func, _res))
srfNode = mc.createNode('closestPointOnSurface')
mc.connectAttr("%s.worldSpace[0]" % _shape,
"%s.inputSurface" % srfNode)
mc.connectAttr("%s.translate" % mDriverLoc.mNode,
"%s.inPosition" % srfNode)
#mc.connectAttr("%s.position" % srfNode, "%s.translate" % mLoc.mNode, f=True)
#mClosestPoint = cgmMeta.validateObjArg(srfNode,setClass=True)
#mClosestPoint.doStore('cgmName',mObj)
#mClosestPoint.doName()
log.debug("|{0}| >> paramU {1}.parameterU | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterU')))
log.debug("|{0}| >> paramV {1}.parameterV | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterV')))
l_argBuild = []
mPlug_uSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_uSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_vSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_vSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_vSize.p_combinedName, maxV, minV))
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_uSize.p_combinedName, maxU, minU))
l_argBuild.append("{0} = {1} + {2}.parameterU".format(
mPlug_sumU.p_combinedName, minU, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedU.p_combinedName,
mPlug_sumU.p_combinedName, mPlug_uSize.p_combinedName))
l_argBuild.append("{0} = {1} + {2}.parameterV".format(
mPlug_sumV.p_combinedName, minV, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedV.p_combinedName,
mPlug_sumV.p_combinedName, mPlug_vSize.p_combinedName))
for arg in l_argBuild:
log.debug("|{0}| >> Building arg: {1}".format(
_str_func, arg))
NODEFACTORY.argsToNodes(arg).doBuild()
ATTR.connect(mPlug_normalizedU.p_combinedShortName,
'{0}.parameterU'.format(mFollShape.mNode))
ATTR.connect(mPlug_normalizedV.p_combinedShortName,
'{0}.parameterV'.format(mFollShape.mNode))
md_res['mDriverLoc'] = mDriverLoc
elif d_closest['type'] in ['curve', 'nurbsCurve']:
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
_resClosest = DIST.create_closest_point_node(
mDriverLoc.mNode, _shape, True)
_loc = _resClosest[0]
md_res['mDriverLoc'] = mDriverLoc
md_res['mDrivenLoc'] = cgmMeta.asMeta(_loc)
md_res['mTrack'] = mTrack
else:
log.warning(
cgmGEN.logString_msg(
_str_func,
"Shape type not currently supported for driver setup. Type: {0}"
.format(d_closest['type'])))
#if connectBy is None:
#return _res
if connectBy == 'parent':
mObj.p_parent = _trackTransform
elif connectBy == 'conPoint':
mc.pointConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'conParent':
mc.parentConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'parentGroup':
mGroup = mObj.doGroup(asMeta=True)
#_grp = TRANS.group_me(obj,True)
#TRANS.parent_set(_grp,_trackTransform)
mGroup.p_parent = _trackTransform
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointOrientGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
mc.orientConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conParentGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.parentConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy is None:
pass
else:
raise NotImplementedError, "|{0}| >>invalid connectBy: {1}".format(
_str_func, connectBy)
if md_res:
return _res, md_res
return _res
#pprint.pprint(vars())
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def split_blends(driven1=None,
driven2=None,
sealDriver1=None,
sealDriver2=None,
sealDriverMid=None,
nameSeal1='left',
nameSeal2='right',
nameSealMid='center',
maxValue=10.0,
inTangent='auto',
outTangent='auto',
settingsControl=None,
buildNetwork=True):
"""
Split for blend data
"""
try:
_str_func = 'split_blends'
d_dat = {
1: {
'dist1': [],
'dist2': [],
'distMid': []
},
2: {
'dist1': [],
'dist2': [],
'distMid': []
}
}
_lock = False
_hidden = False
#>>> Verify ===================================================================================
log.debug("|{0}| >> driven1 [Check]...".format(_str_func))
d_dat[1]['driven'] = cgmMeta.validateObjListArg(driven1,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
log.debug("|{0}| >> driven2 [Check]...".format(_str_func))
d_dat[2]['driven'] = cgmMeta.validateObjListArg(driven2,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
mSettings = cgmMeta.validateObjArg(settingsControl, 'cgmObject')
if buildNetwork:
log.debug(
"|{0}| >> buildNetwork | building driver attrs...".format(
_str_func))
mPlug_sealMid = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSealMid),
attrType='float',
minValue=0.0,
maxValue=maxValue,
lock=False,
keyable=True)
mPlug_seal1 = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSeal1),
attrType='float',
minValue=0.0,
maxValue=maxValue,
lock=False,
keyable=True)
mPlug_seal2 = cgmMeta.cgmAttr(mSettings.mNode,
'seal_{0}'.format(nameSeal2),
attrType='float',
minValue=0.0,
maxValue=maxValue,
lock=False,
keyable=True)
pos1 = POS.get(sealDriver1)
pos2 = POS.get(sealDriver2)
posMid = POS.get(sealDriverMid)
normMin = maxValue * .1
normMax = maxValue - normMin
for idx, dat in d_dat.iteritems():
mDriven = dat['driven']
d_tmp = {
'dist1': {
'pos': pos1,
'res': dat['dist1']
},
'dist2': {
'pos': pos2,
'res': dat['dist2']
},
'distMid': {
'pos': posMid,
'res': dat['distMid']
},
}
for mObj in mDriven:
for n, d in d_tmp.iteritems():
dTmp = DIST.get_distance_between_points(
d['pos'], mObj.p_position)
if MATH.is_float_equivalent(dTmp, 0.0):
dTmp = 0.0
d['res'].append(dTmp)
dat['dist1Norm'] = MATH.normalizeList(dat['dist1'], normMax)
dat['dist2Norm'] = MATH.normalizeList(dat['dist2'], normMax)
dat['distMidNorm'] = MATH.normalizeList(dat['distMid'], normMax)
dat['dist1On'] = [v + normMin for v in dat['dist1Norm']]
dat['dist2On'] = [v + normMin for v in dat['dist2Norm']]
dat['distMidOn'] = [v + normMin for v in dat['distMidNorm']]
if buildNetwork:
log.debug(
"|{0}| >> buildNetwork | building driver attrs...".format(
_str_func))
dat['mPlugs'] = {
'1': {},
'2': {},
'mid': {},
'on': {},
'off': {},
'sum': {}
}
for i, mObj in enumerate(mDriven):
log.debug("|{0}| >> buildNetwork | On: {1}".format(
_str_func, mObj) + cgmGEN._str_subLine)
dat['mPlugs']['1'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_blend{2}'.format(idx, i, '1'),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
dat['mPlugs']['2'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_blend{2}'.format(idx, i, '2'),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
dat['mPlugs']['mid'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_blend{2}'.format(idx, i, 'mid'),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
dat['mPlugs']['on'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_on'.format(idx, i),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
dat['mPlugs']['off'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_off'.format(idx, i),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
dat['mPlugs']['sum'][i] = cgmMeta.cgmAttr(
mSettings,
'set{0}_idx{1}_sum'.format(idx, i),
attrType='float',
keyable=False,
lock=_lock,
hidden=_hidden)
args = []
args.append("{0} = {1} + {2} + {3}".format(
dat['mPlugs']['sum'][i].p_combinedShortName,
dat['mPlugs']['1'][i].p_combinedShortName,
dat['mPlugs']['2'][i].p_combinedShortName,
dat['mPlugs']['mid'][i].p_combinedShortName))
args.append("{0} = clamp(0 , 1.0, {1}".format(
dat['mPlugs']['on'][i].p_combinedShortName,
dat['mPlugs']['sum'][i].p_combinedShortName,
))
args.append("{0} = 1.0 - {1}".format(
dat['mPlugs']['off'][i].p_combinedShortName,
dat['mPlugs']['on'][i].p_combinedShortName,
))
for a in args:
NODEFACTORY.argsToNodes(a).doBuild()
log.debug("|{0}| >> buildNetwork | On: {1}".format(
_str_func, mObj))
zeroMid = 0
zero1 = 0
zero2 = 0
if i:
zero1 = dat['dist1On'][i - 1]
try:
zero2 = dat['dist2On'][i + 1]
except:
zero2 = 0
#zero1 = MATH.Clamp(dat['dist1On'][i-1],normMin,maxValue)
#zero2 = MATH.Clamp(dat['dist2On'][i-1],normMin,maxValue)
mc.setDrivenKeyframe(
dat['mPlugs']['1'][i].p_combinedShortName,
currentDriver=mPlug_seal1.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=zero1,
value=0.0)
mc.setDrivenKeyframe(
dat['mPlugs']['1'][i].p_combinedShortName,
currentDriver=mPlug_seal1.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=dat['dist1On'][i],
value=1.0)
mc.setDrivenKeyframe(
dat['mPlugs']['2'][i].p_combinedShortName,
currentDriver=mPlug_seal2.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=zero2,
value=0.0)
mc.setDrivenKeyframe(
dat['mPlugs']['2'][i].p_combinedShortName,
currentDriver=mPlug_seal2.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=dat['dist2On'][i],
value=1.0)
last1 = dat['dist1On'][i]
last2 = dat['dist2On'][i]
mc.setDrivenKeyframe(
dat['mPlugs']['mid'][i].p_combinedShortName,
currentDriver=mPlug_sealMid.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=zeroMid,
value=0.0)
mc.setDrivenKeyframe(
dat['mPlugs']['mid'][i].p_combinedShortName,
currentDriver=mPlug_sealMid.p_combinedShortName,
itt=inTangent,
ott=outTangent,
driverValue=dat['distMidOn'][i],
value=1.0)
#pprint.pprint(d_dat)
#return d_dat
for idx, dat in d_dat.iteritems():
for plugSet, mSet in dat['mPlugs'].iteritems():
for n, mPlug in mSet.iteritems():
mPlug.p_lock = True
mPlug.p_hidden = True
return d_dat
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def createJoints(self, mode='each'):
_str_func = 'createJoints'
_d = uiFunc_getCreateData(self)
_sel = MMCONTEXT.get_list()
if not _sel:
return log.error("|{0}| >> Nothing selected".format(_str_func))
_resplit = _d['resplit']
_splitMode = ['linear', 'curve', 'sub'][_d['resplit'] - 1]
if mode != 'curve':
if _splitMode == 'sub':
if len(_sel) == 1:
_buffer = mc.listRelatives(_sel[0], type='joint')
if _buffer:
_sel.append(_buffer[0])
elif len(_sel) < 2:
return log.error(
"|{0}| >> Need more objects for resplitting 'each' mode. ".
format(_str_func))
log.info("|{0}| >> mode: {1}".format(_str_func, mode))
mc.select(cl=True)
#pprint.pprint(_sel)
if mode == 'curve':
for o in _sel:
mObj = cgmMeta.validateObjArg(o, 'cgmObject')
for mShape in mObj.getShapes(asMeta=True):
_type = mShape.getMayaType()
if _type == 'nurbsCurve':
JOINTS.build_chain(curve=mShape.mNode,
axisAim=_d['aim'],
axisUp=_d['up'],
worldUpAxis=_d['world'],
count=_d['count'],
splitMode='curveCast',
parent=_d['parent'],
orient=_d['orient'],
progressBar=self.uiPB_cgmJointTools,
relativeOrient=_d['relativeOrient'])
else:
log.warning(
"|{0}| >> shape: {1} | invalid type: {2}".format(
_str_func, mShape.mNode, _type))
elif mode == 'each':
#posList = [POS.get(o) for o in _sel]
if not _resplit:
log.info("|{0}| >> No resplit...".format(_str_func))
JOINTS.build_chain(targetList=_sel,
axisAim=_d['aim'],
axisUp=_d['up'],
worldUpAxis=_d['world'],
parent=_d['parent'],
orient=_d['orient'],
progressBar=self.uiPB_cgmJointTools,
relativeOrient=_d['relativeOrient'])
else:
log.info("|{0}| >> resplit...".format(_str_func))
if _splitMode == 'sub':
count = _d['count'] #+ len(_sel)
else:
count = _d['count']
JOINTS.build_chain(targetList=_sel,
axisAim=_d['aim'],
axisUp=_d['up'],
worldUpAxis=_d['world'],
count=count,
splitMode=_splitMode,
parent=_d['parent'],
orient=_d['orient'],
progressBar=self.uiPB_cgmJointTools,
relativeOrient=_d['relativeOrient'])
else:
raise ValueError, "Unknown mode: {0}".format(mode)
mc.select(_sel)
def attach_toShape(obj = None, targetShape = None, connectBy = 'parent'):
"""
:parameters:
obj - transform to attach
targetShape(str) - Curve, Nurbs, Mesh
connectBy(str)
parent - parent to track transform
parentGroup - parent to group and have group follow
conPoint - just point contraint
conPointGroup - pointConstrain group
conPointOrientGroup - point/orient constrain group
conParentGroup - parent Constrain group
None - just the tracker nodes
:returns:
resulting dat
"""
try:
_str_func = 'attach_toShape'
mObj = cgmMeta.validateObjArg(obj,'cgmObject')
targetShape = VALID.mNodeString(targetShape)
log.debug("targetShape: {0}".format(targetShape))
#Get our data...
d_closest = DIST.get_closest_point_data(targetShape,
mObj.mNode)
log.debug("|{0}| >> jnt: {1} | {2}".format(_str_func,mObj.mNode, d_closest))
#pprint.pprint(d_closest)
if d_closest['type'] in ['mesh','nurbsSurface']:
log.debug("|{0}| >> Follicle mode...".format(_str_func))
_shape = SHAPES.get_nonintermediate(d_closest['shape'] )
log.debug("_shape: {0}".format(_shape))
l_follicleInfo = NODES.createFollicleOnMesh( _shape )
i_follicleTrans = cgmMeta.asMeta(l_follicleInfo[1],'cgmObject',setClass=True)
i_follicleShape = cgmMeta.asMeta(l_follicleInfo[0],'cgmNode')
#> Name...
i_follicleTrans.doStore('cgmName',mObj)
i_follicleTrans.doStore('cgmTypeModifier','surfaceTrack')
i_follicleTrans.doName()
_trackTransform = i_follicleTrans.mNode
#>Set follicle value...
if d_closest['type'] == 'mesh':
i_follicleShape.parameterU = d_closest['parameterU']
i_follicleShape.parameterV = d_closest['parameterV']
else:
i_follicleShape.parameterU = d_closest['normalizedU']
i_follicleShape.parameterV = d_closest['normalizedV']
_res = [i_follicleTrans.mNode, i_follicleShape.mNode]
else:
log.debug("|{0}| >> Curve mode...".format(_str_func))
#d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv)
_shape = SHAPES.get_nonintermediate(d_closest['shape'] )
mPOCI = cgmMeta.cgmNode(nodeType = 'pointOnCurveInfo')
mc.connectAttr("%s.worldSpace"%_shape,"%s.inputCurve"%mPOCI.mNode)
mPOCI.parameter = d_closest['parameter']
mTrack = mObj.doCreateAt()
mTrack.doStore('cgmName',mObj)
mTrack.doStore('cgmType','surfaceTrack')
mTrack.doName()
_trackTransform = mTrack.mNode
mc.connectAttr("%s.position"%mPOCI.mNode,"%s.t"%_trackTransform)
mPOCI.doStore('cgmName',mObj)
mPOCI.doName()
_res = [mTrack.mNode, mPOCI.mNode]
if connectBy is None:
return _res
elif connectBy == 'parent':
mObj.p_parent = _trackTransform
return _res
elif connectBy == 'conPoint':
mc.pointConstraint(_trackTransform, mObj.mNode,maintainOffset = True)
return _res
elif connectBy == 'conParent':
mc.parentConstraint(_trackTransform, mObj.mNode,maintainOffset = True)
return _res
elif connectBy == 'parentGroup':
mGroup = mObj.doGroup(asMeta=True)
#_grp = TRANS.group_me(obj,True)
#TRANS.parent_set(_grp,_trackTransform)
mGroup.p_parent = _trackTransform
return _res + [mGroup.mNode]
elif connectBy == 'conPointGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
elif connectBy == 'conPointOrientGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode,mGroup.mNode)
mc.orientConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
elif connectBy == 'conParentGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.parentConstraint(mLoc.mNode,mGroup.mNode)
return _res + [mGroup.mNode]
else:
raise NotImplementedError,"|{0}| >>invalid connectBy: {1}".format(_str_func,connectBy)
#pprint.pprint(vars())
except Exception,err:cgmGEN.cgmExceptCB(Exception,err)
def __func__(self):
"""
"""
_str_funcName = self._str_funcCombined
curve = self.d_kws['curve']
points = self.d_kws['points']
mi_crv = cgmMeta.validateObjArg(self.d_kws['curve'],cgmMeta.cgmObject,mayaType='nurbsCurve',noneValid=False)
int_points = cgmValid.valueArg(self.d_kws['points'],minValue=1,calledFrom = _str_funcName)
f_insetSplitFactor = cgmValid.valueArg(self.d_kws['insetSplitFactor'],calledFrom = _str_funcName)
f_startSplitFactor = cgmValid.valueArg(self.d_kws['startSplitFactor'],calledFrom = _str_funcName)
f_kwMinU = cgmValid.valueArg(self.d_kws['minU'], noneValid=True, calledFrom = _str_funcName)
f_kwMaxU = cgmValid.valueArg(self.d_kws['maxU'], noneValid=True, calledFrom = _str_funcName)
f_points = float(int_points)
int_spans = int(cgmValid.valueArg(self.d_kws['points'],minValue=5,autoClamp=True,calledFrom = _str_funcName))
b_rebuild = cgmValid.boolArg(self.d_kws['rebuildForSplit'],calledFrom = _str_funcName)
b_markPoints = cgmValid.boolArg(self.d_kws['markPoints'],calledFrom = _str_funcName)
b_reverseCurve = cgmValid.boolArg(self.d_kws['reverseCurve'],calledFrom = _str_funcName)
try:#>>> Rebuild curve
if b_rebuild:
useCurve = mc.rebuildCurve (curve, ch=0, rpo=0, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001)[0]
else:
useCurve = mc.duplicate(curve)[0]
if b_reverseCurve:
useCurve = mc.reverseCurve(useCurve,rpo = True)[0]
except Exception,error:raise StandardError,"Rebuild fail | %s"%error
try:#>>> Divide stuff
#==========================
l_spanUPositions = []
str_bufferU = mc.ls("%s.u[*]"%useCurve)[0]
log.debug("%s >> u list : %s"%(_str_funcName,str_bufferU))
f_maxU = float(str_bufferU.split(':')[-1].split(']')[0])
l_uValues = [0]
if points == 1:
l_uValues = [f_maxU/2]
elif f_startSplitFactor is not False:
if points < 5:
raise StandardError,"Need at least 5 points for startSplitFactor. Points : %s"%(points)
log.debug("%s >> f_startSplitFactor : %s"%(_str_funcName,f_startSplitFactor))
#Figure out our u's
f_base = f_startSplitFactor * f_maxU
l_uValues.append( f_base )
f_len = f_maxU - (f_base *2)
int_toMake = f_points-4
f_factor = f_len/(int_toMake+1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_len : %s"%(_str_funcName,f_len))
log.debug("%s >> int_toMake : %s"%(_str_funcName,int_toMake))
log.debug("%s >> f_base : %s"%(_str_funcName,f_base))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-3):
l_uValues.append(((i*f_factor + f_base)))
l_uValues.append(f_maxU - f_base)
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
elif f_insetSplitFactor is not False:
log.debug("%s >> f_insetSplitFactor : %s"%(_str_funcName,f_insetSplitFactor))
#Figure out our u's
f_base = f_insetSplitFactor * f_maxU
f_len = f_maxU - (f_base *2)
f_factor = f_len/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_len : %s"%(_str_funcName,f_len))
log.debug("%s >> f_base : %s"%(_str_funcName,f_base))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append((i*f_factor))
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
elif f_kwMinU is not False or f_kwMaxU is not False:
log.debug("%s >> Sub mode. "%(_str_funcName))
if f_kwMinU is not False:
if f_kwMinU > f_maxU:
raise StandardError, "kw minU value(%s) cannot be greater than maxU(%s)"%(f_kwMinU,f_maxU)
f_useMinU = f_kwMinU
else:f_useMinU = 0.0
if f_kwMaxU is not False:
if f_kwMaxU > f_maxU:
raise StandardError, "kw maxU value(%s) cannot be greater than maxU(%s)"%(f_kwMaxU,f_maxU)
f_useMaxU = f_kwMaxU
else:f_useMaxU = f_maxU
if int_points == 1:
l_uValues = [(f_useMaxU - f_useMinU)/2]
elif int_points == 2:
l_uValues = [f_useMaxU,f_useMinU]
else:
l_uValues = [f_useMinU]
f_factor = (f_useMaxU - f_useMinU)/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_useMaxU))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append((i*f_factor) + f_useMinU)
l_uValues.append(f_useMaxU)
else:
#Figure out our u's
log.debug("%s >> Regular mode. Points = %s "%(_str_funcName,int_points))
if int_points == 3:
l_uValues.append(f_maxU/2)
l_uValues.append(f_maxU)
else:
f_factor = f_maxU/(f_points-1)
log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU))
log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor))
for i in range(1,int_points-1):
l_uValues.append(i*f_factor)
l_uValues.append(f_maxU)
log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues))
except Exception,error:raise StandardError,"Divide fail | %s"%error
for u in l_uValues:
try:l_spanUPositions.append(mc.pointPosition("%s.u[%f]"%(useCurve,u)))
except StandardError,error:raise StandardError,"Failed on pointPositioning: %s"%u
log.debug("%s >> l_spanUPositions | len: %s | list: %s"%(_str_funcName,len(l_spanUPositions),l_spanUPositions))
try:
if b_markPoints:
ml_built = []
for i,pos in enumerate(l_spanUPositions):
buffer = mc.spaceLocator(n = "%s_u_%f"%(useCurve,(l_uValues[i])))[0]
ml_built.append( cgmMeta.cgmObject(buffer))
log.debug("%s >> created : %s | at: %s"%(_str_funcName,ml_built[-1].p_nameShort,pos))
mc.xform(ml_built[-1].mNode, t = (pos[0],pos[1],pos[2]), ws=True)
if len(ml_built)>1:
try:f_distance = distance.returnAverageDistanceBetweenObjects([o.mNode for o in ml_built]) * .5
except StandardError,error:raise StandardError,"Average distance fail. Objects: %s| error: %s"%([o.mNode for o in ml_built],error)
try:
for o in ml_built:
o.scale = [f_distance,f_distance,f_distance]
except StandardError,error:raise StandardError,"Scale fail : %s"%error
except StandardError,error:log.error("Mark points fail. error : %s"%(error))
mc.delete(useCurve)#Delete our use curve
return l_spanUPositions
def ik_rp(self,
mStart,
mEnd,
ml_ikFrame=None,
mIKControl=None,
mIKBaseControl=None,
mIKHandleDriver=None,
mRoot=None,
mIKGroup=None,
mIKControlEnd=None,
ml_ikFullChain=None):
try:
_str_func = "ik_rp"
log.debug("|{0}| >> {1}...".format(_str_func, _str_func) + '-' * 60)
mRigNull = self.mRigNull
mBlock = self.mBlock
if not ml_ikFrame:
ml_ikFrame = self.ml_handleTargetsCulled
if not mIKControl:
raise ValueError, "Must have mIKControl"
if not mIKHandleDriver:
raise ValueError, "Must have mIKHandleDriver"
if not mRoot:
raise ValueError, "Must have mRoot"
log.debug("|{0}| >> rp setup...".format(_str_func))
mIKMid = mRigNull.controlIKMid
str_ikEnd = mBlock.getEnumValueString('ikEnd')
#Measture ======================================================
log.debug("|{0}| >> measure... ".format(_str_func) + '-' * 30)
res_ikScale = self.UTILS.get_blockScale(
self, '{0}_ikMeasure'.format(self.d_module['partName'], ),
ml_ikFrame)
mPlug_masterScale = res_ikScale[0]
mMasterCurve = res_ikScale[1]
mMasterCurve.p_parent = mRoot
self.fnc_connect_toRigGutsVis(mMasterCurve)
mMasterCurve.dagLock(True)
#Unparent the children from the end while we set stuff up...
log.debug("|{0}| >> end unparent ...".format(_str_func) + '-' * 30)
ml_end_children = mEnd.getChildren(asMeta=True)
if ml_end_children:
for mChild in ml_end_children:
mChild.parent = False
#Build the IK ---------------------------------------------------------------------
reload(IK)
"""
if mIKControlEnd and str_ikEnd in ['tipCombo']:
mMainIKControl = mIKControlEnd
else:
mMainIKControl = mIKControl
"""
_d_ik = {
'globalScaleAttr': mPlug_masterScale.
p_combinedName, #mPlug_globalScale.p_combinedName,
'stretch': 'translate',
'lockMid': True,
'rpHandle': mIKMid.mNode,
'nameSuffix': 'ik',
'baseName': '{0}_ikRP'.format(self.d_module['partName']),
'controlObject': mIKControl.mNode,
'moduleInstance': self.mModule.mNode
}
d_ikReturn = IK.handle(mStart.mNode, mEnd.mNode, **_d_ik)
mIKHandle = d_ikReturn['mHandle']
ml_distHandlesNF = d_ikReturn['ml_distHandles']
mRPHandleNF = d_ikReturn['mRPHandle']
#>>>Parent IK handles -----------------------------------------------------------------
log.debug("|{0}| >> parent IK stuff ...".format(_str_func) + '-' * 30)
mIKHandle.parent = mIKHandleDriver.mNode #handle to control
for mObj in ml_distHandlesNF[:-1]:
mObj.parent = mRoot
ml_distHandlesNF[-1].parent = mIKHandleDriver.mNode #handle to control
ml_distHandlesNF[1].parent = mIKMid
ml_distHandlesNF[1].t = 0, 0, 0
ml_distHandlesNF[1].r = 0, 0, 0
if mIKBaseControl:
ml_distHandlesNF[0].parent = mIKBaseControl
#>>> Fix our ik_handle twist at the end of all of the parenting
IK.handle_fixTwist(mIKHandle,
self.d_orientation['str'][0]) #Fix the twist
if mIKControlEnd:
mIKEndDriver = mIKControlEnd
else:
mIKEndDriver = mIKControl
if ml_end_children:
for mChild in ml_end_children:
mChild.parent = mEnd
#mc.scaleConstraint([mIKControl.mNode],
# ml_ikFrame[self.int_handleEndIdx].mNode,
# maintainOffset = True)
#if mIKBaseControl:
#ml_ikFrame[0].parent = mRigNull.controlIKBase
#if mIKBaseControl:
#mc.pointConstraint(mIKBaseControl.mNode, ml_ikFrame[0].mNode,maintainOffset=True)
#Make a spin group ===========================================================
log.debug("|{0}| >> spin group ...".format(_str_func) + '-' * 30)
mSpinGroup = mStart.doGroup(False, False, asMeta=True)
mSpinGroup.doCopyNameTagsFromObject(self.mModule.mNode,
ignore=['cgmName', 'cgmType'])
mSpinGroup.addAttr('cgmName',
'{0}NoFlipSpin'.format(self.d_module['partName']))
mSpinGroup.doName()
ATTR.set(mSpinGroup.mNode, 'rotateOrder', self.d_orientation['str'])
mSpinGroup.parent = mIKGroup
mSpinGroup.doGroup(True, True, typeModifier='zero')
mSpinGroupAdd = mSpinGroup.doDuplicate()
mSpinGroupAdd.doStore('cgmTypeModifier', 'addSpin')
mSpinGroupAdd.doName()
mSpinGroupAdd.p_parent = mSpinGroup
if mIKBaseControl:
mc.pointConstraint(mIKBaseControl.mNode,
mSpinGroup.mNode,
maintainOffset=True)
#Setup arg
#mPlug_spin = cgmMeta.cgmAttr(mIKControl,'spin',attrType='float',keyable=True, defaultValue = 0, hidden = False)
#mPlug_spin.doConnectOut("%s.r%s"%(mSpinGroup.mNode,_jointOrientation[0]))
mSpinTarget = mIKControl
if mBlock.getMayaAttr('ikRPAim'):
mc.aimConstraint(mSpinTarget.mNode,
mSpinGroup.mNode,
maintainOffset=False,
aimVector=[0, 0, 1],
upVector=[0, 1, 0],
worldUpType='none')
else:
mc.aimConstraint(mSpinTarget.mNode,
mSpinGroup.mNode,
maintainOffset=False,
aimVector=[0, 0, 1],
upVector=[0, 1, 0],
worldUpObject=mSpinTarget.mNode,
worldUpType='objectrotation',
worldUpVector=self.v_twistUp)
mPlug_spinMid = cgmMeta.cgmAttr(mSpinTarget,
'spinMid',
attrType='float',
defaultValue=0,
keyable=True,
lock=False,
hidden=False)
_direction = self.d_module.get('direction') or 'center'
if _direction.lower() == 'right':
str_arg = "{0}.r{1} = -{2}".format(
mSpinGroupAdd.mNode, self.d_orientation['str'][0].lower(),
mPlug_spinMid.p_combinedShortName)
log.debug("|{0}| >> Right knee spin: {1}".format(
_str_func, str_arg))
NODEFACTORY.argsToNodes(str_arg).doBuild()
else:
mPlug_spinMid.doConnectOut("{0}.r{1}".format(
mSpinGroupAdd.mNode, self.d_orientation['str'][0]))
mSpinGroup.dagLock(True)
mSpinGroupAdd.dagLock(True)
#>>> mBallRotationControl ==========================================================
mIKBallRotationControl = mRigNull.getMessageAsMeta(
'controlBallRotation')
if mIKBallRotationControl: # and str_ikEnd not in ['tipCombo']:
log.debug("|{0}| >> mIKBallRotationControl...".format(_str_func) +
'-' * 30)
mBallOrientGroup = cgmMeta.validateObjArg(
mIKBallRotationControl.doGroup(True,
False,
asMeta=True,
typeModifier='orient'),
'cgmObject',
setClass=True)
ATTR.set(mBallOrientGroup.mNode, 'rotateOrder',
self.d_orientation['str'])
mLocBase = mIKBallRotationControl.doCreateAt()
mLocAim = mIKBallRotationControl.doCreateAt()
mLocAim.doStore('cgmTypeModifier', 'extendedIK')
mLocBase = mIKBallRotationControl.doCreateAt()
mLocBase.doName()
mLocAim.doName()
mLocAim.p_parent = ml_ikFullChain[-1]
mLocBase.p_parent = mIKBallRotationControl.masterGroup
const = mc.orientConstraint([mLocAim.mNode, mLocBase.mNode],
mBallOrientGroup.mNode,
maintainOffset=True)[0]
d_blendReturn = NODEFACTORY.createSingleBlendNetwork(
[mIKControl.mNode, 'extendIK'],
[mIKControl.mNode, 'resRootFollow'],
[mIKControl.mNode, 'resFullFollow'],
keyable=True)
targetWeights = mc.orientConstraint(const,
q=True,
weightAliasList=True,
maintainOffset=True)
#Connect
d_blendReturn['d_result1']['mi_plug'].doConnectOut(
'%s.%s' % (const, targetWeights[0]))
d_blendReturn['d_result2']['mi_plug'].doConnectOut(
'%s.%s' % (const, targetWeights[1]))
d_blendReturn['d_result1']['mi_plug'].p_hidden = True
d_blendReturn['d_result2']['mi_plug'].p_hidden = True
mBallOrientGroup.dagLock(True)
mLocAim.dagLock(True)
mLocBase.dagLock(True)
mIKBallRotationControl.p_parent = mBallOrientGroup
#Joint constraint -------------------------
mIKBallRotationControl.masterGroup.p_parent = mPivotResultDriver
mc.orientConstraint([mIKBallRotationControl.mNode],
ml_ikFrame[self.int_handleEndIdx].mNode,
maintainOffset=True)
mc.parentConstraint([mPivotResultDriver.mNode],
ml_ikFrame[self.int_handleEndIdx + 1].mNode,
maintainOffset=True)
ATTR.set_default(mIKControl.mNode, 'extendIK', 1.0)
mIKControl.extendIK = 0.0
elif str_ikEnd == 'bank':
mc.orientConstraint([mPivotResultDriver.mNode],
ml_ikFrame[self.int_handleEndIdx].mNode,
maintainOffset=True)
elif str_ikEnd == 'pad':
mc.orientConstraint([mPivotResultDriver.mNode],
ml_ikFrame[self.int_handleEndIdx].mNode,
maintainOffset=True)
else:
mc.orientConstraint([mIKEndDriver.mNode],
ml_ikFrame[self.int_handleEndIdx].mNode,
maintainOffset=True)
#Mid IK driver -----------------------------------------------------------------------
log.debug("|{0}| >> mid Ik driver...".format(_str_func) + '-' * 30)
log.debug("|{0}| >> mid IK driver.".format(_str_func))
mMidControlDriver = mIKMid.doCreateAt()
mMidControlDriver.addAttr(
'cgmName', '{0}_midIK'.format(self.d_module['partName']))
mMidControlDriver.addAttr('cgmType', 'driver')
mMidControlDriver.doName()
mMidControlDriver.addAttr('cgmAlias', 'midDriver')
if mIKBaseControl:
l_midDrivers = [mIKBaseControl.mNode]
else:
l_midDrivers = [mRoot.mNode]
if str_ikEnd in ['tipCombo'] and mIKControlEnd:
log.debug("|{0}| >> mIKControlEnd + tipCombo...".format(_str_func))
l_midDrivers.append(mIKControl.mNode)
else:
l_midDrivers.append(mIKHandleDriver.mNode)
mc.pointConstraint(l_midDrivers, mMidControlDriver.mNode)
mMidControlDriver.parent = mSpinGroupAdd #mIKGroup
mIKMid.masterGroup.parent = mMidControlDriver
mMidControlDriver.dagLock(True)
#Mid IK trace
log.debug("|{0}| >> midIK track Crv".format(_str_func, mIKMid))
trackcrv, clusters = CORERIG.create_at(
[
mIKMid.mNode, ml_ikFrame[MATH.get_midIndex(
len(ml_ikFrame))].mNode
], #ml_handleJoints[1]],
'linearTrack',
baseName='{0}_midTrack'.format(self.d_module['partName']))
mTrackCrv = cgmMeta.asMeta(trackcrv)
mTrackCrv.p_parent = self.mModule
mHandleFactory = mBlock.asHandleFactory()
mHandleFactory.color(mTrackCrv.mNode, controlType='sub')
for s in mTrackCrv.getShapes(asMeta=True):
s.overrideEnabled = 1
s.overrideDisplayType = 2
mTrackCrv.doConnectIn('visibility', "{0}.v".format(mIKGroup.mNode))
#Full IK chain -----------------------------------------------------------------------
if ml_ikFullChain:
log.debug("|{0}| >> Full IK Chain...".format(_str_func))
_d_ik = {
'globalScaleAttr': mPlug_masterScale.
p_combinedName, #mPlug_globalScale.p_combinedName,
'stretch': 'translate',
'lockMid': False,
'rpHandle': mIKMid.mNode,
'baseName':
'{0}_ikFullChain'.format(self.d_module['partName']),
'nameSuffix': 'ikFull',
'controlObject': mIKControl.mNode,
'moduleInstance': self.mModule.mNode
}
d_ikReturn = IK.handle(ml_ikFullChain[0], ml_ikFullChain[-1],
**_d_ik)
mIKHandle = d_ikReturn['mHandle']
ml_distHandlesNF = d_ikReturn['ml_distHandles']
mRPHandleNF = d_ikReturn['mRPHandle']
mIKHandle.parent = mIKControl.mNode #handle to control
for mObj in ml_distHandlesNF[:-1]:
mObj.parent = mRoot
ml_distHandlesNF[-1].parent = mIKControl.mNode #handle to control
#ml_distHandlesNF[1].parent = mIKMid
#ml_distHandlesNF[1].t = 0,0,0
#ml_distHandlesNF[1].r = 0,0,0
#>>> Fix our ik_handle twist at the end of all of the parenting
IK.handle_fixTwist(mIKHandle,
self.d_orientation['str'][0]) #Fix the twist
#mIKControl.masterGroup.p_parent = ml_ikFullChain[-2]
######mc.parentConstraint([mIKControl.mNode], ml_ikFrame[-1].mNode, maintainOffset = True)
if mIKBaseControl:
ml_ikFrame[0].parent = mIKBaseControl
#if mIKBaseControl:
#mc.pointConstraint(mIKBaseControl.mNode, ml_ikFrame[0].mNode,maintainOffset=True)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def setup_defHelpJoint(targetJoint,orientation = 'zyx'):
"""
Setup a helper joint
@KWS
targetJoint(string/inst) -- must be helper joint
orientation(str)
forceNew(bool) -- delete if exists
helperTypes --
'halfHold' -- like a regular bend joint that needs a holder at it's root, like a finger
'childRootHold' -- holds form on a hard rotate, like a finger root
'halfPush' -- like a regular bend joint that needs a holder at it's root, like a finger
"""
mi_posLoc = False
if orientation != 'zyx':
raise NotImplementedError, "add_defHelpJoints >> only currently can do orienation of 'zyx'"
#Validate base info
mi_helperJoint = cgmMeta.validateObjArg(targetJoint,cgmMeta.cgmObject,mayaType='joint')
mi_targetJoint = cgmMeta.validateObjArg(mi_helperJoint.getMessage('defHelp_target'),cgmMeta.cgmObject,mayaType='joint')
mi_childJoint = cgmMeta.validateObjArg(mi_helperJoint.getMessage('defHelp_childTarget'),cgmMeta.cgmObject,mayaType='joint')
str_helperType = mi_helperJoint.getAttr('defHelpType')
if not str_helperType in __l_helperTypes__:
log.warning("%s.setup_defHelpJoint >> '%s' not a valid helperType: %s"%(mi_helperJoint.p_nameShort,str_helperType,__l_helperTypes__))
return False
log.debug(">>> %s.setup_defHelpJoint >> "%mi_helperJoint.p_nameShort + "="*75)
#>Setup
#----------------------------------------------------------------
if str_helperType == 'halfHold':
mi_helperJoint.tx = mi_childJoint.tx *.5
mi_helperJoint.ty = mi_childJoint.ty *.5
mi_helperJoint.tz = mi_childJoint.tz *.5
mi_helperJoint.__setattr__("t%s"%orientation[1],(-mi_childJoint.tz *.2))
#Setup sd
'''
""" set our keyframes on our curve"""
for channel in :
mc.setKeyframe (attributeHolder,sqshStrchAttribute, time = cnt, value = 1)
""" making the frame cache nodes """
frameCacheNodes.append(nodes.createNamedNode(jointChain[jnt],'frameCache'))
cnt+=1
""" connect it """
for cacheNode in frameCacheNodes:
mc.connectAttr((sqshStrchAttribute),(cacheNode+'.stream'))
cnt=1
""" set the vary time """
for cacheNode in frameCacheNodes:
mc.setAttr((cacheNode+'.varyTime'),cnt)
cnt+=1
'''
#With half hold, our driver is the child joint
str_driverRot = "%s.r%s"%(mi_childJoint.mNode,orientation[2])
str_drivenTransAim = "%s.t%s"%(mi_helperJoint.mNode,orientation[0])
f_baseTransValue = mi_helperJoint.getAttr("t%s"%(orientation[0]))
f_sdkTransValue = f_baseTransValue + (f_baseTransValue * .3)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 0,value = f_baseTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 110,value = f_sdkTransValue)
elif str_helperType == 'halfPush':
mi_helperJoint.tx = mi_childJoint.tx *.5
mi_helperJoint.ty = mi_childJoint.ty *.5
mi_helperJoint.tz = mi_childJoint.tz *.5
mi_helperJoint.__setattr__("t%s"%orientation[1],-(mi_childJoint.tz *.2))
#With half push, our driver is the target joint
str_driverRot = "%s.r%s"%(mi_targetJoint.mNode,orientation[2])
str_drivenTransAim = "%s.t%s"%(mi_helperJoint.mNode,orientation[0])
f_baseTransValue = mi_helperJoint.getAttr("t%s"%(orientation[0]))
f_sdkTransValue = f_baseTransValue + (f_baseTransValue * .3)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 0,value = f_baseTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 110,value = f_sdkTransValue)
elif str_helperType == 'childRootHold':
'''mi_helperJoint.__setattr__("t%s"%orientation[1],(-mi_childJoint.getMayaAttr("t%s"%(orientation[0])) *.2))
mi_helperJoint.parent = mi_targetJoint.parent
if not mi_posLoc:mi_posLoc = mi_helperJoint.doLoc()#Make sure we have a loc
mi_posLoc.parent = mi_helperJoint.mNode#Parent loc to i_dup to make sure we're in same space
f_baseUpTransValue = mi_helperJoint.getAttr("t%s"%(orientation[1]))
f_sdkUpTransValue = mi_childJoint.getAttr("t%s"%(orientation[0])) * -.25
f_baseAimTransValue = mi_helperJoint.getAttr("t%s"%(orientation[0]))
f_sdkAimTransValue = mi_childJoint.getAttr("t%s"%(orientation[0])) * -.5'''
mi_helperJoint.__setattr__("t%s"%orientation[1],(-mi_childJoint.getMayaAttr("t%s"%(orientation[0])) *.2))
mi_helperJoint.__setattr__("t%s"%orientation[0],(-mi_childJoint.getMayaAttr("t%s"%(orientation[0])) *.1))
mi_helperJoint.parent = mi_targetJoint.parent
if not mi_posLoc:mi_posLoc = mi_helperJoint.doLoc()#Make sure we have a loc
mi_posLoc.parent = mi_helperJoint.mNode#Parent loc to i_dup to make sure we're in same space
f_baseUpTransValue = mi_helperJoint.getAttr("t%s"%(orientation[1]))
f_sdkUpTransValue = mi_targetJoint.getAttr("t%s"%(orientation[0])) * -.05
f_baseAimTransValue = mi_helperJoint.getAttr("t%s"%(orientation[0]))
f_sdkAimTransValue = mi_targetJoint.getAttr("t%s"%(orientation[0])) * -.25
#Move the pos loc for our pose ----------------------------------
mi_posLoc.__setattr__("t%s"%orientation[0],f_sdkAimTransValue)
mi_posLoc.__setattr__("t%s"%orientation[1],f_sdkUpTransValue)
mi_posLoc.parent = mi_helperJoint.parent
#With childRootHold, our driver is the target joint --------------
str_driverRot = "%s.r%s"%(mi_targetJoint.mNode,orientation[2])
#Up ---------------------------------------------------------------
str_drivenTransUp = "%s.t%s"%(mi_helperJoint.mNode,orientation[1])
mc.setDrivenKeyframe(str_drivenTransUp,
currentDriver = str_driverRot,
driverValue = 0,value = f_baseUpTransValue)
mc.setDrivenKeyframe(str_drivenTransUp,
currentDriver = str_driverRot,
driverValue = 120,value = mi_posLoc.getAttr("t%s"%orientation[1]))
#Aim ---------------------------------------------------------------
str_drivenTransAim = "%s.t%s"%(mi_helperJoint.mNode,orientation[0])
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 0,value = f_baseAimTransValue)
mc.setDrivenKeyframe(str_drivenTransAim,
currentDriver = str_driverRot,
driverValue = 120,value = mi_posLoc.getAttr("t%s"%orientation[0]))
if mi_posLoc:mi_posLoc.delete()
return
slerp.SetAttr('percent', weight)
constraint.ConnectAttrIn('worldUpVector',
slerp.GetAttrString('output'))
constraint.SetAttr('aimVectorX', 0)
constraint.SetAttr('aimVectorY', 0)
constraint.SetAttr('aimVectorZ', 1)
constraint.SetAttr('upVectorX', 0)
constraint.SetAttr('upVectorY', 1)
constraint.SetAttr('upVectorZ', 0)
constraint = (node.GetNodeType(
mc.orientConstraint(controlNodes[-1].name,
jointNodes[-1].name,
mo=True)[0]))
constraints.append(constraint)
twistOnCurve(**_d_attach_l)
reload(SPECTRA)
for j in SPECTRA._d_handlesDynP['segmentJoints']:
mObj = cgmMeta.validateObjArg(j, 'cgmObject')
mObj.doStore('cgmAlias', 'followSeg')
for j in SPECTRA._d_handlesDynP['controls']:
mObj = cgmMeta.validateObjArg(j, 'cgmObject')
mObj.dynParentGroup.rebuild()
def rootOrCog(self, mHandle=None):
try:
_str_func = 'rootOrCog'
log_start(_str_func)
mBlock = self.mBlock
ml_prerigHandles = self.ml_prerigHandles
ml_formHandles = self.ml_formHandles
_offset = self.v_offset
if mBlock.getMessage('cogHelper') and mBlock.getMayaAttr('addCog'):
log.debug("|{0}| >> Cog...".format(_str_func))
mCogHelper = mBlock.cogHelper
mCog = mCogHelper.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mCog.mNode,
mCogHelper.shapeHelper.mNode)
#Cast a simple curve
#Cv's 4,2 |
ml_shapes = self.atBuilderUtils('shapes_fromCast',
targets=mCogHelper.shapeHelper,
offset=_offset * 2.0,
mode='singleCast') #'segmentHan
CORERIG.shapeParent_in_place(mCog.mNode, ml_shapes[0].mNode, False)
CORERIG.override_color(mCog.mNode, 'white')
mCog.doStore('cgmName',
'{0}_cog'.format(self.d_module['partName']))
mCog.doStore('cgmAlias', 'cog')
mCog.doName()
self.mRigNull.connectChildNode(mCog, 'rigRoot',
'rigNull') #Connect
self.mRigNull.connectChildNode(mCog, 'settings',
'rigNull') #Connect
else: #Root =============================================================================
log.debug("|{0}| >> Root...".format(_str_func))
mRootHandle = ml_prerigHandles[0]
#mRoot = ml_joints[0].doCreateAt()
ml_joints = self.d_joints['ml_moduleJoints']
mRoot = ml_joints[0].doCreateAt()
#_size_root = MATH.average(mHandleFactory.get_axisBox_size(ml_formHandles[0].mNode))
_bb_root = POS.get_bb_size(ml_formHandles[0].loftCurve.mNode, True)
_size_root = MATH.average(_bb_root)
mRootCrv = cgmMeta.validateObjArg(CURVES.create_fromName(
'cubeOpen', _size_root * 1.5),
'cgmObject',
setClass=True)
mRootCrv.doSnapTo(mRootHandle)
#SNAP.go(mRootCrv.mNode, ml_joints[0].mNode,position=False)
CORERIG.shapeParent_in_place(mRoot.mNode, mRootCrv.mNode, False)
mRoot.doStore('cgmName', self.d_module['partName'])
#ATTR.copy_to(self.mModule.mNode,'cgmName',mRoot.mNode,driven='target')
mRoot.doStore('cgmTypeModifier', 'root')
mRoot.doName()
self.mHandleFactory.color(mRoot.mNode, controlType='sub')
self.mRigNull.connectChildNode(mRoot, 'rigRoot',
'rigNull') #Connect
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def _gatherInfo_(self):
mi_go = self._go #Rig Go instance link
self.md_rigList = {}
self.str_mirrorSide = mi_go.verify_mirrorSideArg(
mi_go._direction) #Get the mirror side, shakes fist @ "Centre"
self.mi_helper = cgmMeta.validateObjArg(
mi_go._mi_module.getMessage('helper'), noneValid=True)
if not self.mi_helper:
raise StandardError, "No suitable helper found"
if not mi_go.isShaped():
raise StandardError, "Needs shapes to build controls"
if not mi_go.isRigSkeletonized():
raise StandardError, "Needs shapes to build controls"
self.md_rigList['fk_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_eyeballFK'),
cgmMeta.cgmObject)
self.md_rigList['ik_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_eyeballIK'),
cgmMeta.cgmObject)
self.md_rigList['settings_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_settings'),
cgmMeta.cgmObject)
self.md_rigList['eyeMove_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_eyeMove'),
cgmMeta.cgmObject)
self.md_rigList['pupil_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_pupil'), cgmMeta.cgmObject)
self.md_rigList['iris_shape'] = cgmMeta.validateObjArg(
mi_go._i_rigNull.getMessage('shape_iris'), cgmMeta.cgmObject)
#>> Find our joint lists ===================================================================
self.md_jointLists = {}
self.ml_rigJoints = mi_go._mi_module.rigNull.msgList_get(
'rigJoints')
self.md_rigList['eyeOrb'] = metaUtils.get_matchedListFromAttrDict(
self.ml_rigJoints, cgmName='eyeOrb')[0]
self.md_rigList['eye'] = metaUtils.get_matchedListFromAttrDict(
self.ml_rigJoints, cgmName='eye')[0]
l_pupil = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName='pupil')
if l_pupil:
self.md_rigList['pupil'] = l_pupil[0]
else:
#self.md_rigList['pupil_shape'].delete()
self.md_rigList['pupil'] = False
l_iris = metaUtils.get_matchedListFromAttrDict(self.ml_rigJoints,
cgmName='iris')
if l_iris:
self.md_rigList['iris'] = l_iris[0]
else:
#self.md_rigList['iris_shape'].delete()
self.md_rigList['iris'] = False
#>> Running lists ===========================================================================
self.ml_directControls = []
self.ml_controlsAll = []
def ik_base(self, ikBase=None, ml_baseJoints=None, ml_fkShapes=None):
try:
_str_func = 'segment_handles'
log_start(_str_func)
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
if ikBase == None:
ikBase = mBlock.getEnumValueString('ikBase')
if not ml_baseJoints:
raise ValueError, "{0} | ml_baseJoints required".format(_str_func)
log.debug("|{0}| >> {1} ...".format(_str_func, ikBase))
if ikBase in ['hips', 'simple']:
if ikBase == 'hips':
mIKBaseCrv = mBlock.ikStartHandle.doCreateAt(
setClass=True) #ml_baseJoints[1]
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,
ignore=['cgmType'])
mIKBaseCrv.doStore('cgmName', 'hips')
else:
mIKBaseCrv = mBlock.ikStartHandle.doCreateAt(setClass=True)
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,
ignore=['cgmType'])
CORERIG.shapeParent_in_place(mIKBaseCrv.mNode,
ml_fkShapes[0].mNode, True)
else:
log.debug("|{0}| >> default IK base shape...".format(_str_func))
mIK_formHandle = mBlock.ikStartHandle #ml_formHandles[ 0 ]
#bb_ik = mHandleFactory.get_axisBox_size(mIK_formHandle.mNode)
bb_ik = POS.get_bb_size(mIK_formHandle.mNode, True, mode='max')
_ik_shape = CURVES.create_fromName('cube', size=bb_ik)
ATTR.set(_ik_shape, 'scale', 1.1)
mIKBaseShape = cgmMeta.validateObjArg(_ik_shape,
'cgmObject',
setClass=True)
mIKBaseShape.doSnapTo(mIK_formHandle)
#pos_ik = POS.get_bb_center(mProxyHelper.mNode)
#SNAPCALLS.get_special_pos(mEndHandle.p_nameLong,
# 'axisBox','z+',False)
#mIKBaseShape.p_position = pos_ik
mIKBaseCrv = ml_baseJoints[0].doCreateAt()
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,
ignore=['cgmType'])
CORERIG.shapeParent_in_place(mIKBaseCrv.mNode, mIKBaseShape.mNode,
False)
mIKBaseCrv.doStore('cgmTypeModifier', 'ikBase')
mIKBaseCrv.doName()
self.mHandleFactory.color(mIKBaseCrv.mNode, controlType='main')
self.mRigNull.connectChildNode(mIKBaseCrv, 'controlIKBase',
'rigNull') #Connect
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
mc.setAttr('invalidMClass.mClass','noIdea',type = 'string')
o3 = r9Meta.MetaClass('invalidMClass')#...and instantiating it
o3#...it's gonna reuturn as a MetaClass because it's mClass is unknown
cgmMeta.cgmNode('invalidMClass')#...I can also call it as a cgmNode with no issue because no valid mClass is set
o3.mClass = 'cgmNode'#...if i set it's mClass to a known mClass however
r9Meta.MetaClass('invalidMClass')#...it's gonna now always return as a cgmNode as it's a valid mClass value
#...so, long story short. Manually changing a node's mClass attribute is not a reliable method of changing the type it instantiates to
#...The right way...
#r9's method
n3 = r9Meta.MetaClass(nodeType='network', name='r9Convert')#...let's make one via meta call
r9Meta.convertMClassType(n3,'cgmNode')#... This converts our node to a cgmNode type
#cgm's Method
cgmMeta.validateObjArg(n3.mNode,'MetaClass',setLogLevel = 'debug')#...this initially wont' change because our current class is a subclass of MetaClass, trust that this is a feature and not a bug
cgmMeta.validateObjArg(n3.mNode,'MetaClass',setClass = True, setLogLevel = 'debug')#...this pass will get it as we have our setClass flag on
cgmMeta.validateObjArg(n3.mNode,'cgmNode',setClass = True, setLogLevel = 'info')#...convert it back and get out of debug
#==============================================================================================
#>> Data storage
#==============================================================================================
mc.file(new=True,f=True)#...let's start with a clean file
#Go to the outliner and make sure DAG objects only is off
n1 = r9Meta.MetaClass(nodeType='network', name='r9Example')#...let's make one via meta call
#>>Json =========================================================================
d_test ={'jsonFloat':1.05,'Int':3,'jsonString':'string says hello','jsonBool':True}
n1.addAttr('jsonTest', d_test) #create a string attr with JSON serialized data
n1.jsonTest['jsonString'] #will deserialize the MayaNode jsonTest attr back to a dict and return its key['stringTest']
def ik_bankRollShapes(self):
try:
_str_func = 'bankRollShapes'
log.debug(cgmGEN.logString_sub(_str_func))
mBlock = self.mBlock
mRigNull = self.mRigNull
mHandleFactory = self.mHandleFactory
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
ml_fkShapes = []
mBallFK = False
mToeFK = False
mToeIK = False
mBallIK = False
_minRot = -90,
_maxRot = 90
mMesh_tmp = self.mBlock.atUtils('get_castMesh', pivotEnd=1)
str_meshShape = mMesh_tmp.getShapes()[0]
#if self.mPivotHelper:
# size_pivotHelper = POS.get_bb_size(self.mPivotHelper.mNode)
#else:
# size_pivotHelper = POS.get_bb_size(ml_formHandles[-1].mNode)
#reload(SHAPECASTER)
_d_cast = {
'vectorOffset': _offset,
'points': 15,
#'minRot':-90,'maxRot':90,
'closedCurve': False
}
_max = None
if self.mBall:
try:
_max = RAYS.get_dist_from_cast_axis(
self.mBall.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
except:
_max = 1
_d_cast['maxDistance'] = _max
crvBall = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mBall.mNode,
**_d_cast)
if not self.mToe:
pos = RAYS.get_cast_pos(self.mBall.mNode,
shapes=mMesh_tmp.mNode)
pos_me = self.mBall.p_position
dist = DIST.get_distance_between_points(pos, pos_me) / 2
pos_end = DIST.get_pos_by_vec_dist(pos_me, [0, 0, 1], dist)
mDup = self.mBall.doDuplicate(po=True)
mDup.p_position = pos_end
crvBall2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mDup.mNode, **_d_cast)
CURVES.connect([crvBall, crvBall2], 7)
mDup.delete()
mHandleFactory.color(crvBall, controlType='sub')
mBallFK = self.mBall.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mBallFK.mNode,
crvBall,
True,
replaceShapes=True)
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func,
"Ball Ik control..."))
mBallIK = self.mBall.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mBallIK.mNode,
crvBall,
True,
replaceShapes=True)
mRigNull.connectChildNode(mBallIK, 'controlIKBall',
'rigNull') #Connect
mBallIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallIK.doStore('cgmTypeModifier', 'ik')
mBallIK.doName()
mBallIK.connectChildNode(self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
#Hinge ===================================================================
log.debug(
cgmGEN.logString_msg(_str_func,
"Ball Hinge Ik control..."))
#Need to make our cast locs
mStart = mBallIK.doCreateAt(setClass=1)
mEnd = mBallIK.doCreateAt(setClass=1)
pos1_start = self.mBall.getParent(asMeta=1).p_position
pos2_start = mEnd.p_position
vec_to_end = MATH.get_vector_of_two_points(
pos1_start, pos2_start)
vec_to_start = MATH.get_vector_of_two_points(
pos2_start, pos1_start)
mStart.p_position = DIST.get_average_position(
[pos1_start, pos2_start])
#DIST.get_pos_by_vec_dist(pos1_start,vec_to_end,_offset)#
mEnd.p_position = DIST.get_pos_by_vec_dist(
pos2_start, vec_to_start, _offset)
crv1 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mStart.mNode, **_d_cast)
crv2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mEnd.mNode, **_d_cast)
CURVES.connect([crv1, crv2], 7)
mBallHingeIK = self.mBall.doCreateAt(setClass=True)
mRigNull.connectChildNode(mBallHingeIK, 'controlIKBallHinge',
'rigNull') #Connect
mBallHingeIK.connectChildNode(
self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mHandleFactory.color(crv1, controlType='sub')
CORERIG.shapeParent_in_place(mBallHingeIK.mNode,
crv1,
True,
replaceShapes=True)
mBallHingeIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallHingeIK.doStore('cgmNameModifier', 'hinge')
mBallHingeIK.doStore('cgmTypeModifier', 'ik')
mBallHingeIK.doName()
for mObj in mStart, mEnd:
mObj.delete()
ml_fkShapes.append(cgmMeta.asMeta(crv1))
ml_fkShapes.append(cgmMeta.validateObjArg(crvBall, 'cgmObject'))
if self.mToe:
if not _max:
_max = RAYS.get_dist_from_cast_axis(
self.mToe.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
_d_cast['maxDistance'] = _max
crv = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mToe.mNode, **_d_cast)
"""
crv = CURVES.create_controlCurve(self.mToe.mNode, shape='circle',
direction = _jointOrientation[0]+'+',
sizeMode = 'fixed',
size = size_pivotHelper[0])"""
mHandleFactory.color(crv, controlType='sub')
mToeFK = self.mToe.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mToeFK.mNode,
crv,
True,
replaceShapes=True)
ml_fkShapes.append(cgmMeta.validateObjArg(crv, 'cgmObject'))
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func, "Toe Ik control..."))
mToeIK = self.mToe.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mToeIK.mNode,
crv,
True,
replaceShapes=True)
mRigNull.connectChildNode(mToeIK, 'controlIKToe',
'rigNull') #Connect
mToeIK.doCopyNameTagsFromObject(self.mToe.mNode,
ignore=['cgmType'])
mToeIK.doStore('cgmTypeModifier', 'ik')
mToeIK.doName()
mToeIK.connectChildNode(self.mToe.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mMesh_tmp.delete()
return ml_fkShapes
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
class fncWrap(cgmGeneral.cgmFuncCls):
def __init__(self, *args, **kws):
"""
"""
super(fncWrap, self).__init__(*args, **kws)
if args:
self.mi_control = cgmMeta.validateObjArg(args[0],
cgmMeta.cgmObject,
noneValid=False)
try:
self._str_funcName = "registerControl(%s)" % self.mi_control.p_nameShort
except:
self._str_funcName = "registerControl"
self._l_ARGS_KWS_DEFAULTS = [
{
'kw': 'controlObject',
"default": None,
'help': "The object to use as a control",
"argType": "mObject"
},
{
'kw': 'copyTransform',
"default": None,
'help':
"Object to copy the transform of for our control object",
"argType": "mObject"
},
{
'kw': 'copyPivot',
"default": None,
'help':
"Object to copy the pivot of for our control object",
"argType": "mObject"
},
{
'kw': 'shapeParentTo',
"default": None,
'help':
"Object to shape parent our control curve to to use that transform",
"argType": "mObject"
},
{
'kw': 'useShape',
"default": None,
'help': "Object to use the curve shape of for our control",
"argType": "mObject"
},
{
'kw': 'setRotateOrder',
"default": None,
'help': "Argument for a rotate order to set",
"argType": "rotateOrder"
},
{
'kw': 'autoLockNHide',
"default": None,
'help': "Try to set lock and hide",
"argType": "bool"
},
{
'kw': 'mirrorAxis',
"default": None,
'help': "Mirror axis to set - using red9's setup terms",
"argType": "string"
},
{
'kw': 'mirrorSide',
"default": None,
'help': "Mirror side - using red9's setup terms",
"argType": "string/int"
},
{
'kw': 'makeMirrorable',
"default": True,
'help':
"Setup for mirrorability (using red9) -- implied by other mirror args",
"argType": "bool"
},
{
'kw': 'addDynParentGroup',
"default": False,
'help': "Add a dynParent group setup"
},
{
'kw': 'addExtraGroups',
"default": False,
'help': "Number of nested extra groups desired",
"argType": "int"
},
{
'kw': 'addConstraintGroup',
"default": False,
'help':
"If a group just above the control is desired for consraining",
"argType": "bool"
},
{
'kw': 'freezeAll',
"default": False,
'help': "Freeze all transforms on the control object",
"argType": "bool"
},
{
'kw': 'addSpacePivots',
"default": False,
'help': "Number of space pivots to generate and connect",
"argType": "int"
},
{
'kw': 'controlType',
"default": None,
'help': "Tag for cgmType",
"argType": "string"
},
{
'kw': 'typeModifier',
"default": None,
'help': "Tag for cgmTypeModifier for naming",
"argType": "string"
},
{
'kw': 'addForwardBack',
"default": None,
'help':
"Forward Back driver setup. Looking for an attribute to drive",
"argType": "mAttr"
},
{
'kw': 'addMirrorAttributeBridges',
"default": None,
'help':
"Attribute to drive the same channel on mirrored objects. Looking for an nested list [[attrName,attr],...]",
"argType": "nested list"
},
{
'kw': 'aim',
"default": None,
'help': "aim axis to use",
"argType": "string/int"
},
{
'kw': 'up',
"default": None,
'help': "up axis to use",
"argType": "string/int"
},
{
'kw': 'out',
"default": None,
'help': "out axis to use",
"argType": "string/int"
},
{
'kw': 'makeAimable',
"default": False,
'help': "Make object aimable -- implied by aim/up/out",
"argType": "mObject"
},
]
self.__dataBind__(*args, **kws)
#=================================================================
self.l_funcSteps = [{
'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
}]
def _validate(self):
assert type(self.d_kws['addExtraGroups']) in [int, bool]
assert type(self.d_kws['addSpacePivots']) in [int, bool]
i_obj = self.mi_control
self.mi_control = cgmMeta.asMeta(i_obj,
'cgmControl',
setClass=True)
self.str_mirrorAxis = VALID.stringArg(
self.d_kws['mirrorAxis'], calledFrom=self._str_funcCombined)
self.str_mirrorSide = VALID.stringArg(
self.d_kws['mirrorSide'], calledFrom=self._str_funcCombined)
self.b_makeMirrorable = VALID.boolArg(
self.d_kws['makeMirrorable'],
calledFrom=self._str_funcCombined)
self._addMirrorAttributeBridges = self.d_kws.get(
'addMirrorAttributeBridges') or False
if self._addMirrorAttributeBridges:
if type(self._addMirrorAttributeBridges) not in [list, tuple]:
raise StandardError, "[Bad addMirrorAttributeBridge arg]{arg: %s}" % self._addMirrorAttributeBridge
for i, l in enumerate(self._addMirrorAttributeBridges):
if type(l) not in [list, tuple]:
raise StandardError, "[Bad addMirrorAttributeBridge arg: %s]{arg: %s}" % (
i, l)
# Running lists ------------------------------------------------------------------------------------------
self.ml_groups = [] #Holder for groups
self.ml_constraintGroups = []
self.ml_spacePivots = []
def _copyTransform(self):
copyTransform = self.d_kws['copyTransform']
if copyTransform is not None:
if issubclass(type(copyTransform), cgmMeta.cgmNode):
i_target = copyTransform
elif mc.objExists(copyTransform):
i_target = cgmMeta.cgmObject(copyTransform)
else:
raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyTransform
#Need to move this to default cgmNode stuff
mBuffer = self.mi_control
i_newTransform = cgmMeta.cgmObject(
rigging.groupMeObject(i_target.mNode, False))
for a in mc.listAttr(self.mi_control.mNode, userDefined=True):
attributes.doCopyAttr(self.mi_control.mNode, a,
i_newTransform.mNode)
curves.parentShapeInPlace(i_newTransform.mNode,
self.mi_control.mNode) #Parent shape
i_newTransform.parent = self.mi_control.parent #Copy parent
self.mi_control = cgmMeta.asMeta(i_newTransform,
'cgmControl',
setClass=True)
mc.delete(mBuffer.mNode)
def _shapeParent(self):
shapeParentTo = self.d_kws['shapeParentTo']
if shapeParentTo:
try:
i_target = cgmMeta.validateObjArg(shapeParentTo,
cgmMeta.cgmObject)
curves.parentShapeInPlace(i_target.mNode,
self.mi_control.mNode)
i_target = cgmMeta.asMeta(i_target,
'cgmControl',
setClass=True)
#self.mi_control.delete()
self.mi_control = i_target #replace the control with the joint
except Exception, error:
raise StandardError, "shapeParentTo | %s" % error
useShape = self.d_kws['useShape']
if useShape is not None:
try:
i_shape = cgmMeta.validateObjArg(useShape,
cgmMeta.cgmObject,
mayaType='nurbsCurve')
curves.parentShapeInPlace(self.mi_control.mNode,
i_shape.mNode)
except Exception, error:
raise StandardError, "useShape | %s" % error
def ribbon_seal(
driven1=None,
driven2=None,
influences1=None,
influences2=None,
msgDriver=None, #...msgLink on joint to a driver group for constaint purposes
extendEnds=False,
loftAxis='z',
orientation='zyx',
secondaryAxis='y+',
baseName=None,
baseName1=None,
baseName2=None,
connectBy='constraint',
sectionSpans=1,
settingsControl=None,
specialMode=None,
sealSplit=False,
sealDriver1=None,
sealDriver2=None,
sealDriverMid=None,
sealName1='left',
sealName2='right',
sealNameMid='center',
maxValue=10.0,
moduleInstance=None,
parentGutsTo=None):
try:
_str_func = 'ribbon_seal'
ml_rigObjectsToConnect = []
md_drivers = {}
md_base = {}
md_seal = {}
md_blend = {}
md_follicles = {}
md_follicleShapes = {}
d_dat = {1: {}, 2: {}}
if msgDriver:
ml_missingDrivers = []
def check_msgDriver(mObj):
mDriver = mObj.getMessageAsMeta(msgDriver)
if mDriver:
md_drivers[mObj] = mDriver
else:
log.error("|{0}| >> Missing driver: {1}".format(
_str_func, mObj))
ml_missingDrivers.append(mObj)
return False
#>>> Verify ===================================================================================
log.debug("|{0}| >> driven1 [Check]...".format(_str_func))
d_dat[1]['driven'] = cgmMeta.validateObjListArg(driven1,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
log.debug("|{0}| >> driven2 [Check]...".format(_str_func))
d_dat[2]['driven'] = cgmMeta.validateObjListArg(driven2,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
#Check our msgDrivers -----------------------------------------------------------
if msgDriver:
log.debug("|{0}| >> msgDriver [Check]...".format(_str_func))
for mObj in d_dat[1]['driven'] + d_dat[2]['driven']:
if mObj not in ml_missingDrivers:
check_msgDriver(mObj)
if ml_missingDrivers:
raise ValueError, "Missing drivers. See errors."
log.debug("|{0}| >> msgDriver [Pass]...".format(_str_func))
d_dat[1]['int_driven'] = len(d_dat[1]['driven'])
d_dat[2]['int_driven'] = len(d_dat[2]['driven'])
log.debug("|{0}| >> Driven lengths {1} | {2}".format(
_str_func, d_dat[1]['int_driven'], d_dat[2]['int_driven']))
log.debug("|{0}| >> influences1 [Check]...".format(_str_func))
d_dat[1]['mInfluences'] = cgmMeta.validateObjListArg(
influences1,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
log.debug("|{0}| >> influences2 [Check]...".format(_str_func))
d_dat[2]['mInfluences'] = cgmMeta.validateObjListArg(
influences2,
mType='cgmObject',
mayaType=['joint'],
noneValid=False)
d_dat[1]['int_influences'] = len(d_dat[1]['mInfluences'])
d_dat[2]['int_influences'] = len(d_dat[2]['mInfluences'])
log.debug("|{0}| >> Influence lengths {1} | {2}".format(
_str_func, d_dat[1]['int_influences'], d_dat[2]['mInfluences']))
mi_mayaOrientation = VALID.simpleOrientation(orientation)
str_orientation = mi_mayaOrientation.p_string
str_secondaryAxis = VALID.stringArg(secondaryAxis, noneValid=True)
if specialMode and specialMode not in [
'noStartEnd', 'endsToInfluences'
]:
raise ValueError, "Unknown special mode: {0}".format(specialMode)
#module -----------------------------------------------------------------------------------------------
mModule = cgmMeta.validateObjArg(moduleInstance, noneValid=True)
#try:mModule.isModule()
#except:mModule = False
mi_rigNull = False
if mModule:
log.debug("|{0}| >> mModule [Check]...".format(_str_func))
mi_rigNull = mModule.rigNull
if str_baseName is None:
str_baseName = mModule.getPartNameBase() #Get part base name
if not baseName: baseName = 'testRibbonSeal'
if not baseName1: baseName1 = 'ribbon1'
if not baseName2: baseName2 = 'ribbon2'
d_check = {
'driven1': d_dat[1]['int_driven'],
'driven2': d_dat[2]['int_driven']
}
for k, i in d_check.iteritems():
if i < 3:
raise ValueError, "needs at least three driven. Found : {0} | {1}".format(
k, i)
log.debug("|{0}| >> Group [Check]...".format(_str_func))
if parentGutsTo is None:
mGroup = cgmMeta.cgmObject(name='newgroup')
mGroup.addAttr('cgmName', str(baseName), lock=True)
mGroup.addAttr('cgmTypeModifier', 'segmentStuff', lock=True)
mGroup.doName()
else:
mGroup = cgmMeta.validateObjArg(parentGutsTo, 'cgmObject', False)
if mModule:
mGroup.parent = mModule.rigNull
#Good way to verify an instance list? #validate orientation
#> axis -------------------------------------------------------------
"""
axis_aim = VALID.simpleAxis("{0}+".format(str_orientation[0]))
axis_aimNeg = axis_aim.inverse
axis_up = VALID.simpleAxis("{0}+".format(str_orientation [1]))
axis_out = VALID.simpleAxis("{0}+".format(str_orientation [2]))
v_aim = axis_aim.p_vector#aimVector
v_aimNeg = axis_aimNeg.p_vector#aimVectorNegative
v_up = axis_up.p_vector #upVector
v_out = axis_out.p_vector
str_up = axis_up.p_string
loftAxis2 = False
#Figure out our loft axis stuff
if loftAxis not in orientation:
_lower_loftAxis = loftAxis.lower()
if _lower_loftAxis in ['out','up']:
if _lower_loftAxis == 'out':
loftAxis = str_orientation[2]
else:
loftAxis = str_orientation[1]
else:
raise ValueError,"Not sure what to do with loftAxis: {0}".format(loftAxis)
"""
outChannel = str_orientation[2] #outChannel
upChannel = str_orientation[1]
#upChannel = '{0}up'.format(str_orientation[1])#upChannel
#>>> Ribbon Surface ============================================================================
log.debug("|{0}| >> Ribbons generating...".format(_str_func))
l_surfaceReturn1 = IK.ribbon_createSurface(d_dat[1]['driven'],
loftAxis, sectionSpans,
extendEnds)
d_dat[1]['mSurf'] = cgmMeta.validateObjArg(l_surfaceReturn1[0],
'cgmObject',
setClass=True)
d_dat[1]['mSurf'].addAttr('cgmName',
str(baseName1),
attrType='string',
lock=True)
d_dat[1]['mSurf'].addAttr('cgmType',
'controlSurface',
attrType='string',
lock=True)
d_dat[1]['mSurf'].doName()
l_surfaceReturn2 = IK.ribbon_createSurface(d_dat[2]['driven'],
loftAxis, sectionSpans,
extendEnds)
d_dat[2]['mSurf'] = cgmMeta.validateObjArg(l_surfaceReturn1[0],
'cgmObject',
setClass=True)
d_dat[2]['mSurf'].addAttr('cgmName',
str(baseName2),
attrType='string',
lock=True)
d_dat[2]['mSurf'].addAttr('cgmType',
'controlSurface',
attrType='string',
lock=True)
d_dat[2]['mSurf'].doName()
log.debug("d_dat[1]['mSurf']: {0}".format(d_dat[1]['mSurf']))
log.debug("d_dat[2]['mSurf']: {0}".format(d_dat[2]['mSurf']))
ml_toConnect = []
ml_toConnect.extend([d_dat[1]['mSurf'], d_dat[2]['mSurf']])
#Special Mode =================================================================================
if specialMode in ['noStartEnd', 'endsToInfluences']:
log.debug(
"|{0}| >> Special Mode: {1}".format(_str_func, specialMode) +
cgmGEN._str_subLine)
if specialMode == 'endsToInfluences':
d_special = {
'1start': {
'mObj': d_dat[1]['driven'][0],
'mDriver': d_dat[1]['mInfluences'][0]
},
'1end': {
'mObj': d_dat[1]['driven'][-1],
'mDriver': d_dat[1]['mInfluences'][-1]
},
'2start': {
'mObj': d_dat[2]['driven'][0],
'mDriver': d_dat[2]['mInfluences'][0]
},
'2end': {
'mObj': d_dat[2]['driven'][-1],
'mDriver': d_dat[2]['mInfluences'][-1]
}
}
for n, dat in d_special.iteritems():
mObj = dat['mObj']
mDriven = md_drivers[mObj]
mDriver = dat['mDriver']
log.debug("|{0}| >> {1} | Driver: {2}".format(
_str_func, i, mDriven))
_const = mc.parentConstraint([mDriver.mNode],
mDriven.mNode,
maintainOffset=True)[0]
ATTR.set(_const, 'interpType', 2)
d_dat[1]['driven'] = d_dat[1]['driven'][1:-1]
d_dat[2]['driven'] = d_dat[2]['driven'][1:-1]
driven1 = driven1[1:-1]
driven2 = driven2[1:-1]
#>>> Setup our Attributes ================================================================
log.debug("|{0}| >> Settings...".format(_str_func))
if settingsControl:
mSettings = cgmMeta.validateObjArg(settingsControl, 'cgmObject')
else:
mSettings = d_dat[1]['mSurf']
mPlug_sealHeight = cgmMeta.cgmAttr(mSettings.mNode,
'sealHeight',
attrType='float',
lock=False,
keyable=True)
mPlug_sealHeight.doDefault(.5)
mPlug_sealHeight.value = .5
#>>> Setup blend results --------------------------------------------------------------------
if sealSplit:
d_split = split_blends(
driven1, #d_dat[1]['driven'],
driven2, #d_dat[2]['driven'],
sealDriver1,
sealDriver2,
sealDriverMid,
nameSeal1=sealName1,
nameSeal2=sealName2,
nameSealMid=sealNameMid,
settingsControl=mSettings,
maxValue=maxValue)
for k, d in d_split.iteritems():
d_dat[k]['mPlugs'] = d['mPlugs']
else:
mPlug_seal = cgmMeta.cgmAttr(mSettings.mNode,
'seal',
attrType='float',
lock=False,
keyable=True)
mPlug_sealOn = cgmMeta.cgmAttr(mSettings,
'result_sealOn',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_sealOff = cgmMeta.cgmAttr(mSettings,
'result_sealOff',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
NODEFACTORY.createSingleBlendNetwork(mPlug_seal.p_combinedName,
mPlug_sealOn.p_combinedName,
mPlug_sealOff.p_combinedName)
d_dat[1]['mPlug_sealOn'] = mPlug_sealOn
d_dat[1]['mPlug_sealOff'] = mPlug_sealOff
d_dat[2]['mPlug_sealOn'] = mPlug_sealOn
d_dat[2]['mPlug_sealOff'] = mPlug_sealOff
mPlug_FavorOneMe = cgmMeta.cgmAttr(mSettings,
'result_sealOneMe',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorOneThee = cgmMeta.cgmAttr(mSettings,
'result_sealOneThee',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorTwoMe = cgmMeta.cgmAttr(mSettings,
'result_sealTwoMe',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
mPlug_FavorTwoThee = cgmMeta.cgmAttr(mSettings,
'result_sealTwoThee',
attrType='float',
defaultValue=0,
keyable=False,
lock=True,
hidden=False)
NODEFACTORY.createSingleBlendNetwork(mPlug_sealHeight.p_combinedName,
mPlug_FavorOneThee.p_combinedName,
mPlug_FavorOneMe.p_combinedName)
NODEFACTORY.createSingleBlendNetwork(mPlug_sealHeight.p_combinedName,
mPlug_FavorTwoThee.p_combinedName,
mPlug_FavorTwoMe.p_combinedName)
d_dat[1]['mPlug_me'] = mPlug_FavorOneMe
d_dat[1]['mPlug_thee'] = mPlug_FavorOneThee
d_dat[2]['mPlug_me'] = mPlug_FavorTwoMe
d_dat[2]['mPlug_thee'] = mPlug_FavorTwoThee
"""
b_attachToInfluences = False
if attachEndsToInfluences:
log.debug("|{0}| >> attachEndsToInfluences flag. Checking...".format(_str_func))
if influences and len(influences) > 1:
b_attachToInfluences = True
log.debug("|{0}| >> b_attachToInfluences: {1}".format(_str_func,b_attachToInfluences))
"""
#>>> Skinning ============================================================================
log.debug("|{0}| >> Skinning Ribbons...".format(_str_func))
for idx, dat in d_dat.iteritems():
max_influences = 2
mode_tighten = 'twoBlend'
blendLength = int(dat['int_driven'] / 2)
blendMin = 2
_hardLength = 2
if extendEnds:
blendMin = 4
_hardLength = 4
mode_tighten = None
if dat['int_influences'] > 2:
mode_tighten = None
#blendLength = int(int_lenInfluences/2)
max_influences = MATH.Clamp(blendLength, 2, 4)
blendLength = MATH.Clamp(int(dat['int_influences'] / 2), 2, 6)
if dat['int_influences'] == dat['int_driven']:
_hardLength = 3
#Tighten the weights...
mSkinCluster = cgmMeta.validateObjArg(mc.skinCluster(
[mObj.mNode for mObj in dat['mInfluences']],
dat['mSurf'].mNode,
tsb=True,
maximumInfluences=max_influences,
normalizeWeights=1,
dropoffRate=5.0),
'cgmNode',
setClass=True)
mSkinCluster.doStore('cgmName', dat['mSurf'])
mSkinCluster.doName()
#Tighten the weights...
RIGSKIN.surface_tightenEnds(dat['mSurf'].mNode,
hardLength=_hardLength,
blendLength=blendLength,
mode=mode_tighten)
#>>> Meat ============================================================================
ml_processed = []
for idx, dat in d_dat.iteritems():
idx_seal = 1
if idx == 1:
idx_seal = 2
dat_seal = d_dat[idx_seal]
log.debug("|{0}| >> Building [{1}] | seal idx: {2} |".format(
_str_func, idx, idx_seal) + cgmGEN._str_subLine)
mSurfBase = dat['mSurf']
mSurfSeal = dat_seal['mSurf']
for i, mObj in enumerate(dat['driven']):
if mObj in ml_processed:
log.debug("|{0}| >> Already completed: {1}".format(
_str_func, mObj))
continue
ml_processed.append(mObj)
log.debug("|{0}| >> {1} | Driven: {2}".format(
_str_func, i, mObj))
mDriven = md_drivers[mObj]
log.debug("|{0}| >> {1} | Driver: {2}".format(
_str_func, i, mDriven))
log.debug("|{0}| >> Create track drivers...".format(_str_func))
mTrackBase = mDriven.doCreateAt(setClass=True)
mTrackBase.doStore('cgmName', mObj)
mTrackSeal = mTrackBase.doDuplicate()
mTrackBlend = mTrackBase.doDuplicate()
mTrackSeal.doStore('cgmType', 'trackSeal')
mTrackBase.doStore('cgmType', 'trackBase')
mTrackBlend.doStore('cgmType', 'trackBlend')
for mTrack in mTrackBase, mTrackSeal, mTrackBlend:
mTrack.doName()
log.debug("|{0}| >> Attach drivers...".format(_str_func))
d_tmp = {
'base': {
'mSurf': mSurfBase,
'mTrack': mTrackBase
},
'seal': {
'mSurf': mSurfSeal,
'mTrack': mTrackSeal
},
}
for n, d in d_tmp.iteritems():
mTrack = d['mTrack']
mSurf = d['mSurf']
_res = RIGCONSTRAINTS.attach_toShape(
mTrack.mNode, mSurf.mNode, 'parent')
mFollicle = _res[-1][
'mFollicle'] #cgmMeta.asMeta(follicle)
mFollShape = _res[-1][
'mFollicleShape'] #cgmMeta.asMeta(shape)
md_follicleShapes[mObj] = mFollShape
md_follicles[mObj] = mFollicle
mFollicle.parent = mGroup.mNode
if mModule: #if we have a module, connect vis
mFollicle.overrideEnabled = 1
cgmMeta.cgmAttr(
mModule.rigNull.mNode, 'gutsVis',
lock=False).doConnectOut(
"%s.%s" %
(mFollicle.mNode, 'overrideVisibility'))
cgmMeta.cgmAttr(
mModule.rigNull.mNode, 'gutsLock',
lock=False).doConnectOut(
"%s.%s" %
(mFollicle.mNode, 'overrideDisplayType'))
#Blend point --------------------------------------------------------------------
_const = mc.parentConstraint(
[mTrackBase.mNode, mTrackSeal.mNode], mTrackBlend.mNode)[0]
ATTR.set(_const, 'interpType', 2)
targetWeights = mc.parentConstraint(_const,
q=True,
weightAliasList=True)
#Connect
if idx == 1:
dat['mPlug_thee'].doConnectOut('%s.%s' %
(_const, targetWeights[0]))
dat['mPlug_me'].doConnectOut('%s.%s' %
(_const, targetWeights[1]))
else:
dat['mPlug_me'].doConnectOut('%s.%s' %
(_const, targetWeights[0]))
dat['mPlug_thee'].doConnectOut('%s.%s' %
(_const, targetWeights[1]))
#seal --------------------------------------------------------------------
_const = mc.parentConstraint(
[mTrackBase.mNode, mTrackBlend.mNode], mDriven.mNode)[0]
ATTR.set(_const, 'interpType', 2)
targetWeights = mc.parentConstraint(_const,
q=True,
weightAliasList=True)
if sealSplit:
dat['mPlugs']['off'][i].doConnectOut(
'%s.%s' % (_const, targetWeights[0]))
dat['mPlugs']['on'][i].doConnectOut(
'%s.%s' % (_const, targetWeights[1]))
else:
dat['mPlug_sealOff'].doConnectOut(
'%s.%s' % (_const, targetWeights[0]))
dat['mPlug_sealOn'].doConnectOut(
'%s.%s' % (_const, targetWeights[1]))
log.debug("|{0}| >> Blend drivers...".format(_str_func))
"""
#Simple contrain
if b_attachToInfluences and mJnt in [ml_joints[0],ml_joints[-1]]:
if mJnt == ml_joints[0]:
mUse = ml_influences[0]
else:
mUse = ml_influences[-1]
mc.parentConstraint([mUse.mNode], mDriven.mNode, maintainOffset=True)
else:
mc.parentConstraint([mDriver.mNode], mDriven.mNode, maintainOffset=True)
"""
#pprint.pprint(d_dat)
return
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def __init__(self, *args, **kws):
"""
"""
super(fncWrap, self).__init__(*args, **kws)
if args:
self.mi_control = cgmMeta.validateObjArg(args[0],
cgmMeta.cgmObject,
noneValid=False)
try:
self._str_funcName = "registerControl(%s)" % self.mi_control.p_nameShort
except:
self._str_funcName = "registerControl"
self._l_ARGS_KWS_DEFAULTS = [
{
'kw': 'controlObject',
"default": None,
'help': "The object to use as a control",
"argType": "mObject"
},
{
'kw': 'copyTransform',
"default": None,
'help':
"Object to copy the transform of for our control object",
"argType": "mObject"
},
{
'kw': 'copyPivot',
"default": None,
'help':
"Object to copy the pivot of for our control object",
"argType": "mObject"
},
{
'kw': 'shapeParentTo',
"default": None,
'help':
"Object to shape parent our control curve to to use that transform",
"argType": "mObject"
},
{
'kw': 'useShape',
"default": None,
'help': "Object to use the curve shape of for our control",
"argType": "mObject"
},
{
'kw': 'setRotateOrder',
"default": None,
'help': "Argument for a rotate order to set",
"argType": "rotateOrder"
},
{
'kw': 'autoLockNHide',
"default": None,
'help': "Try to set lock and hide",
"argType": "bool"
},
{
'kw': 'mirrorAxis',
"default": None,
'help': "Mirror axis to set - using red9's setup terms",
"argType": "string"
},
{
'kw': 'mirrorSide',
"default": None,
'help': "Mirror side - using red9's setup terms",
"argType": "string/int"
},
{
'kw': 'makeMirrorable',
"default": True,
'help':
"Setup for mirrorability (using red9) -- implied by other mirror args",
"argType": "bool"
},
{
'kw': 'addDynParentGroup',
"default": False,
'help': "Add a dynParent group setup"
},
{
'kw': 'addExtraGroups',
"default": False,
'help': "Number of nested extra groups desired",
"argType": "int"
},
{
'kw': 'addConstraintGroup',
"default": False,
'help':
"If a group just above the control is desired for consraining",
"argType": "bool"
},
{
'kw': 'freezeAll',
"default": False,
'help': "Freeze all transforms on the control object",
"argType": "bool"
},
{
'kw': 'addSpacePivots',
"default": False,
'help': "Number of space pivots to generate and connect",
"argType": "int"
},
{
'kw': 'controlType',
"default": None,
'help': "Tag for cgmType",
"argType": "string"
},
{
'kw': 'typeModifier',
"default": None,
'help': "Tag for cgmTypeModifier for naming",
"argType": "string"
},
{
'kw': 'addForwardBack',
"default": None,
'help':
"Forward Back driver setup. Looking for an attribute to drive",
"argType": "mAttr"
},
{
'kw': 'addMirrorAttributeBridges',
"default": None,
'help':
"Attribute to drive the same channel on mirrored objects. Looking for an nested list [[attrName,attr],...]",
"argType": "nested list"
},
{
'kw': 'aim',
"default": None,
'help': "aim axis to use",
"argType": "string/int"
},
{
'kw': 'up',
"default": None,
'help': "up axis to use",
"argType": "string/int"
},
{
'kw': 'out',
"default": None,
'help': "out axis to use",
"argType": "string/int"
},
{
'kw': 'makeAimable',
"default": False,
'help': "Make object aimable -- implied by aim/up/out",
"argType": "mObject"
},
]
self.__dataBind__(*args, **kws)
#=================================================================
self.l_funcSteps = [{
'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
}]
r9Meta.MetaClass(
'invalidMClass'
) #...it's gonna now always return as a cgmNode as it's a valid mClass value
#...so, long story short. Manually changing a node's mClass attribute is not a reliable method of changing the type it instantiates to
#...The right way...
#r9's method
n3 = r9Meta.MetaClass(nodeType='network',
name='r9Convert') #...let's make one via meta call
r9Meta.convertMClassType(
n3, 'cgmNode') #... This converts our node to a cgmNode type
#cgm's Method
cgmMeta.validateObjArg(
n3.mNode, 'MetaClass', setLogLevel='debug'
) #...this initially wont' change because our current class is a subclass of MetaClass, trust that this is a feature and not a bug
cgmMeta.validateObjArg(
n3.mNode, 'MetaClass', setClass=True, setLogLevel='debug'
) #...this pass will get it as we have our setClass flag on
cgmMeta.validateObjArg(
n3.mNode, 'cgmNode', setClass=True,
setLogLevel='info') #...convert it back and get out of debug
#==============================================================================================
#>> Data storage
#==============================================================================================
mc.file(new=True, f=True) #...let's start with a clean file
#Go to the outliner and make sure DAG objects only is off
n1 = r9Meta.MetaClass(nodeType='network',
def freezeOrientation(targetJoints):
"""
Freeze joint orientations in place.
"""
_str_funcName = "metaFreezeJointOrientation"
#t1 = time.time()
if type(targetJoints) not in [list, tuple]: targetJoints = [targetJoints]
ml_targetJoints = cgmMeta.validateObjListArg(targetJoints, 'cgmObject')
#log.info("{0}>> meta'd: {1}".format(_str_funcName, "%0.3f seconds"%(time.time() - t1)))
#t1 = time.time()
'''
for i_jnt in ml_targetJoints:
if i_jnt.getConstraintsTo():
log.warning("freezeJointOrientation>> target joint has constraints. Can't change orientation. Culling from targets: '%s'"%i_jnt.getShortName())
return False
'''
#buffer parents and children of
d_children = {}
d_parent = {}
mi_parent = cgmMeta.validateObjArg(ml_targetJoints[0].parent,
noneValid=True)
#log.info('validate')
for i, i_jnt in enumerate(ml_targetJoints):
_relatives = TRANS.children_get(i_jnt.mNode)
log.debug("{0} relatives: {1}".format(i, _relatives))
d_children[i_jnt] = cgmMeta.validateObjListArg(_relatives, 'cgmObject',
True) or []
d_parent[i_jnt] = cgmMeta.validateObjArg(i_jnt.parent, noneValid=True)
for i_jnt in ml_targetJoints:
for i, i_c in enumerate(d_children[i_jnt]):
#log.debug(i_c.getShortName())
#log.debug("freezeJointOrientation>> parented '%s' to world to orient parent"%i_c.mNode)
i_c.parent = False
if mi_parent:
ml_targetJoints[0].parent = False
#Orient
t_loop = time.time()
for i, i_jnt in enumerate(ml_targetJoints):
"""
So....jointOrient is always in xyz rotate order
dup,rotate order
Unparent, add rotate & joint rotate, push value, zero rotate, parent back, done
"""
log.debug("parent...")
if i != 0 and d_parent.get(i_jnt):
i_jnt.parent = d_parent.get(
i_jnt) #parent back first before duping
#New method ----
log.debug("loc...")
#mi_rootLoc = i_jnt.doLoc(fastMode = True)#Make some locs
mi_zLoc = i_jnt.doLoc(fastMode=True) #Make some locs
mi_yLoc = mi_zLoc.doDuplicate()
log.debug("dup...")
i_dup = i_jnt.doDuplicate(parentOnly=True)
i_dup.parent = i_jnt.parent
i_dup.rotate = 0, 0, 0
i_dup.rotateOrder = 0
i_dup.jointOrient = 0, 0, 0
log.debug("group...")
str_group = TRANS.group_me(i_jnt, False, True) #group for easy move
mi_yLoc.parent = str_group
mi_zLoc.parent = str_group
mi_zLoc.tz = 1 #Move
mi_yLoc.ty = 1
mc.makeIdentity(i_dup.mNode, apply=1, jo=1) #Freeze
#Aim
log.debug("constrain...")
str_const = mc.aimConstraint(mi_zLoc.mNode,
i_dup.mNode,
maintainOffset=False,
weight=1,
aimVector=[0, 0, 1],
upVector=[0, 1, 0],
worldUpVector=[0, 1, 0],
worldUpObject=mi_yLoc.mNode,
worldUpType='object')[0]
i_jnt.rotate = [0, 0, 0] #Move to joint
i_jnt.jointOrient = i_dup.rotate
#log.info('{0} delete'.format(i))
log.debug("delete...")
mc.delete([str_const, str_group]) #Delete extra stuff str_group
i_dup.delete()
#reparent
if mi_parent:
try:
ml_targetJoints[0].parent = mi_parent
except Exception, error:
raise StandardError, "Failed to parent back %s" % error
def spline(self,
ml_ikJoints=None,
ml_ribbonIkHandles=None,
mIKControl=None,
mIKBaseControl=None,
ml_skinDrivers=None,
mPlug_masterScale=None):
try:
_str_func = 'spline'
log_start(_str_func)
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_ribbonIkHandles = mRigNull.msgList_get('ribbonIKDrivers')
if not ml_ribbonIkHandles:
raise ValueError, "No ribbon IKDriversFound"
_aim = self.d_orientation['vectorAim']
_aimNeg = self.d_orientation['vectorAimNeg']
_up = self.d_orientation['vectorUp']
_out = self.d_orientation['vectorOut']
res_spline = IK.spline([mObj.mNode for mObj in ml_ikJoints],
orientation=_jointOrientation,
advancedTwistSetup=True,
baseName=self.d_module['partName'] + '_spline',
moduleInstance=self.mModule)
mSplineCurve = res_spline['mSplineCurve']
log.debug("|{0}| >> spline curve...".format(_str_func))
mSplineCurve.doConnectIn('masterScale',
mPlug_masterScale.p_combinedShortName)
ATTR.copy_to(mSplineCurve.mNode,
'twistEnd',
mIKControl.mNode,
driven='source')
ATTR.copy_to(mSplineCurve.mNode,
'twistStart',
mIKBaseControl.mNode,
driven='source')
ATTR.copy_to(mSplineCurve.mNode,
'twistType',
mIKControl.mNode,
driven='source')
#ATTR.set_default(mIKControl.mNode,'twistType',1)
#ATTR.set(mIKControl.mNode,'twistType',1)
mSkinCluster = cgmMeta.validateObjArg(mc.skinCluster(
[mHandle.mNode for mHandle in ml_skinDrivers],
mSplineCurve.mNode,
tsb=True,
maximumInfluences=2,
normalizeWeights=1,
dropoffRate=2.5),
'cgmNode',
setClass=True)
mSkinCluster.doStore('cgmName', mSplineCurve)
mSkinCluster.doName()
mc.orientConstraint(mIKControl.mNode,
ml_ikJoints[-1].mNode,
maintainOffset=True)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def metaFreezeJointOrientation(targetJoints):
"""
Freeze joint orientations in place.
"""
try:
_str_funcName = "metaFreezeJointOrientation"
t1 = time.time()
if type(targetJoints) not in [list, tuple]:
targetJoints = [targetJoints]
ml_targetJoints = cgmMeta.validateObjListArg(targetJoints,
'cgmObject',
mayaType='joint')
log.info("{0}>> meta'd: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1)))
t1 = time.time()
'''
for i_jnt in ml_targetJoints:
if i_jnt.getConstraintsTo():
log.warning("freezeJointOrientation>> target joint has constraints. Can't change orientation. Culling from targets: '%s'"%i_jnt.getShortName())
return False
'''
#buffer parents and children of
d_children = {}
d_parent = {}
mi_parent = cgmMeta.validateObjArg(ml_targetJoints[0].parent,
noneValid=True)
#log.info('validate')
for i, i_jnt in enumerate(ml_targetJoints):
_relatives = mc.listRelatives(i_jnt.mNode, path=True, c=True)
log.debug("{0} relatives: {1}".format(i, _relatives))
d_children[i_jnt] = cgmMeta.validateObjListArg(
_relatives, 'cgmObject', True) or []
d_parent[i_jnt] = cgmMeta.validateObjArg(i_jnt.parent,
noneValid=True)
for i_jnt in ml_targetJoints:
for i, i_c in enumerate(d_children[i_jnt]):
#log.debug(i_c.getShortName())
#log.debug("freezeJointOrientation>> parented '%s' to world to orient parent"%i_c.mNode)
i_c.parent = False
if mi_parent:
ml_targetJoints[0].parent = False
#log.info('gather data')
log.info("{0}>> parent data: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1)))
t1 = time.time()
#Orient
for i, i_jnt in enumerate(ml_targetJoints):
"""
So....jointOrient is always in xyz rotate order
dup,rotate order
Unparent, add rotate & joint rotate, push value, zero rotate, parent back, done
"""
log.debug("parent...")
if i != 0 and d_parent.get(i_jnt):
i_jnt.parent = d_parent.get(
i_jnt) #parent back first before duping
#log.info('{0} parent'.format(i))
log.info("{0}>> {2} parent: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
log.debug("dup...")
#i_dup = duplicateJointInPlace(i_jnt)
i_dup = i_jnt.doDuplicate(parentOnly=True)
#log.debug("{0} | UUID: {1}".format(i_jnt.mNode,i_jnt.getMayaAttr('UUID')))
#log.debug("{0} | UUID: {1}".format(i_dup.mNode,i_dup.getMayaAttr('UUID')))
i_dup.parent = i_jnt.parent
i_dup.rotateOrder = 0
log.info("{0}>> {2} dup: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
#New method ----
log.debug("loc...")
mi_zLoc = i_jnt.doLoc() #Make some locs
mi_yLoc = i_jnt.doLoc()
#log.info('{0} loc'.format(i))
log.info("{0}>> {2} loc: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
log.debug("group...")
str_group = mi_zLoc.doGroup() #group for easy move
mi_yLoc.parent = str_group
#log.info('{0} group'.format(i))
log.info("{0}>> {2} group: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
mi_zLoc.tz = 1 #Move
mi_yLoc.ty = 1
mc.makeIdentity(i_dup.mNode, apply=1, jo=1) #Freeze
#Aim
log.debug("constrain...")
str_const = mc.aimConstraint(mi_zLoc.mNode,
i_dup.mNode,
maintainOffset=False,
weight=1,
aimVector=[0, 0, 1],
upVector=[0, 1, 0],
worldUpVector=[0, 1, 0],
worldUpObject=mi_yLoc.mNode,
worldUpType='object')[0]
#log.info('{0} constrain'.format(i))
log.info("{0}>> {2} constraint: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
i_jnt.rotate = [0, 0, 0] #Move to joint
i_jnt.jointOrient = i_dup.rotate
#log.info('{0} delete'.format(i))
log.debug("delete...")
mc.delete([str_const, str_group]) #Delete extra stuff
i_dup.delete()
log.info("{0}>> {2} clean: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1),
i_jnt.p_nameShort))
t1 = time.time()
log.info("{0}>> orienting: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1)))
t1 = time.time()
#reparent
if mi_parent:
try:
ml_targetJoints[0].parent = mi_parent
except Exception, error:
raise StandardError, "Failed to parent back %s" % error
for i, i_jnt in enumerate(ml_targetJoints):
for ii, i_c in enumerate(d_children[i_jnt]):
#log.info("{0} | {1}".format(i,ii))
#log.info(i_c)
log.debug("freezeJointOrientation>> parented '%s' back" %
i_c.getShortName())
i_c.parent = i_jnt.mNode
cgmMeta.cgmAttr(i_c, "inverseScale").doConnectIn("%s.scale" %
i_jnt.mNode)
#log.info('reparent')
log.info("{0}>> reparent: {1}".format(
_str_funcName, "%0.3f seconds" % (time.time() - t1)))
t1 = time.time()
return True
def gatherInfo(self):
mi_go = self._go #Rig Go instance link
self.mi_helper = cgmMeta.validateObjArg(
mi_go._mi_module.getMessage('helper'), noneValid=True)
if not self.mi_helper:
raise StandardError, "No suitable helper found"
def add_defHelpJoint(targetJoint,
childJoint=None,
helperType='halfPush',
orientation='zyx',
doSetup=True,
forceNew=False):
"""
Add helper joints to other joints
@KWS
targetJoint(string/inst)
helperType(str) --
'halfHold' -- like a regular bend joint that needs a holder at it's root, like a finger
'childRootHold' -- holds form on a hard rotate, like a finger root
jointUp(str) --
orientation(str)
forceNew(bool) -- delete if exists
"""
mi_posLoc = False
if orientation != 'zyx':
raise NotImplementedError, "add_defHelpJoints >> only currently can do orienation of 'zyx'"
#Validate base info
mi_targetJoint = cgmMeta.validateObjArg(targetJoint,
cgmMeta.cgmObject,
mayaType='joint')
log.debug(">>> %s.add_defHelpJoint >> " % mi_targetJoint.p_nameShort +
"=" * 75)
#>>Child joint
#TODO -- implement child guessing
mi_childJoint = cgmMeta.validateObjArg(childJoint,
cgmMeta.cgmObject,
mayaType='joint',
noneValid=True)
log.debug("%s.add_defHelpJoints >> Child joint : '%s'" %
(mi_targetJoint.p_nameShort, mi_childJoint))
str_plugHook = 'defHelp_joints'
#Validate some data
d_typeChecks = {
'halfHold': [mi_childJoint],
'childRootHold': [mi_childJoint],
'halfPush': [mi_childJoint]
}
if helperType in d_typeChecks.keys():
for k in d_typeChecks[helperType]:
if not k:
log.warning(
"%s.add_defHelpJoints >> must have valid %s for helperType: '%s'"
% (mi_targetJoint.p_nameShort, k, helperType))
return False
#>Register
#----------------------------------------------------------------
#First see if we have one
ml_dynDefHelpJoints = cgmMeta.validateObjListArg(
mi_targetJoint.getMessage(str_plugHook),
cgmMeta.cgmObject,
noneValid=True)
i_matchJnt = False
for i_jnt in ml_dynDefHelpJoints:
log.debug(i_jnt.p_nameShort)
if i_jnt.getAttr('defHelpType') == helperType and i_jnt.getMessage(
'defHelp_target') == [mi_targetJoint.p_nameLong]:
i_matchJnt = i_jnt
log.debug("%s.add_defHelpJoints >> Found match: '%s'" %
(mi_targetJoint.p_nameShort, i_matchJnt.p_nameShort))
break
if i_matchJnt: #if we have a match
if forceNew:
log.debug(
"%s.add_defHelpJoints >> helper exists, no force new : '%s'" %
(mi_targetJoint.p_nameShort, i_matchJnt.p_nameShort))
ml_dynDefHelpJoints.remove(i_matchJnt)
mc.delete(i_matchJnt.mNode)
else:
log.debug(
"%s.add_defHelpJoints >> helper exists, no force new : '%s'" %
(mi_targetJoint.p_nameShort, i_matchJnt.p_nameShort))
if not i_matchJnt:
log.debug("No match joint")
i_dupJnt = mi_targetJoint.doDuplicate(
inputConnections=False) #Duplicate
#i_dupJnt= duplicateJointInPlace(mi_targetJoint)
i_dupJnt.addAttr('cgmTypeModifier', helperType) #Tag
i_dupJnt.addAttr('defHelpType', helperType, lock=True) #Tag
i_dupJnt.doName() #Rename
i_dupJnt.parent = mi_targetJoint #Parent
ml_dynDefHelpJoints.append(i_dupJnt) #append to help joint list
i_dupJnt.connectChildNode(mi_childJoint,
"defHelp_childTarget") #Connect Child target
mi_targetJoint.msgList_append(ml_dynDefHelpJoints, str_plugHook,
'defHelp_target') #Connect
else:
i_dupJnt = i_matchJnt
#------------------------------------------------------------
log.debug("%s.add_defHelpJoints >> Created helper joint : '%s'" %
(mi_targetJoint.p_nameShort, i_dupJnt.p_nameShort))
if doSetup:
try:
setup_defHelpJoint(i_dupJnt, orientation)
except StandardError, error:
log.warning("%s.add_defHelpJoints >> Failed to setup | %s" %
(i_dupJnt.p_nameShort, error))
return True
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
_crv = CURVES.create_controlCurve(self.mNode,
shape='squareOpen',
direction='y+',
sizeMode='fixed',
size=1)
TRANS.scale_to_boundingBox(_crv,
[self.baseSize[0], None, self.baseSize[2]])
mHandleFactory.color(_crv, 'center', 'sub', transparent=False)
mCrv = cgmMeta.validateObjArg(_crv, 'cgmObject')
l_offsetCrvs = []
for shape in mCrv.getShapes():
offsetShape = mc.offsetCurve(shape, distance=-_offsetSize, ch=False)[0]
mHandleFactory.color(offsetShape, 'center', 'main', transparent=False)
l_offsetCrvs.append(offsetShape)
for s in [_crv] + l_offsetCrvs:
RIG.shapeParent_in_place(self.mNode, s, False)
return True
def formDelete(self):
pass
#self.setAttrFlags(attrs=['translate','rotate','sx','sz'], lock = False)
def duplicateJointInPlace(joint, asMeta=True):
"""
:parameters:
joint | str/instance
Joint to duplicate
asMeta | bool
What to return as
:returns:
str or instance of new joint
:raises:
TypeError | if 'arg' is not a joint
"""
_str_func_ = 'duplicateJointInPlace'
try:
mJoint = cgmMeta.validateObjArg(joint,
mayaType='joint',
mType='cgmObject')
#dup = mc.joint()
mDup = mJoint.doDuplicate(parentOnly=True)
#mDup.parent = mJoint.parent
#mc.delete(mc.parentConstraint(mJoint.mNode,mDup.mNode))
'''
('rotateOrder','rotateAxisX','rotateAxisY','rotateAxisZ',
'inheritsTransform','drawStyle','radius',
'jointTypeX','jointTypeY','jointTypeZ',
'stiffnessX','stiffnessY','stiffnessZ',
'preferredAngleX','preferredAngleY','preferredAngleZ',
'jointOrientX','jointOrientY','jointOrientZ','segmentScaleCompensate','showManipDefault',
'displayHandle','displayLocalAxis','selectHandleX','selectHandleY','selectHandleZ'),
'''
mDup.rotateOrder = mJoint.rotateOrder
mDup.jointOrient = mJoint.jointOrient
mDup.rotateAxis = mJoint.rotateAxis
mDup.inheritsTransform = mJoint.inheritsTransform
mDup.radius = mJoint.radius
mDup.stiffness = mJoint.stiffness
mDup.preferredAngle = mJoint.preferredAngle
mDup.segmentScaleCompensate = mJoint.segmentScaleCompensate
#mDup.displayHandle = mJoint.displayHandle
#mDup.selectHandle = mJoint.selectHandle
#Inverse scale...
mAttr_inverseScale = cgmMeta.cgmAttr(mJoint, 'inverseScale')
_driver = mAttr_inverseScale.getDriver()
if mAttr_inverseScale.getDriver():
cgmMeta.cgmAttr(mDup, "inverseScale").doConnectIn(_driver)
mAttr_inverseScale.getDriver(mJoint)
for attr in mJoint.getUserAttrs():
try:
cgmMeta.cgmAttr(mJoint, attr).doCopyTo(mDup.mNode)
except Exception, err:
log.error(
"duplicateJointInPlace({0}) .{1} failed << {2} >>".format(
mJoint.p_nameShort, attr, err))
if asMeta:
return mDup
return mDup.mNode
