def ik_rp(self, mHandle=None, ml_targets=None):
_str_func = 'rp'
#Mid IK...---------------------------------------------------------------------------------
log.debug("|{0}| >> ...".format(_str_func) + '/' * 30)
if mHandle == None:
mHandle = self.mMidFormHandle
if not ml_targets:
self.ml_handleTargetsCulled
size_knee = MATH.average(POS.get_bb_size(mHandle.mNode, True)) * .75
crv = CURVES.create_fromName(
'sphere',
direction='z+', #_jointOrientation[0]+'+',
size=size_knee) #max(size_knee) * 1.25)
mRP = cgmMeta.validateObjArg(crv, setClass=True)
mRP.p_position = self.mBlock.atUtils('prerig_get_rpBasePos', ml_targets,
False)
self.mBlock.asHandleFactory().color(mRP.mNode, controlType='main')
#mRP.doCopyNameTagsFromObject(ml_fkJoints[1].mNode,ignore=['cgmType','cgmTypeModifier'])
mRP.doStore('cgmName', self.d_module['partName'])
mRP.doStore('cgmAlias', 'midIK')
mRP.doStore('cgmTypeModifier', 'ikPole')
mRP.doName()
self.mRigNull.connectChildNode(mRP, 'controlIKMid', 'rigNull') #Connect
log.debug(cgmGEN._str_subLine)
return mRP
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 = ml_baseJoints[1].doCreateAt(setClass=True)
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType'])
mIKBaseCrv.doStore('cgmName','hips')
else:
mIKBaseCrv = ml_baseJoints[0].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 = 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())
def limbRoot(self):
try:
_str_func = 'limbRoot'
log_start(_str_func)
ml_fkJoints = self.ml_fkJoints
_short_module = self.mModule.mNode
mHandleFactory = self.mHandleFactory
#limbRoot ------------------------------------------------------------------------------
log.debug("|{0}| >> LimbRoot".format(_str_func))
idx = 0
#if self.b_lever:
# idx = 1
mLimbRootHandle = self.ml_prerigHandles[idx]
mLimbRoot = ml_fkJoints[0].rigJoint.doCreateAt()
_size_root = MATH.average(POS.get_bb_size(self.mRootFormHandle.mNode))
#MATH.average(POS.get_bb_size(self.mRootFormHandle.mNode))
mRootCrv = cgmMeta.validateObjArg(CURVES.create_fromName(
'locatorForm', _size_root),
'cgmObject',
setClass=True)
mRootCrv.doSnapTo(ml_fkJoints[0]) #mLimbRootHandle
#SNAP.go(mRootCrv.mNode, ml_joints[0].mNode,position=False)
CORERIG.shapeParent_in_place(mLimbRoot.mNode, mRootCrv.mNode, False)
for a in 'cgmName', 'cgmDirection', 'cgmModifier':
if ATTR.get(_short_module, a):
ATTR.copy_to(_short_module,
a,
mLimbRoot.mNode,
driven='target')
mLimbRoot.doStore('cgmTypeModifier', 'limbRoot')
mLimbRoot.doName()
mHandleFactory.color(mLimbRoot.mNode, controlType='sub')
self.mRigNull.connectChildNode(mLimbRoot, 'limbRoot', 'rigNull')
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
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 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 create_localAxisProxyBAK(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_localAxisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node"
l_shapes = TRANS.shapes_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#_dup = TRANS.parent_set(_dup,False)
#Get some values...
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
TRANS.orient_set(_dup, (0, 0, 0))
ATTR.set(_dup, 'scale', [1, 1, 1])
_size = POS.get_bb_size(_dup, True)
import cgm.core.lib.math_utils as COREMATH
reload(COREMATH)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
return
#mc.xform(_proxy, scale = _size, worldSpace = True, absolute = True)
#Parent it to the dup...
_proxy = TRANS.parent_set(_proxy, _dup)
ATTR.reset(_proxy, ['t', 'r', 'shear'])
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
ATTR.set(_dup, 'shear', shear)
#TRANS.scaleLocal_set(_dup, s)
#mc.delete(_dup)
#_scaleLossy = TRANS.scaleLossy_get(_dag)
#import cgm.core.lib.math_utils as COREMATH
#TRANS.scaleLocal_set(_dup, COREMATH.list_mult([-1.0,-1.0,-1.0],_scaleLossy,))
#proxy = TRANS.parent_set(_proxy, False)
cgmGEN.func_snapShot(vars())
#ATTR.set(_dup,'translate',t)
#ATTR.set(_dup,'rotate',r)
#SNAP.go(_proxy[0],_dag)
#ATTR.set(_proxy[0],'scale',_scaleLossy)
#TRANS.scaleLocal_set(_dup,[1,1,1])
#ATTR.set(_dup,'shear',[0,0,0])
#_proxy = TRANS.parent_set(_proxy, False)
#TRANS.scaleLocal_set(_proxy,_scaleLossy)
#ATTR.set(_dup,'scale',s)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def create_axisProxy(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_axisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(obj)
if VALID.is_shape(obj):
l_shapes = [obj]
else:
l_shapes = TRANS.shapes_get(_dag, True)
_parent = TRANS.parent_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#TRANS.pivots_recenter(_dup)
_dup = TRANS.parent_set(_dup, False)
ATTR.set_standardFlags(_dup, lock=False, keyable=True)
#Get some values...
l_reset = ['t', 'r', 's', 'shear', 'rotateAxis']
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
ra = ATTR.get(_dup, 'rotateAxis')
if ATTR.has_attr(_dup, 'jointOrient'):
l_reset.append('jointOrient')
jo = ATTR.get(_dup, 'jointOrient')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
ATTR.reset(_dup, l_reset)
_size = POS.get_bb_size(_dup, True)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
#Now Put it back
_dup = TRANS.parent_set(_dup, TRANS.parent_get(_dag))
_proxy = TRANS.parent_set(_proxy, _dup)
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
#ATTR.set(_dup,'s',(0,0,0))
ATTR.reset(_dup, ['s', 'shear'])
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
_proxy = TRANS.parent_set(_proxy, _dag)
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
#match_transform(_proxy,_dag)
#SNAP.go(_proxy,_dag,pivot='bb')
#cgmGEN.func_snapShot(vars())
_proxy = TRANS.parent_set(_proxy, False)
mc.delete(_dup)
#match_transform(_proxy,_dag)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
