def segment_handles(self, ml_handles=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'] if not ml_handles: raise ValueError, "{0} | ml_handles required".format(_str_func) ml_handleShapes = self.atBuilderUtils( 'shapes_fromCast', targets=ml_handles, offset=_offset, mode='limbSegmentHandle') #'segmentHandle') limbSegmentHandle for i, mCrv in enumerate(ml_handleShapes): log.debug("|{0}| >> Shape: {1} | Handle: {2}".format( _str_func, mCrv.mNode, ml_handles[i].mNode)) self.mHandleFactory.color(mCrv.mNode, controlType='sub') CORERIG.shapeParent_in_place(ml_handles[i].mNode, mCrv.mNode, False, replaceShapes=True) except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def define(self): _short = self.mNode _str_func = '[{0}] define'.format(_short) ATTR.set_alias(_short, 'sy', 'blockScale') self.setAttrFlags(attrs=['sx', 'sz', 'sz']) self.doConnectOut('sy', ['sx', 'sz']) ATTR.set_hidden(_short, 'baseSize', True) _shapes = self.getShapes() if _shapes: log.debug("|{0}| >> Removing old shapes...".format(_str_func)) mc.delete(_shapes) _size = self.atUtils('defineSize_get') #_sizeSub = _size / 2.0 log.debug("|{0}| >> Size: {1}".format(_str_func, _size)) _crv = CURVES.create_fromName(name='locatorForm', direction='z+', size=_size * 2.0) SNAP.go(_crv, self.mNode) CORERIG.override_color(_crv, 'white') CORERIG.shapeParent_in_place(self.mNode, _crv, False) mHandleFactory = self.asHandleFactory() self.addAttr('cgmColorLock', True, lock=True, hidden=True) if self.cgmName == 'default': self.cgmName = 'eyeLook' self.doName()
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 form(self): _crv = CURVES.create_controlCurve(self.mNode, shape='circleArrow', direction='y+', sizeMode='fixed', size=self.baseSize) RIG.shapeParent_in_place(self.mNode, _crv, False) return True
def template(self): _crv = CURVES.create_controlCurve( self.mNode, shape=self.getEnumValueString('basicShape'), direction='z+', sizeMode='fixed', size=self.baseSize) RIG.shapeParent_in_place(self.mNode, _crv, False) return True
def ik_segMid(self,mHandle = None): try: _str_func = 'ik_segMid' log_start(_str_func) ml_shapes = self.atBuilderUtils('shapes_fromCast', targets = mHandle, offset = self.v_offset, mode = 'simpleCast')#'segmentHan CORERIG.shapeParent_in_place(mHandle.mNode, ml_shapes[0].mNode,False) mHandle.doStore('cgmTypeModifier','ik') mHandle.doStore('cgmType','handle') mHandle.doName() self.mHandleFactory.color(mHandle.mNode, controlType = 'sub') return mHandle 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 direct(self, ml_rigJoints=None): try: _str_func = 'direct' log_start(_str_func) mBlock = self.mBlock mRigNull = self.mRigNull _offset = self.v_offset _jointOrientation = self.d_orientation['str'] if not ml_rigJoints: ml_rigJoints = mRigNull.msgList_get('rigJoints') if len(ml_rigJoints) < 3: _size_direct = DIST.get_distance_between_targets( [mObj.mNode for mObj in ml_rigJoints], average=True) d_direct = {'size': _size_direct / 2} else: d_direct = {'size': None} ml_directShapes = self.atBuilderUtils('shapes_fromCast', ml_rigJoints, mode='direct', **d_direct) for i, mCrv in enumerate(ml_directShapes): self.mHandleFactory.color(mCrv.mNode, controlType='sub') CORERIG.shapeParent_in_place(ml_rigJoints[i].mNode, mCrv.mNode, False, replaceShapes=True) for mJnt in ml_rigJoints: try: mJnt.drawStyle = 2 except: mJnt.radius = .00001 return ml_rigJoints except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def prerig(self): try: #self.atUtils('puppet_verify') self.UTILS.puppet_verify(self) #Create preRig Null ================================================================================== mPrerigNull = self.atBlockUtils('prerigNull_verify') mHandleFactory = self.asHandleFactory(self.mNode) ml_handles = [self.mNode] #Helpers===================================================================================== self.msgList_connect('prerigHandles', [self.mNode]) if self.addMotionJoint: mMotionJoint = mHandleFactory.addRootMotionHelper( baseShape='arrowSingleFat3d', shapeDirection='y-') mShape = mMotionJoint.doDuplicate(po=False) SNAP.to_ground(mShape.mNode) CORERIG.shapeParent_in_place(mMotionJoint.mNode, mShape.mNode, False, True) mMotionJoint.p_parent = mPrerigNull except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def lever(self, ball=False): try: _str_func = 'lever_digit' log_start(_str_func) mBlock = self.mBlock mRigNull = self.mRigNull _offset = self.v_offset _jointOrientation = self.d_orientation['str'] ml_formHandles = self.ml_formHandles ml_prerigHandles = self.ml_prerigHandles mHandleFactory = self.mHandleFactory #Mesh shapes ---------------------------------------------------------- mMesh_tmp = self.mBlock.atUtils('get_castMesh') str_meshShape = mMesh_tmp.getShapes()[0] #Figure out our knots ---------------------------------------------------- mMain = self.ml_formHandlesUse[0] mMainLoft = mMain.loftCurve idxMain = self.ml_shapers.index(mMainLoft) minU = ATTR.get(str_meshShape, 'minValueU') maxU = ATTR.get(str_meshShape, 'maxValueU') f_factor = (maxU - minU) / (20) pprint.pprint(vars()) #reload(SURF) #Meat ============================================================== mLeverDirect = mRigNull.getMessageAsMeta('leverDirect') mLeverFK = mRigNull.getMessageAsMeta('leverFK') mLeverControlCast = mLeverDirect if not mLeverControlCast: mLeverControlCast = mLeverFK log.debug("|{0}| >> mLeverControlCast: {1}".format( _str_func, mLeverControlCast)) dist_lever = DIST.get_distance_between_points( ml_prerigHandles[0].p_position, ml_prerigHandles[1].p_position) log.debug("|{0}| >> Lever dist: {1}".format(_str_func, dist_lever)) #Dup our rig joint and move it mDup = mLeverControlCast.doDuplicate(po=True) mDup.p_parent = mLeverControlCast mDup.resetAttrs() ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]), dist_lever * .5) l_lolis = [] l_starts = [] _mTar = mDup if ball: #Loli =============================================================== mDefineLeverObj = mBlock.defineLeverHelper _mVectorLeverUp = MATH.get_obj_vector(mDefineLeverObj.mNode, 'y+', asEuclid=True) #mOrientHelper = mBlock.orientHelper #_mVectorLeverUp = MATH.get_obj_vector(mOrientHelper.mNode,'y+',asEuclid=True) mBall_tmp = mBlock.atUtils('get_castMesh') str_ballShape = mBall_tmp.getShapes()[0] pos = RAYS.cast(str_ballShape, startPoint=_mTar.p_position, vector=_mVectorLeverUp).get('near') #pos = RAYS.get_cast_pos(_mTar.mNode,_mVectorLeverUp,shapes = str_ballShape) #SNAPCALLS.get_special_pos([_mTar,str_ballShape],'castNear',str_settingsDirections,False) vec = MATH.get_vector_of_two_points(_mTar.p_position, pos) newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4) ball = CURVES.create_fromName('sphere', _offset * 2) mBall = cgmMeta.cgmObject(ball) mBall.p_position = newPos SNAP.aim_atPoint( mBall.mNode, _mTar.p_position, aimAxis=_jointOrientation[0] + '+', mode='vector', vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-')) line = mc.curve(d=1, ep=[pos, newPos], os=True) l_lolis.extend([ball, line]) ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]), dist_lever * .8) CORERIG.shapeParent_in_place(mLeverFK.mNode, l_lolis, False) mBall_tmp.delete() #Main clav section ======================================== """ ml_clavShapes = BUILDUTILS.shapes_fromCast(self, targets= [mLeverControlCast.mNode, mDup.mNode], aimVector= self.d_orientation['vectorOut'], connectionPoints = 5, f_factor=0, offset=_offset, mode = 'frameHandle')""" l_curves = SURF.get_splitValues(str_meshShape, knotIndices=[0, idxMain], mode='u', insertMax=False, preInset=f_factor * .5, postInset=-f_factor * .5, curvesCreate=True, curvesConnect=True, connectionPoints=6, offset=self.v_offset) ml_shapes = cgmMeta.validateObjListArg(l_curves) mHandleFactory.color(mLeverFK.mNode, controlType='sub') CORERIG.shapeParent_in_place(mLeverFK.mNode, ml_shapes[0].mNode, False, replaceShapes=False) mDup.delete() for mShape in ml_shapes: try: mShape.delete() except: pass mMesh_tmp.delete() except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
ATTR.set(o,'segmentScaleCompensate',0) ATTR.set_default('l_glove_upr_pinky_end_jnt','tz', ATTR.get('l_glove_upr_pinky_end_jnt','tz')) for o in mc.ls(sl=True): mc.rename(o,o.replace('__','_')) import cgm.core.cgm_Meta as cgmMeta import cgm.core.lib.rigging_utils as RIGGING ml = cgmMeta.validateObjListArg(mc.ls(sl=1)) for mObj in ml: _source = mObj.getMessage('cgmSource') RIGGING.shapeParent_in_place(_source[0],mObj.mNode,False) cgmMeta.asMeta(_source).doGroup(True) import cgm.core.rig.joint_utils as JOINTS ml = cgmMeta.validateObjListArg(mc.ls(sl=1)) _p = [] for mObj in ml: _p.append(mObj.parent) mObj.parent = False for mObj in ml: mObj.rx = 90 mObj.rz = 180 JOINTS.freezeOrientation(mObj) for i,mObj in enumerate(ml): mObj.parent = _p[i]
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())
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
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())
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 is_form(self): if self.getShapes(): return True return False #=============================================================================================================
#>>> Skirt controls ml_joints = cgmMeta.validateObjListArg(mc.ls(sl=1)) for mJnt in ml_joints: mDup = mJnt.doDuplicate() mDup.connectParentNode(mJnt.mNode, 'source', 'driver') mDup.rename(mDup.p_nameBase.replace('_sknj', '_driver_jnt')) mDup.parent = False mc.pointConstraint(mDup.mNode, mJnt.mNode, maintainOffset=True) mc.orientConstraint(mDup.mNode, mJnt.mNode, maintainOffset=True) import cgm.core.lib.rigging_utils as RIGGING for o in mc.ls(sl=True): mObj = cgmMeta.cgmObject(o) _bfr = mObj.getMessage('cgmSource')[0] RIGGING.shapeParent_in_place(_bfr, mObj.mNode, False) import cgm.core.lib.attribute_utils as ATTR for o in mc.ls('*sdk'): ATTR.set(o, 'rotateOrder', 5) #...picker groups def setUpPickerGroups(control=None, atr=None, groups=[]): import cgm.core.classes.NodeFactory as nodeF import cgm.core.cgm_Meta as cgmMeta import cgm.core.lib.attribute_utils as ATTR mGroups = cgmMeta.validateObjListArg(groups, 'cgmObject') mControl = cgmMeta.validateObjArg(control, 'cgmObject')
def register( controlObject=None, #(mObject - None) -- The object to use as a control typeModifier=None, #(string - None) -- Tag for cgmTypeModifier for naming copyTransform=None, #(mObject - None) -- Object to copy the transform of for our control object copyPivot=None, #(mObject - None) -- Object to copy the pivot of for our control object shapeParentTo=None, #'(mObject - None) -- Object to shape parent our control curve to to use that transform useShape=None, #'(mObject - None) -- Object to use the curve shape of for our control setRotateOrder=None, #'(rotateOrder - None) -- Argument for a rotate order to set autoLockNHide=None, #'(bool - None) -- Try to set lock and hide mirrorAxis=None, #'(string - None) -- Mirror axis to set - using red9's setup terms mirrorSide=None, #'(string/int - None) -- Mirror side - using red9's setup terms makeMirrorable=True, #'(bool - True) -- Setup for mirrorability (using red9) -- implied by other mirror args addDynParentGroup=False, #'(False) -- Add a dynParent group setup addExtraGroups=False, #'(int - False) -- Number of nested extra groups desired addConstraintGroup=False, #'(bool - False) -- If a group just above the control is desired for consraining freezeAll=False, #'(bool - False) -- Freeze all transforms on the control object noFreeze=False, addSpacePivots=False, #'(int - False) -- Number of space pivots to generate and connect controlType=None, #'(string - None) -- Tag for cgmType aim=None, #'(string/int - None) -- aim axis to use up=None, #'(string/int - None) -- up axis to use out=None, #'(string/int - None) -- out axis to use makeAimable=None, #'(mObject - False) -- Make object aimable -- implied by aim/up/out): **kws): _str_func = 'register' """ [{'step':'validate','call':self._validate}, {'step':'Copy Transform','call':self._copyTransform}, {'step':'Shape Parent','call':self._shapeParent}, {'step':'Copy Pivot','call':self._copyPivot}, {'step':'Naming','call':self._naming}, {'step':'Aim Setup','call':self._aimSetup}, {'step':'Rotate Order','call':self._rotateOrder}, {'step':'Initial Freeze','call':self._initialFreeze}, {'step':'Groups Setup','call':self._groupsSetup}, {'step':'Space Pivot','call':self._spacePivots}, {'step':'Mirror Setup','call':self._mirrorSetup}, {'step':'Freeze','call':self._freeze}, {'step':'Mirror Attribute Bridges','call':self._mirrorAttributeBridges_}, {'step':'lock N Hide','call':self._lockNHide}, {'step':'Return build','call':self._returnBuild}] """ try: #Validate ================================================================================================ mi_control = cgmMeta.validateObjArg(controlObject, 'cgmControl', setClass=True) str_mirrorAxis = VALID.stringArg(mirrorAxis, calledFrom=_str_func) str_mirrorSide = cgmGeneral.verify_mirrorSideArg( mirrorSide) #VALID.stringArg(mirrorSide,calledFrom = _str_func) b_makeMirrorable = VALID.boolArg(makeMirrorable, calledFrom=_str_func) _addMirrorAttributeBridges = kws.get('addMirrorAttributeBridges', False) addForwardBack = kws.get('addForwardBack', False) if _addMirrorAttributeBridges: if type(_addMirrorAttributeBridges) not in [list, tuple]: raise ValueError, "[Bad addMirrorAttributeBridge arg]{arg: %s}" % _addMirrorAttributeBridge for i, l in enumerate(_addMirrorAttributeBridges): if type(l) not in [list, tuple]: raise ValueError, "[Bad addMirrorAttributeBridge arg: %s]{arg: %s}" % ( i, l) # Running lists ------------------------------------------------------------------------------------------ ml_groups = [] #Holder for groups ml_constraintGroups = [] ml_spacePivots = [] #Copy Transform ================================================================================================ if copyTransform is not None: mTarget = cgmMeta.validateObjArg(copyTransform, 'cgmObject', noneValid=True) if not mTarget: raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyTransform #Need to move this to default cgmNode stuff mBuffer = mi_control i_newTransform = cgmMeta.cgmObject( rigging.groupMeObject(mTarget.mNode, False)) for a in mc.listAttr(mi_control.mNode, userDefined=True): ATTR.copy_to(mi_control.mNode, a, i_newTransform.mNode) curves.parentShapeInPlace(i_newTransform.mNode, mi_control.mNode) #Parent shape i_newTransform.parent = mi_control.parent #Copy parent mi_control = cgmMeta.asMeta(i_newTransform, 'cgmControl', setClass=True) mc.delete(mBuffer.mNode) #ShapeParent ================================================================================================ if shapeParentTo: i_target = cgmMeta.validateObjArg(shapeParentTo, 'cgmObject') CORERIG.shapeParent_in_place(i_target.mNode, mi_control.mNode) i_target = cgmMeta.asMeta(i_target, 'cgmControl', setClass=True) #mi_control.delete() mi_control = i_target #replace the control with the joint if useShape is not None: i_shape = cgmMeta.validateObjArg(useShape, cgmMeta.cgmObject, mayaType='nurbsCurve') curves.parentShapeInPlace(mi_control.mNode, i_shape.mNode) #Copy Pivot ============================================================================================ if copyPivot is not None: if issubclass(type(copyPivot), cgmMeta.cgmNode): i_target = copyPivot elif mc.objExists(copyPivot): i_target = cgmMeta.cgmObject(copyPivot) else: raise StandardError, "Failed to find suitable copyTransform object: '%s" % copyPivot #Need to move this to default cgmNode stuff mi_control.doCopyPivot(i_target.mNode) #Naming ============================================================================================ mi_control.addAttr('cgmType', 'controlAnim', lock=True) if typeModifier is not None: mi_control.addAttr('cgmTypeModifier', str(typeModifier), lock=True) mi_control.doName() #mi_control.doName(nameShapes=True) #Rotate Order ============================================================================================ _rotateOrder = False if setRotateOrder is not None: _rotateOrder = setRotateOrder elif controlType in __d_rotateOrderDefaults__.keys(): _rotateOrder = __d_rotateOrderDefaults__[controlType] elif mi_control.getAttr('cgmName') in __d_rotateOrderDefaults__.keys(): _rotateOrder = __d_rotateOrderDefaults__[mi_control.getAttr( 'cgmName')] else: log.debug("|{0}| >> Rotate order not set on: {1}".format( _str_func, mi_control.p_nameShort)) #Set it --------------------------------------------------------------- if _rotateOrder: mRotateOrder = VALID.simpleOrientation(_rotateOrder) #dictionary.validateRotateOrderString(_rotateOrder) mc.xform(mi_control.mNode, rotateOrder=mRotateOrder.p_string) #Initial Freeze ============================================================================================ if freezeAll: mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=1, s=1, n=0) #Groups ============================================================================================ if addDynParentGroup or addSpacePivots or mi_control.getAttr( 'cgmName') == 'cog' or _addMirrorAttributeBridges: mi_control.addAttr('________________', attrType='int', keyable=False, hidden=False, lock=True) ATTR.reorder(mi_control.mNode, '________________', top=True) #Aim Setup ============================================================================================ if aim is not None or up is not None or makeAimable: mi_control._verifyAimable() #First our master group: i_masterGroup = (cgmMeta.asMeta(mi_control.doGroup(True), 'cgmObject', setClass=True)) i_masterGroup.doStore('cgmName', mi_control) i_masterGroup.addAttr('cgmTypeModifier', 'master', lock=True) i_masterGroup.doName() mi_control.connectChildNode(i_masterGroup, 'masterGroup', 'groupChild') if addDynParentGroup: i_dynGroup = (cgmMeta.cgmObject(mi_control.doGroup(True))) i_dynGroup = cgmRigMeta.cgmDynParentGroup(dynChild=mi_control, dynGroup=i_dynGroup) i_dynGroup.doName() """ i_zeroGroup = (cgmMeta.cgmObject(mi_control.doGroup(True))) i_zeroGroup.addAttr('cgmTypeModifier','zero',lock=True) i_zeroGroup.doName() mi_control.connectChildNode(i_zeroGroup,'zeroGroup','groupChild')""" if addExtraGroups: for i in range(addExtraGroups): i_group = (cgmMeta.asMeta(mi_control.doGroup(True), 'cgmObject', setClass=True)) if type( addExtraGroups ) == int and addExtraGroups > 1: #Add iterator if necessary i_group.addAttr('cgmIterator', str(i + 1), lock=True) i_group.doName() ml_groups.append(i_group) mi_control.msgList_connect("extraGroups", ml_groups, 'groupChild') if addConstraintGroup: #ConstraintGroups i_constraintGroup = (cgmMeta.asMeta(mi_control.doGroup(True), 'cgmObject', setClass=True)) i_constraintGroup.addAttr('cgmTypeModifier', 'constraint', lock=True) i_constraintGroup.doName() ml_constraintGroups.append(i_constraintGroup) mi_control.connectChildNode(i_constraintGroup, 'constraintGroup', 'groupChild') #Space Pivot ============================================================================================ if addSpacePivots: parent = mi_control.getMessage('masterGroup')[0] for i in range(int(addSpacePivots)): #i_pivot = rUtils.create_spaceLocatorForObject(mi_control.mNode,parent) i_pivot = SPACEPIVOTS.create(mi_control.mNode, parent) ml_spacePivots.append(i_pivot) #log.info("spacePivot created: {0}".format(i_pivot.p_nameShort)) #Mirror Setup ============================================================================================ if str_mirrorSide is not None or b_makeMirrorable: for mObj in [mi_control] + ml_spacePivots: mi_control._verifyMirrorable() l_enum = cgmMeta.cgmAttr(mi_control, 'mirrorSide').p_enum if str_mirrorSide in l_enum: #log.debug("|{0}| >> Rotate order not set on: {1}".format(_str_func,mi_control.p_nameShort)) #log.debug("%s >> %s >> found in : %s"%(_str_funcCombined, "mirrorSetup", l_enum)) mi_control.mirrorSide = l_enum.index(str_mirrorSide) if str_mirrorAxis: mi_control.mirrorAxis = str_mirrorAxis for mObj in mi_control.msgList_get('spacePivots'): mObj._verifyMirrorable() mi_control.doConnectOut('mirrorAxis', mObj.mNode + '.mirrorAxis') mi_control.doConnectOut('mirrorSide', mObj.mNode + '.mirrorSide') #cgmMeta.cgmAttr(mObj,'mirrorSide').doConnectIn(mi_control,'mirrorSide') #cgmMeta.cgmAttr(mi_control,'mirrorAxis').doCopyTo(mObj,connectTargetToSource = 1) #ATTR.connect(mObj.mNode + '.mirrorAxis',"{0}.mirrorAxis".format(mi_control.mNode)) #ATTR.connect(mObj.mNode + 'mirrorSide',"{0}.mirrorSide".format(mi_control.mNode)) #Freeze ============================================================================================ if not shapeParentTo and noFreeze is not True: if not freezeAll: if mi_control.getAttr( 'cgmName' ) == 'cog' or controlType in __l_fullFreezeTypes__: mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=1, s=1, n=0) else: mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=0, s=1, n=0) else: mc.makeIdentity(mi_control.mNode, apply=True, t=1, r=1, s=1, n=0) #Mirror attriubte Bridges ========================================================================== if addForwardBack: mPlug_forwardBackDriver = cgmMeta.cgmAttr(mi_control, "forwardBack", attrType='float', keyable=True) try: mPlug_forwardBackDriven = cgmMeta.validateAttrArg( [mi_control, addForwardBack])['mi_plug'] except Exception, error: raise StandardError, "push pull driver | %s" % (error) if str_mirrorSide.lower() == 'right': arg_forwardBack = "%s = -%s" % ( mPlug_forwardBackDriven.p_combinedShortName, mPlug_forwardBackDriver.p_combinedShortName) else: arg_forwardBack = "%s = %s" % ( mPlug_forwardBackDriven.p_combinedShortName, mPlug_forwardBackDriver.p_combinedShortName) mPlug_forwardBackDriven.p_locked = True mPlug_forwardBackDriven.p_hidden = True mPlug_forwardBackDriven.p_keyable = False NodeF.argsToNodes(arg_forwardBack).doBuild() if _addMirrorAttributeBridges: for l_bridge in _addMirrorAttributeBridges: _attrName = VALID.stringArg(l_bridge[0]) _attrToBridge = VALID.stringArg(l_bridge[1]) if not mi_control.hasAttr(_attrToBridge): raise StandardError, "['%s' lacks the bridge attr '%s']" % ( mi_control.p_nameShort, _attrToBridge) mPlug_attrBridgeDriver = cgmMeta.cgmAttr(mi_control, _attrName, attrType='float', keyable=True) try: mPlug_attrBridgeDriven = cgmMeta.validateAttrArg( [mi_control, _attrToBridge])['mi_plug'] except Exception, error: raise StandardError, "[validate control attribute bridge attr]{%s}" % ( error) if str_mirrorSide.lower() == 'right': arg_attributeBridge = "%s = -%s" % ( mPlug_attrBridgeDriven.p_combinedShortName, mPlug_attrBridgeDriver.p_combinedShortName) else: arg_attributeBridge = "%s = %s" % ( mPlug_attrBridgeDriven.p_combinedShortName, mPlug_attrBridgeDriver.p_combinedShortName) mPlug_attrBridgeDriven.p_locked = True mPlug_attrBridgeDriven.p_hidden = True mPlug_attrBridgeDriven.p_keyable = False NodeF.argsToNodes(arg_attributeBridge).doBuild()
def leverBAK(self, ml_handles=None): try: _str_func = 'lever' log_start(_str_func) mBlock = self.mBlock mRigNull = self.mRigNull _offset = self.v_offset _jointOrientation = self.d_orientation['str'] ml_formHandles = self.ml_formHandles #Get our curves... ml_targets = [] for i, mHandle in enumerate(ml_formHandles[:2]): ml_targets.append(mHandle.loftCurve) if i: continue ml_sub = mHandle.msgList_get('subShapers') if ml_sub: for mSub in ml_sub: ml_targets.append(mSub) ml_new = [] for mTar in ml_targets: mDup = mTar.doDuplicate(po=False) DIST.offsetShape_byVector(mDup.mNode, _offset) mDup.p_parent = False ml_new.append(mDup) CURVES.connect([mTar.mNode for mTar in ml_new], mode='even') return ml_new[0] mLeverControlJoint = mRigNull.getMessageAsMeta('leverDirect') mLeverControlFK = mRigNull.getMessageAsMeta('leverFK') if not mLeverControlJoint: mLeverControlJoint = mLeverControlFK else: mLeverControlJoint = mLeverControlJoint log.debug("|{0}| >> mLeverControlJoint: {1}".format( _str_func, mLeverControlJoint)) dist_lever = DIST.get_distance_between_points( ml_prerigHandles[0].p_position, ml_prerigHandles[1].p_position) log.debug("|{0}| >> Lever dist: {1}".format(_str_func, dist_lever)) #Dup our rig joint and move it mDup = mLeverControlJoint.doDuplicate() mDup.p_parent = mLeverControlJoint mDup.resetAttrs() ATTR.set(mDup.mNode, 't{0}'.format(_jointOrientation[0]), dist_lever * .8) mDup2 = mDup.doDuplicate() ATTR.set(mDup2.mNode, 't{0}'.format(_jointOrientation[0]), dist_lever * .25) ml_clavShapes = BUILDUTILS.shapes_fromCast( self, targets=[ mDup2.mNode, #ml_fkJoints[0].mNode], mDup.mNode ], aimVector=self.d_orientation['vectorOut'], offset=_offset, f_factor=0, mode='frameHandle') mHandleFactory.color(ml_clavShapes[0].mNode, controlType='main') CORERIG.shapeParent_in_place(mLeverControlFK.mNode, ml_clavShapes[0].mNode, True, replaceShapes=True) #CORERIG.shapeParent_in_place(mLeverFKJnt.mNode,ml_clavShapes[0].mNode, False, replaceShapes=True) mc.delete([mShape.mNode for mShape in ml_clavShapes] + [mDup.mNode, mDup2.mNode]) except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
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())
def chain_create(self, objs = None, fwd = None, up=None, name = None, upSetup = "guess", extendStart = None, extendEnd = True, mNucleus=None, upControl = None, aimUpMode = None, **kws): _str_func = 'chain_create' if not objs: _sel = mc.ls(sl=1) if _sel:objs = _sel ml = cgmMeta.asMeta( objs, noneValid = True ) ml_baseTargets = copy.copy(ml) if not ml: return log.warning("No objects passed. Unable to chain_create") if not name: name = ml[-1].p_nameBase _idx = self.get_nextIdx() #Make our sub group... mGrp = self.doCreateAt(setClass=1) mGrp.p_parent = self mGrp.rename("chain_{0}_grp".format(name)) mGrp.dagLock() self.connectChildNode(mGrp.mNode,'chain_{0}'.format(_idx),'owner') #holders and dat... ml_targets = [] ml_posLocs = [] ml_aim_locs = [] fwd = fwd or self.fwd up = up or self.up upSetup = upSetup or self.upSetup extendStart = extendStart or self.extendStart extendEnd = extendEnd or self.extendEnd upControl = upControl or self.upControl aimUpMode = aimUpMode or self.aimUpMode #fwdAxis = simpleAxis(fwd) #upAxis = simpleAxis(up) fwdAxis = TRANS.closestAxisTowardObj_get(ml[0], ml[1]) upAxis = TRANS.crossAxis_get(fwdAxis) mGrp.doStore('fwd', fwdAxis.p_string) mGrp.doStore('up', upAxis.p_string) #Curve positions... l_pos = [] if upSetup == 'manual': if len(ml) < 2: log.debug(cgmGEN.logString_msg(_str_func, 'Single count. Adding extra handle.')) mLoc = ml[0].doLoc() mLoc.rename("chain_{0}_end_loc".format(name)) _size = DIST.get_bb_size(ml[0],True,'max') mLoc.p_position = ml[0].getPositionByAxisDistance(fwdAxis.p_string,_size) ml.append(mLoc) mLoc.p_parent = mGrp for obj in ml: l_pos.append(obj.p_position) _v_baseDist = DIST.get_distance_between_points(l_pos[-1],l_pos[-2]) _v_baseDist = MATHUTILS.Clamp(_v_baseDist, .5,None) _p_baseExtend = DIST.get_pos_by_axis_dist(ml[-1], fwdAxis.p_string, _v_baseDist) if extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...')) extendEnd = VALID.valueArg(extendEnd) if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd): log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess')) l_pos.append(_p_baseExtend) elif extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | {0}'.format(extendEnd))) l_pos.append( DIST.get_pos_by_axis_dist(ml[-1], fwdAxis.p_string, extendEnd )) else: l_pos.append( _p_baseExtend) if extendStart: f_extendStart = VALID.valueArg(extendStart) if f_extendStart: l_pos.insert(0, DIST.get_pos_by_axis_dist(ml[0], fwdAxis.inverse.p_string, f_extendStart )) else: log.debug(cgmGEN.logString_msg(_str_func, 'Resolving aim')) if len(ml) < 2: return log.error(cgmGEN.logString_msg(_str_func, 'Single count. Must use manual upSetup and aim/up args')) for obj in ml: l_pos.append(obj.p_position) _vecEnd = MATHUTILS.get_vector_of_two_points(l_pos[-2],l_pos[-1]) if extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...')) extendEnd = VALID.valueArg(extendEnd) if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd): log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess')) l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd, (DIST.get_distance_between_points(l_pos[-2],l_pos[-1])/2))) elif extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendStart | {0}'.format(extendEnd))) l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd, extendEnd)) if extendStart: f_extendStart = VALID.valueArg(extendStart) if f_extendStart: log.debug(cgmGEN.logString_msg(_str_func, 'extendStart...')) _vecStart = MATHUTILS.get_vector_of_two_points(l_pos[1],l_pos[0]) l_pos.insert(0, DIST.get_pos_by_vec_dist(l_pos[0], _vecStart, f_extendStart)) #pprint.pprint(l_pos) #for i,p in enumerate(l_pos): # LOC.create(position=p,name='p_{0}'.format(i)) crv = CORERIG.create_at(create='curve',l_pos= l_pos, baseName = name) mInCrv = cgmMeta.asMeta(crv) mInCrv.rename("{0}_inCrv".format(name)) mGrp.connectChildNode(mInCrv.mNode,'mInCrv') mc.select(cl=1) # make the dynamic setup log.debug(cgmGEN.logString_sub(_str_func,'dyn setup')) b_existing = False b_existing_nucleus = False mHairSys = self.getMessageAsMeta('mHairSysShape') if mHairSys: mHairSysDag = mHairSys.getTransform(asMeta=1) log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(mHairSys.mNode))) mc.select(mHairSysDag.mNode, add=True) b_existing = True if self.useExistingNucleus or mNucleus: mNucleus = self.get_nucleus(mNucleus) if mNucleus: #mc.select(mNucleus.mNode,add=1) b_existing_nucleus = True log.info(cgmGEN.logString_msg(_str_func,'Using existing nucleus: {0}'.format(mNucleus.mNode))) self.connectChildNode(mNucleus.mNode,'mNucleus') mc.select(mInCrv.mNode,add=True) mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }') # get relevant nodes follicle = mc.listRelatives(mInCrv.mNode,parent=True)[0] mFollicle = cgmMeta.asMeta(follicle) mFollicle.rename("{0}_foll".format(name)) parent = mFollicle.getParent(asMeta=1) mFollicle.p_parent = mGrp mFollicleShape = mFollicle.getShapes(1)[0] mc.delete(parent.mNode) _follicle = mFollicle.mNode mGrp.connectChildNode(mFollicle.mNode,'mFollicle','group') follicleShape = mFollicleShape.mNode#mc.listRelatives(mFollicle.mNode, shapes=True)[0] _hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0], shapes=True)[0] if not b_existing: mHairSys = cgmMeta.asMeta(_hairSystem) mHairSysDag = mHairSys.getTransform(asMeta=1) mHairSysDag.rename("{0}_hairSys".format(self.baseName)) self.connectChildNode(mHairSysDag.mNode,'mHairSysDag','owner') self.connectChildNode(mHairSys.mNode,'mHairSysShape','owner') mHairSysDag.p_parent = self _hairSystem = mHairSys.mNode outCurve = mc.listConnections('%s.outCurve' % _follicle)[0] mCrv = cgmMeta.asMeta(outCurve) parent = mCrv.getParent(asMeta=1) outCurveShape = mc.listRelatives(mCrv.mNode, shapes=True)[0] mCrv.p_parent = mGrp.mNode mc.delete(parent.mNode) _nucleus = mc.listConnections( '%s.currentState' % mHairSys.mNode )[0] if not b_existing_nucleus: mNucleus = cgmMeta.asMeta(_nucleus) mNucleus.rename("cgmDynFK_nucleus") #self.connectChildNode(mNucleus.mNode,'mNucleus','owner') self.connectChildNode(mNucleus.mNode,'mNucleus') if self.startFrame is not None: mNucleus.startFrame = self.startFrame else: #Because maya is crappy we gotta manually wire the existing nucleus ##startFrame out to startFrame in ##outputObjects[x] - nextState ##shape.currentState>inputActive[x] ##shape.startState>inputActiveStart[x] if cgmMeta.asMeta(_nucleus).mNode != mNucleus.mNode: mc.delete(_nucleus) _useNucleus = mNucleus.mNode """ _useIdx = ATTR.get_nextCompoundIndex(mNucleus.mNode,'outputObjects') log.info("useIdx: {0}".format(_useIdx)) ATTR.connect('{0}.outputObjects[{1}]'.format(_useNucleus,_useIdx),'{0}.nextState'.format(_hairSystem)) ATTR.connect('{0}.currentState'.format(_hairSystem),'{0}.inputActive[{1}]'.format(_useNucleus,_useIdx)) ATTR.connect('{0}.startState'.format(_hairSystem),'{0}.inputActiveStart[{1}]'.format(_useNucleus,_useIdx))""" mParent = ml[0].getParent(asMeta=1) if not mParent: mParent = ml[0].doGroup(1,1, asMeta=True, typeModifier = 'dynFKParent', setClass='cgmObject') #else: #mParent.getParent(asMeta=1) mGrp.connectChildNode(mCrv.mNode,'mOutCrv','group') #self.follicles.append(follicle) #self.outCurves.append(outCurve) # set default properties mFollicleShape.pointLock = 1 #mc.setAttr( '%s.pointLock' % follicleShape, 1 ) mc.parentConstraint(ml[0].getParent(), _follicle, mo=True) # create locators on objects locators = [] prs = [] ml_locs = [] ml_aims = [] ml_prts = [] _upVector = None if upSetup == 'guess': log.debug(cgmGEN.logString_msg(_str_func, 'Resolving up/aim')) poci_base = CURVES.create_pointOnInfoNode(mInCrv.mNode,1) mPoci_base = cgmMeta.asMeta(poci_base) _upVector = mPoci_base.normalizedNormal log.debug(cgmGEN.logString_msg(_str_func, "upVector: {0}".format(_upVector))) #Let's make an up object as the parent of the root isn't good enough mUp = ml[0].doCreateAt(setClass=1) mUp.rename("chain_{0}_up".format(name)) mUp.p_parent = mGrp if _upVector: SNAP.aim_atPoint(mUp.mNode, DIST.get_pos_by_vec_dist(mUp.p_position, _upVector, 10),aimAxis='y+',upAxis='z+') if upControl: log.debug(cgmGEN.logString_msg(_str_func,'upControl')) if len(ml_baseTargets)>1: sizeControl = DIST.get_distance_between_targets([mObj.mNode for mObj in ml_baseTargets],True) else: sizeControl = DIST.get_bb_size(ml[0],True,'max') crv = CURVES.create_controlCurve(mUp.mNode,'arrowSingle', size= sizeControl, direction = 'y+') CORERIG.shapeParent_in_place(mUp.mNode, crv, False) mUpGroup = mUp.doGroup(True,True, asMeta=True, typeModifier = 'master', setClass='cgmObject') mc.parentConstraint(ml[0].getParent(), mUpGroup.mNode, mo=True) else: mc.parentConstraint(ml[0].getParent(), mUp.mNode, mo=True) # create control joint chain mc.select(cl=True) chain = [] for obj in ml: if len(chain) > 0: mc.select(chain[-1]) jnt = mc.joint(name='%s_%s_jnt' % (name, obj.p_nameBase)) SNAP.matchTarget_set(jnt, obj.mNode) mObj = cgmMeta.asMeta(jnt) mObj.doSnapTo(mObj.getMessageAsMeta('cgmMatchTarget')) chain.append(jnt) mc.parent(chain[0], _follicle) mInCrv.p_parent = mGrp mc.bindSkin(mInCrv.mNode, chain[0], ts=True) log.debug(cgmGEN.logString_msg(_str_func,'aimUpMode: {0}'.format(aimUpMode))) for i, mObj in enumerate(ml): if not i: mUpUse = mUp else: mUpUse = ml_locs[-1] mLoc = cgmMeta.asMeta( LOC.create(mObj.getNameLong()) ) loc = mLoc.mNode ml_locs.append(mLoc) #loc = LOC.create(mObj.getNameLong()) mAim = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'aim', setClass='cgmObject') ml_aims.append(mAim) #aimNull = mc.group(em=True) #aimNull = mc.rename('%s_aim' % mObj.getShortName()) poc = CURVES.create_pointOnInfoNode(outCurveShape) #mc.createNode('pointOnCurveInfo', name='%s_pos' % loc) mPoci_obj = cgmMeta.asMeta(poc) mPoci_obj.rename('%s_pos' % loc) pocAim = CURVES.create_pointOnInfoNode(outCurveShape) #mc.createNode('pointOnCurveInfo', name='%s_aim' % loc) pr = CURVES.getUParamOnCurve(loc, outCurve) mPoci_obj.parameter = pr #mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % poc, f=True ) #mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % pocAim, f=True ) #mc.setAttr( '%s.parameter' % poc, pr ) if i < len(ml)-1: nextpr = CURVES.getUParamOnCurve(ml[i+1], outCurve) mc.setAttr('%s.parameter' % pocAim, (nextpr))# + pr))# * .5) else: if extendStart: mc.setAttr( '%s.parameter' % pocAim, len(ml)+1 ) else: mc.setAttr( '%s.parameter' % pocAim, len(ml) ) mLocParent = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'pos', setClass='cgmObject') ml_prts.append(mLocParent) #locParent = mc.group(em=True) #locParent = mc.rename( '%s_pos' % mObj.getShortName() ) mc.connectAttr( '%s.position' % mPoci_obj.mNode, '%s.translate' % mLocParent.mNode) mc.connectAttr( '%s.position' % pocAim, '%s.translate' % mAim.mNode) if aimUpMode == 'master': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = mUp.mNode ) elif aimUpMode == 'orientToMaster': mc.orientConstraint( mUp.mNode, mLocParent.mNode, maintainOffset = 1) elif aimUpMode == 'sequential': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = mUpUse.mNode ) elif aimUpMode == 'joint': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = chain[i] ) elif aimUpMode == 'curveNormal': mUpLoc = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'up', setClass='cgmObject') mUpLoc.p_parent = mLocParent aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "object") mPlusMinusAverage = cgmMeta.cgmNode(name="{0}_pma".format(mObj.p_nameBase), nodeType = 'plusMinusAverage') mPlusMinusAverage.operation = 3 mPoci_obj.doConnectOut('position','{0}.input3D[0]'.format(mPlusMinusAverage.mNode)) mPoci_obj.doConnectOut('normalizedNormal','{0}.input3D[1]'.format(mPlusMinusAverage.mNode)) mUpLoc.doConnectIn('translate','{0}.output3D'.format(mPlusMinusAverage.mNode)) mLoc.p_parent = mLocParent mAim.p_parent = mGrp mLocParent.p_parent = mGrp #mc.parent(loc, locParent) mCrv.rename("{0}_outCrv".format(name)) mCrvParent = mCrv.getParent(asMeta=1) mCrvParent.p_parent = mGrp mGrp.msgList_connect('mLocs',ml_locs) mGrp.msgList_connect('mAims',ml_aims) mGrp.msgList_connect('mParents',ml_prts) mGrp.msgList_connect('mTargets',ml) mGrp.msgList_connect('mBaseTargets',ml_baseTargets) mGrp.msgList_connect('mObjJointChain',chain) mGrp.doStore('cgmName', name) mNucleus.doConnectOut('startFrame',"{0}.startFrame".format(mHairSys.mNode))
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())
:returns Prints commands in script editor Commands(list) """ _str_func = 'combine' _transform = shapeTranforms[0] for t in shapeTranforms: try: pass except Exception, err: raise Exception, "|{0}| >> Channel history delete on {2} | err: {1}".format( _str_func, err, t) for t in shapeTranforms[1:]: RIGGING.shapeParent_in_place(_transform, t, keepSource=False) return _transform def get_nonintermediate(shape): """ Get the nonintermediate shape on a transform :parameters: shape(str): Shape to check :returns non intermediate shape(string) """ _str_func = "get_nonintermediate"
def get_splitValues(surface=None, values=[], mode='u', knotIndices=[], insertMin=False, insertMax=False, preInset=None, postInset=None, offset=None, curvesCreate=False, curvesConnect=False, connectionPoints=9): """ Function to split a curve up u positionally :parameters: 'curve'(None) -- Curve to split curvesCreate(bool) - create new curves from the new values curvesConnect(bool) - whether to connect the first and last curves connectionPoints(int) - how many points of connection to use :returns list of values(list) hat tip: http://ewertb.soundlinker.com/mel/mel.074.php """ _str_func = 'get_splitValues' log.debug("|{0}| >> ".format(_str_func) + '-' * 80) _shape = SHAPES.get_nonintermediate(surface) if mode == 'u': l_base = get_dat(_shape, uKnots=True)['uKnots'] minKnot = ATTR.get(_shape, 'minValueU') maxKnot = ATTR.get(_shape, 'maxValueU') else: l_base = get_dat(_shape, vKnots=True)['vKnots'] minKnot = ATTR.get(_shape, 'minValueV') maxKnot = ATTR.get(_shape, 'maxValueV') l_sets = [] log.debug("|{0}| >> l_base: {1}".format(_str_func, l_base)) if knotIndices: values = [l_base[v] for v in knotIndices] for i, v in enumerate(values): log.debug("|{0}| >> Processing: {1} | {2}".format(_str_func, i, v) + "-" * 40) _last = False if v == values[-1]: log.debug("|{0}| >> last...".format(_str_func)) _last = True if preInset: v += preInset log.debug("|{0}| >> preinset: {1}".format(_str_func, v)) _l = [v] _stop = False for knot in l_base: if _stop or MATH.is_float_equivalent(knot, v) == v: continue log.debug("|{0}| >> checking knot: {1}".format(_str_func, knot)) if _last: if knot > v: _stop = True _l.append(knot) if knot > v or knot < v: if _last != True and knot < values[i + 1] and knot > v: _l.append(knot) log.debug("|{0}| >> knot add: {1}".format(_str_func, _l)) """ if v == values[-1]: if knot < maxKnot: _l.append(knot) elif _last != True and knot < values[i+1]: _l.append(knot)""" if _last and insertMax: l_add = [] for v2 in l_base: if v2 > _l[-1]: l_add.append(v2) for v2 in l_add: _l.append(v2) _l.append(maxKnot) if _last != True: _l.append(values[i + 1]) if insertMin and i == 0: _l.insert(0, minKnot) if postInset: vPost = _l[-1] + postInset if vPost < _l[-2]: log.debug("|{0}| >> alternate postInset".format(_str_func)) vPost = _l[-2] + postInset log.debug("|{0}| >> postInset: {1} | new: {2}".format( _str_func, _l[-1], vPost)) if len(_l) > 1: if vPost > max(_l[:-1]): log.debug( "|{0}| >> v post creater the max".format(_str_func)) _l[-1] = vPost else: _l = _l[:-1] else: _l.append(vPost) """ if _last != True: for v2 in _l: if v2 > v: _l.remove(v2)""" _l = LISTS.get_noDuplicates(_l) _l.sort() l_sets.append(_l) log.debug("|{0}| >> result: {1} | {2} | {3}".format( _str_func, i, v, _l)) l_pre = copy.copy(l_sets) #pprint.pprint(vars()) if not curvesCreate: return l_sets log.debug("|{0}| >> creating curves...".format(_str_func)) l_newCurves = [] d_curves = {} l_finalCurves = [] def getCurve(uValue, l_newCurves): _crv = d_curves.get(uValue) if _crv: return _crv _crv = mc.duplicateCurve("{0}.u[{1}]".format(_shape, uValue), ch=0, rn=0, local=0)[0] if offset: DIST.offsetShape_byVector(_crv, offset, component='cv') d_curves[uValue] = _crv log.debug("|{0}| >> created: {1} ...".format(_str_func, _crv)) l_newCurves.append(_crv) return _crv for i, uSet in enumerate(l_sets): _loftCurves = [getCurve(uValue, l_newCurves) for uValue in uSet] """ if len(uSet)<2: l_finalCurves.append(mc.duplicate(_loftCurves[0])[0]) continue""" log.debug("|{0}| >> {1} | u's: {2}".format(_str_func, i, uSet)) """ if i == 0 and str_start: _pair = [str_start,c,l_newCurves[i+1]] else: _pair = [c,l_newCurves[i+1]]""" if len(_loftCurves) == 1: l_mainCurves = [mc.duplicate(_loftCurves[0])[0]] else: crvBase = mc.duplicate(_loftCurves[0])[0] crvEnd = mc.duplicate(_loftCurves[-1])[0] l_mainCurves = [crvBase, crvEnd] if curvesConnect: log.debug("|{0}| >> {1} | Making connectors".format( _str_func, i)) d_epPos = {} for i, crv in enumerate(_loftCurves): _l = CURVES.getUSplitList(crv, connectionPoints, rebuild=True, rebuildSpans=30)[:-1] for ii, p in enumerate(_l): if not d_epPos.get(ii): d_epPos[ii] = [] _l = d_epPos[ii] _l.append(p) for k, points in d_epPos.iteritems(): log.debug("|{0}| >> {1} | k: {1} | points: {2}".format( _str_func, k, points)) try: crv_connect = mc.curve(d=1, ep=points, os=True) #CURVES.create_fromList(posList=points) l_mainCurves.append(crv_connect) except Exception, err: print err for crv in l_mainCurves[1:]: CORERIG.shapeParent_in_place(l_mainCurves[0], crv, False) #ml_shapes.append(cgmMeta.validateObjArg(l_mainCurves[0])) l_finalCurves.append(l_mainCurves[0])