def __init__(self, obj=None, aimFwd='z+', aimUp='y+', damp=7.0, objectScale=100, debug=False, showBake=False): PostBake.PostBake.__init__(self, obj=obj, showBake=showBake) self.aimFwd = VALID.simpleAxis(aimFwd) self.aimUp = VALID.simpleAxis(aimUp) self.debug = debug self._debugLoc = None self.damp = damp self.objectScale = objectScale self.dir = self.obj.getTransformDirection( self.aimFwd.p_vector) * self.objectScale self.aimTargetPos = self.obj.p_position + self.dir self.keyableAttrs = ['rx', 'ry', 'rz'] self.lastFwd = MATH.Vector3.forward() self.lastUp = MATH.Vector3.up()
def __init__(self, obj=None, velocityDamp=30.0, showBake=False): self.obj = None self.velocityDamp = velocityDamp self.showBake = showBake self.velocity = MATH.Vector3.zero() self.previousPosition = MATH.Vector3.zero() self.startPosition = MATH.Vector3.zero() if obj is None: self.obj = cgmMeta.asMeta(mc.ls(sl=True)[0]) else: self.obj = cgmMeta.asMeta(obj) self.aimFwd = VALID.simpleAxis('z+') self.aimUp = VALID.simpleAxis('y+') self.velocity = MATH.Vector3.zero() self.startPosition = VALID.euclidVector3Arg(self.obj.p_position) self.previousPosition = self.startPosition self.keyableAttrs = ['translate', 'rotate', 'scale'] self._bakedLoc = None self.startTime = int(mc.playbackOptions(q=True, min=True)) self.endTime = int(mc.playbackOptions(q=True, max=True))
def __init__(self, plane='screen', mode='position', planeObject=None, recordMode='combine', aimFwd='z+', aimUp='y+', onStart=None, onUpdate=None, onComplete=None, onReposition=None, onExit=None, postBlendFrames=6, loopTime=False, debug=False): _str_func = 'AnimDraw._init_' try: self.recordableObjs = [RecordableObj(x) for x in mc.ls(sl=True)] except: log.error("|{0}| >> No objects selected".format(_str_func)) return LiveRecord.__init__(self, onStart=onStart, onUpdate=onUpdate, onComplete=onComplete, onExit=onExit, loopTime=loopTime, debug=debug) self.onReposition = onReposition self.plane = plane self.postBlendFrames = postBlendFrames self.mode = mode self.planeObject = cgmMeta.asMeta(planeObject) if planeObject else None self.aimFwd = VALID.simpleAxis(aimFwd) self.aimUp = VALID.simpleAxis(aimUp) self.recordMode = recordMode self._currentPlaneObject = self.planeObject self._debugPlane = None self._debugLoc = None self._prevDataDict = {} self._useCache = False self._recordButtons = [1]
def __init__(self, obj=None, aimFwd='z+', aimUp='y+', damp=.1, angularDamp=.1, spring=1.0, maxDistance=100.0, objectScale=100, pushForce=8.0, springForce=5.0, angularSpringForce=5.0, collider=None, debug=False, showBake=False): PostBake.PostBake.__init__(self, obj=obj, showBake=showBake) self.aimFwd = VALID.simpleAxis(aimFwd) self.aimUp = VALID.simpleAxis(aimUp) self.pushForce = pushForce self.springForce = springForce self.angularSpringForce = angularSpringForce self.maxDistance = maxDistance self.positionForce = MATH.Vector3.zero() self.angularForce = MATH.Vector3.zero() self.spring = spring self.debug = debug self._debugLoc = None self._wantedPosLoc = None self._wantedUpLoc = None self.collider = cgmMeta.asMeta(collider) if collider else None self.damp = damp self.angularDamp = angularDamp self.objectScale = objectScale self.dir = self.obj.getTransformDirection( self.aimFwd.p_vector) * self.objectScale self.aimTargetPos = self.obj.p_position + self.dir self.upTargetPos = self.obj.getTransformDirection( self.aimUp.p_vector) * self.objectScale self.keyableAttrs = ['rx', 'ry', 'rz']
def __init__(self, obj=None, aimFwd='z+', aimUp='y+', damp=10, showBake=False): PostBake.PostBake.__init__(self, obj=obj, showBake=showBake) self.aimFwd = VALID.simpleAxis(aimFwd) self.aimUp = VALID.simpleAxis(aimUp) self.damp = damp self.keyableAttrs = ['rx', 'ry', 'rz'] self.lastFwd = MATH.Vector3.forward() self.lastUp = MATH.Vector3.up()
def uiFunc_set_chain_up(self, idx, upMenu): #print "Changing up on %s to %s" % ( chain.p_nameBase, upMenu.getValue() ) axis = upMenu.getValue() if axis == 'None': axis = None else: axis = VALID.simpleAxis(axis) self._mDynFK.chain_setOrientUpByIdx(idx, axis)
def closestAxisTowardObj_get(sourceObj, targetObj): v = sourceObj.getTransformInversePoint(targetObj.p_position).normalized() m = max( abs(v.x), abs(v.y), abs(v.z) ) va = ( int(v.x / abs(v.x)) if MATH.isclose(abs(v.x), m) else 0, int(v.y / abs(v.y)) if MATH.isclose(abs(v.y), m) else 0, int(v.z / abs(v.z)) if MATH.isclose(abs(v.z), m) else 0 ) return VALID.simpleAxis(va)
def closestAxisToObjAxis_get(sourceObj, targetObj, targetAxis): targetWorldAxisVector = targetObj.getTransformDirection(targetAxis.p_vector) v = sourceObj.getTransformInverseDirection(targetWorldAxisVector).normalized() m = max( abs(v.x), abs(v.y), abs(v.z) ) va = ( int(v.x / abs(v.x)) if MATH.isclose(abs(v.x), m) else 0, int(v.y / abs(v.y)) if MATH.isclose(abs(v.y), m) else 0, int(v.z / abs(v.z)) if MATH.isclose(abs(v.z), m) else 0 ) return VALID.simpleAxis(va)
mJnt.parent = _d_parents[mJnt] for mChild in _d_children[mJnt]: #if mChild not in ml_joints: #log.debug("|{0}| >> reparenting child: {1}".format(_str_func,mChild.mNode)) mChild.parent = mJnt if mJnt in ml_ends and mJnt not in ml_world: log.debug("|{0}| >> End joint. No world: {1}".format(_str_func,mJnt)) mJnt.jointOrient = 0,0,0 ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False) ml_joints = LISTS.get_noDuplicates(ml_joints) mAxis_aim = VALID.simpleAxis(axisAim) mAxis_up = VALID.simpleAxis(axisUp) _axisWorldUp = worldUpAxis str_aim = mAxis_aim.p_string str_up = mAxis_up.p_string if str_aim == str_up: raise ValueError,"axisAim and axisUp cannot be the same" _len = len(ml_joints) _d_parents = {} _d_children = {} ml_roots = [] ml_ends = [] ml_world =[] ml_done = []
def aim_atPoint(obj = None, position = [0,0,0], aimAxis = "z+", upAxis = "y+", mode = 'local',vectorUp = None,ignoreAimAttrs = False): """ Aim functionality. :parameters: obj(str): Object to modify position(array): object to copy from aimAxis(str): axis that is pointing forward upAxis(str): axis that is pointing up mode(str): 'local'-- use standard maya aiming with local axis 'world' -- use standard maya aiming with world axis 'matrix' -- use Bokser's fancy method 'vector' -- maya standard with vector up axis 'object' -- maya standard with object :returns success(bool) """ try: _str_func = 'aimAtPoint' _loc = False _obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj") try:position = position.x,position.y,position.z except:pass try:vectorUp = vectorUp.x,vectorUp.y,vectorUp.z except:pass log.debug("|{0}| >> obj: {1} | position:{2} | mode: {3}".format(_str_func,_obj,position,mode)) if not ignoreAimAttrs: _d_aim = ATTR.validate_arg(_obj,'axisAim') _d_up =ATTR.validate_arg(_obj,'axisUp') if ATTR.has_attr(_d_aim) and ATTR.has_attr(_d_up): aimAxis = ATTR.get_enumValueString(_d_aim) upAxis = ATTR.get_enumValueString(_d_up) log.debug("|{0}| >> obj: {1} aimable from attrs. aim: {2} | up: {3}".format(_str_func,_obj,aimAxis,upAxis)) if mode == 'matrix': '''Rotate transform based on look vector''' # get source and target vectors objPos = POS.get(_obj, asEuclid=True) targetPos = MATH.Vector3.Create(position) aim = (targetPos - objPos).normalized() if not vectorUp: upVector = MATH.Vector3.up() if upAxis == "y-": upVector = MATH.Vector3.down() elif upAxis == "z+": upVector = MATH.Vector3.forward() elif upAxis == "z-": upVector = MATH.Vector3.back() elif upAxis == "x+": upVector = MATH.Vector3.right() elif upAxis == "x-": upVector = MATH.Vector3.left() else: upVector = MATH.Vector3.up() vectorUp = MATH.transform_direction( _obj, upVector ) wantedAim, wantedUp = MATH.convert_aim_vectors_to_different_axis(aim, vectorUp, aimAxis, upAxis) xformPos = mc.xform(_obj, q=True, matrix = True, ws=True) pos = MATH.Vector3(xformPos[12], xformPos[13], xformPos[14]) rot_matrix = EUCLID.Matrix4.new_look_at(MATH.Vector3.zero(), -wantedAim, wantedUp) s = MATH.Vector3.Create( mc.xform(_obj, q=True, ws=True, s=True) ) scale_matrix = EUCLID.Matrix4() scale_matrix.a = s.x scale_matrix.f = s.y scale_matrix.k = s.z scale_matrix.p = 1 result_matrix = rot_matrix * scale_matrix transform_matrix = result_matrix[0:12] + [pos.x, pos.y, pos.z, 1.0] mc.xform(_obj, matrix = transform_matrix , roo="xyz", ws=True) """elif mode == 'world': _loc = mc.spaceLocator()[0] mc.move (position[0],position[1],position[2], _loc, ws=True) mAxis_aim = VALID.simpleAxis(aimAxis) mAxis_up = VALID.simpleAxis(upAxis) _constraint = mc.aimConstraint(_loc,_obj, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'scene',) mc.delete(_constraint + [_loc])""" elif mode in ['local','world','vector','object']: _loc = mc.spaceLocator(name='test')[0] _loc_snap = POS.create_loc(_obj) mc.move (position[0],position[1],position[2], _loc, ws=True) mAxis_aim = VALID.simpleAxis(aimAxis) mAxis_up = VALID.simpleAxis(upAxis) if mode == 'world': _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'scene',) elif mode == 'object': vectorUp = VALID.mNodeString(vectorUp) _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'object', worldUpObject = vectorUp) #worldUpVector = _vUp) else: if mode == 'vector': _vUp = vectorUp else: _vUp = MATH.get_obj_vector(_obj,upAxis) _constraint = mc.aimConstraint(_loc,_loc_snap, maintainOffset = False, aimVector = mAxis_aim.p_vector, upVector = mAxis_up.p_vector, worldUpType = 'vector', worldUpVector = _vUp) go(obj,_loc_snap) mc.delete(_constraint,_loc_snap) else: raise NotImplementedError,"mode: {0}".format(mode) if _loc:mc.delete(_loc) return True except Exception,err: try:mc.delete(_loc) except:pass log.error( "aim_atPoint | obj: {0} | err: {1}".format(obj,err) )
def build_aimSequence(l_driven = None, l_targets = None, l_parents = None, l_upTargets = None, msgLink_masterGroup = 'masterGroup', aim = [0,0,1], up = [0,1,0], mode = 'sequence',#sequence,singleBlend upMode = 'objRotation',#objRotation,decomposeMatrix upParent = [0,1,0], rootTargetEnd = None, rootTargetStart=None,#specify root targets by index and mObj mRoot = None,#need for sequence interpType = None, maintainOffset = False): """ This kind of setup is for setting up a blended constraint so that obj2 in an obj1/obj2/obj3 sequence can aim forward or back as can obj3. :parameters: l_jointChain1 - First set of objects :returns: :raises: Exception | if reached """ _str_func = 'build_aimSequence' ml_driven = cgmMeta.validateObjListArg(l_driven,'cgmObject') ml_targets = cgmMeta.validateObjListArg(l_targets,'cgmObject',noneValid=True) ml_parents = cgmMeta.validateObjListArg(l_parents,'cgmObject',noneValid=True) ml_upTargets = cgmMeta.validateObjListArg(l_upTargets,'cgmObject',noneValid=True) if not ml_upTargets: ml_upTargets = ml_parents axis_aim = VALID.simpleAxis(aim) axis_aimNeg = axis_aim.inverse axis_up = VALID.simpleAxis(up) v_aim = axis_aim.p_vector#aimVector v_aimNeg = axis_aimNeg.p_vector#aimVectorNegative v_up = axis_up.p_vector #upVector #cgmGEN.func_snapShot(vars()) if mode == 'singleBlend': if len(ml_targets) != 2: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 2 targets.".format(_str_func)) if len(ml_driven) != 1: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 1 driven obj.".format(_str_func)) if not ml_parents: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have handleParents.".format(_str_func)) if len(ml_parents) != 1: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 1 handleParent.".format(_str_func)) mDriven = ml_driven[0] if not mDriven.getMessage(msgLink_masterGroup): log.debug("|{0}| >> No master group, creating...".format(_str_func)) raise ValueError, log.error("|{0}| >> Add the create masterGroup setup, Josh".format(_str_func)) mMasterGroup = mDriven.getMessage(msgLink_masterGroup,asMeta=True)[0] s_rootTarget = False s_targetForward = ml_targets[-1].mNode s_targetBack = ml_targets[0].mNode i = 0 mMasterGroup.p_parent = ml_parents[i] mUpDecomp = None if upMode == 'decomposeMatrix': #Decompose matrix for parent... mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix') mUpDecomp.rename("{0}_aimMatrix".format(ml_parents[i].p_nameBase)) #mUpDecomp.doStore('cgmName',ml_parents[i]) #mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True) #mUpDecomp.doName() ATTR.connect("{0}.worldMatrix".format(ml_parents[i].mNode),"{0}.{1}".format(mUpDecomp.mNode,'inputMatrix')) d_worldUp = {'worldUpObject' : ml_parents[i].mNode, 'worldUpType' : 'vector', 'worldUpVector': [0,0,0]} elif upMode == 'objectRotation': d_worldUp = {'worldUpObject' : ml_parents[i].mNode, 'worldUpType' : 'objectRotation', 'worldUpVector': upParent} else: raise ValueError, log.error("|{0}| >> Unknown upMode: {1}".format(_str_func,upMode)) if s_targetForward: mAimForward = mDriven.doCreateAt() mAimForward.parent = mMasterGroup mAimForward.doStore('cgmTypeModifier','forward') mAimForward.doStore('cgmType','aimer') mAimForward.doName() _const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z', aimVector = v_aim, upVector = v_up, **d_worldUp) s_targetForward = mAimForward.mNode if mUpDecomp: ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) else: s_targetForward = ml_parents[i].mNode if s_targetBack: mAimBack = mDriven.doCreateAt() mAimBack.parent = mMasterGroup mAimBack.doStore('cgmTypeModifier','back') mAimBack.doStore('cgmType','aimer') mAimBack.doName() _const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z', aimVector = v_aimNeg, upVector = v_up, **d_worldUp) s_targetBack = mAimBack.mNode if mUpDecomp: ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) else: s_targetBack = s_rootTarget #ml_parents[i].mNode pprint.pprint([s_targetForward,s_targetBack]) mAimGroup = mDriven.doGroup(True,asMeta=True,typeModifier = 'aim') mDriven.parent = False const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0] d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mDriven.mNode,'followRoot'], [mDriven.mNode,'resultRootFollow'], [mDriven.mNode,'resultAimFollow'], 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 mDriven.parent = mAimGroup#...parent back mDriven.followRoot = .5 return True elif mode == 'sequence': """ if len(ml_targets) != 2: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 2 targets.".format(_str_func)) if len(ml_driven) != 1: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 1 driven obj.".format(_str_func)) if not ml_parents: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have handleParents.".format(_str_func)) if len(ml_parents) != 1: cgmGEN.func_snapShot(vars()) return log.error("|{0}| >> Single blend mode must have 1 handleParent.".format(_str_func)) """ for i,mDriven in enumerate(ml_driven): log.debug("|{0}| >> on: {1} | {2}".format(_str_func,i,mDriven)) mUpDecomp = False if not mDriven.getMessage(msgLink_masterGroup): log.debug("|{0}| >> No master group, creating...".format(_str_func)) raise ValueError, log.error("|{0}| >> Add the create masterGroup setup, Josh".format(_str_func)) mDriven.masterGroup.parent = ml_parents[i] if upMode == 'decomposeMatrix': #Decompose matrix for parent... mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix') mUpDecomp.rename("{0}_aimMatrix".format(ml_parents[i].p_nameBase)) #mUpDecomp.doStore('cgmName',ml_parents[i]) #mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True) #mUpDecomp.doName() ATTR.connect("{0}.worldMatrix".format(ml_upTargets[i].mNode),"{0}.{1}".format(mUpDecomp.mNode,'inputMatrix')) d_worldUp = {'worldUpObject' : ml_upTargets[i].mNode, 'worldUpType' : 'vector', 'worldUpVector': [0,0,0]} elif upMode == 'objectRotation': d_worldUp = {'worldUpObject' : ml_upTargets[i].mNode, 'worldUpType' : 'objectRotation', 'worldUpVector': upParent} else: raise ValueError, log.error("|{0}| >> Unknown upMode: {1}".format(_str_func,upMode)) s_rootTarget = False s_targetForward = False s_targetBack = False mMasterGroup = mDriven.masterGroup b_first = False if mDriven == ml_driven[0]: log.debug("|{0}| >> First handle: {1}".format(_str_func,mDriven)) if len(ml_driven) <=2: s_targetForward = ml_parents[-1].mNode else: s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0] if rootTargetStart: s_rootTarget = rootTargetStart.mNode else: s_rootTarget = mRoot.mNode b_first = True elif mDriven == ml_driven[-1]: log.debug("|{0}| >> Last handle: {1}".format(_str_func,mDriven)) if rootTargetEnd: s_rootTarget = rootTargetEnd.mNode else: s_rootTarget = ml_parents[i].mNode s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0] else: log.debug("|{0}| >> Reg handle: {1}".format(_str_func,mDriven)) s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0] s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0] #Decompose matrix for parent... """ mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix') mUpDecomp.doStore('cgmName',ml_parents[i]) mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True) mUpDecomp.doName() ATTR.connect("%s.worldMatrix"%(ml_parents[i].mNode),"%s.%s"%(mUpDecomp.mNode,'inputMatrix')) """ if s_targetForward: mAimForward = mDriven.doCreateAt() mAimForward.parent = mMasterGroup mAimForward.doStore('cgmTypeModifier','forward') mAimForward.doStore('cgmType','aimer') mAimForward.doName() _const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z', aimVector = v_aim, upVector = v_up,**d_worldUp) s_targetForward = mAimForward.mNode if mUpDecomp: ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) elif s_rootTarget: s_targetForward = s_rootTarget else: s_targetForward = ml_parents[i].mNode if s_targetBack: mAimBack = mDriven.doCreateAt() mAimBack.parent = mMasterGroup mAimBack.doStore('cgmTypeModifier','back') mAimBack.doStore('cgmType','aimer') mAimBack.doName() _const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z', aimVector = v_aimNeg, upVector = v_up, **d_worldUp) s_targetBack = mAimBack.mNode if mUpDecomp: ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) else: s_targetBack = s_rootTarget #ml_parents[i].mNode #pprint.pprint([s_targetForward,s_targetBack]) mAimGroup = mDriven.doGroup(True,asMeta=True,typeModifier = 'aim') mDriven.parent = False log.debug("|{0}| >> obj: {1} | {2}".format(_str_func,i,mDriven)) log.debug("|{0}| >> forward: {1}".format(_str_func,s_targetForward)) log.debug("|{0}| >> back: {1}".format(_str_func,s_targetBack)) log.debug(cgmGEN._str_subLine) if b_first: const = mc.orientConstraint([s_targetBack, s_targetForward], mAimGroup.mNode, maintainOffset = True)[0] else: const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0] d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mDriven.mNode,'followRoot'], [mDriven.mNode,'resultRootFollow'], [mDriven.mNode,'resultAimFollow'], 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 mDriven.parent = mAimGroup#...parent back if interpType: ATTR.set(const,'interpType',interpType) #if mDriven in [ml_driven[0],ml_driven[-1]]: # mDriven.followRoot = 1 #else: mDriven.followRoot = .5 return True raise ValueError,"Not done..." return for i,mObj in enumerate(ml_driven): return mObj.masterGroup.parent = ml_parents[i] s_rootTarget = False s_targetForward = False s_targetBack = False mMasterGroup = mObj.masterGroup b_first = False if mObj == ml_driven[0]: log.debug("|{0}| >> First handle: {1}".format(_str_func,mObj)) if len(ml_driven) <=2: s_targetForward = ml_parents[-1].mNode else: s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0] s_rootTarget = mRoot.mNode b_first = True elif mObj == ml_driven[-1]: log.debug("|{0}| >> Last handle: {1}".format(_str_func,mObj)) s_rootTarget = ml_parents[i].mNode s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0] else: log.debug("|{0}| >> Reg handle: {1}".format(_str_func,mObj)) s_targetForward = ml_driven[i+1].getMessage('masterGroup')[0] s_targetBack = ml_driven[i-1].getMessage('masterGroup')[0] #Decompose matrix for parent... mUpDecomp = cgmMeta.cgmNode(nodeType = 'decomposeMatrix') mUpDecomp.doStore('cgmName',ml_parents[i]) mUpDecomp.addAttr('cgmType','aimMatrix',attrType='string',lock=True) mUpDecomp.doName() ATTR.connect("%s.worldMatrix"%(ml_parents[i].mNode),"%s.%s"%(mUpDecomp.mNode,'inputMatrix')) if s_targetForward: mAimForward = mObj.doCreateAt() mAimForward.parent = mMasterGroup mAimForward.doStore('cgmTypeModifier','forward') mAimForward.doStore('cgmType','aimer') mAimForward.doName() _const=mc.aimConstraint(s_targetForward, mAimForward.mNode, maintainOffset = True, #skip = 'z', aimVector = [0,0,1], upVector = [1,0,0], worldUpObject = ml_parents[i].mNode, worldUpType = 'vector', worldUpVector = [0,0,0]) s_targetForward = mAimForward.mNode ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) else: s_targetForward = ml_parents[i].mNode if s_targetBack: mAimBack = mObj.doCreateAt() mAimBack.parent = mMasterGroup mAimBack.doStore('cgmTypeModifier','back') mAimBack.doStore('cgmType','aimer') mAimBack.doName() _const = mc.aimConstraint(s_targetBack, mAimBack.mNode, maintainOffset = True, #skip = 'z', aimVector = [0,0,-1], upVector = [1,0,0], worldUpObject = ml_parents[i].mNode, worldUpType = 'vector', worldUpVector = [0,0,0]) s_targetBack = mAimBack.mNode ATTR.connect("%s.%s"%(mUpDecomp.mNode,"outputRotate"),"%s.%s"%(_const[0],"upVector")) else: s_targetBack = s_rootTarget #ml_parents[i].mNode pprint.pprint([s_targetForward,s_targetBack]) mAimGroup = mObj.doGroup(True,asMeta=True,typeModifier = 'aim') mObj.parent = False if b_first: const = mc.orientConstraint([s_targetBack, s_targetForward], mAimGroup.mNode, maintainOffset = True)[0] else: const = mc.orientConstraint([s_targetForward, s_targetBack], mAimGroup.mNode, maintainOffset = True)[0] d_blendReturn = NODEFACTORY.createSingleBlendNetwork([mObj.mNode,'followRoot'], [mObj.mNode,'resultRootFollow'], [mObj.mNode,'resultAimFollow'], 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 mObj.parent = mAimGroup#...parent back if mObj in [ml_driven[0],ml_driven[-1]]: mObj.followRoot = 1 else: mObj.followRoot = .5
def crossAxis_get(axis): returnAxis = VALID.simpleAxis('y+') if axis.p_string[0] == 'y': returnAxis = VALID.simpleAxis('z+') return returnAxis
def test_vectorToAxis(self): for k, v in SHARED._d_axis_vector_to_string.iteritems(): self.assertEqual(validateArgs.simpleAxis(k).p_string, v)
def createWrapControlShape( targetObjects, targetGeo=None, latheAxis='z', aimAxis='y+', objectUp='y+', points=8, curveDegree=1, insetMult=None, #Inset multiplier minRotate=None, maxRotate=None, posOffset=[], rootOffset=[], #offset root before cast rootRotate=None, joinMode=False, extendMode=None, closedCurve=True, l_specifiedRotates=None, maxDistance=1000, closestInRange=True, vectorOffset=None, midMeshCast=False, subSize=None, #For ball on loli for example rotateBank=None, joinHits=None, #keys to processed hits to see what to join axisToCheck=['x', 'y'], **kws): #'segment,radial,disc' """ 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 = "createWrapControlShape" log.debug(">> %s >> " % (_str_func) + "=" * 75) _joinModes = [] _extendMode = [] if type(targetObjects) not in [list, tuple]: targetObjects = [targetObjects] targetGeo = VALID.objStringList(targetGeo, calledFrom=_str_func) assert type(points) is int, "Points must be int: %s" % points assert type(curveDegree) is int, "Points must be int: %s" % points assert curveDegree > 0, "Curve degree must be greater than 1: %s" % curveDegree if posOffset is not None and len(posOffset) and len(posOffset) != 3: raise StandardError, "posOffset must be len(3): %s | len: %s" % ( posOffset, len(posOffset)) if rootOffset is not None and len(rootOffset) and len(rootOffset) != 3: raise StandardError, "rootOffset must be len(3): %s | len: %s" % ( rootOffset, len(rootOffset)) if rootRotate is not None and len(rootRotate) and len(rootRotate) != 3: raise StandardError, "rootRotate must be len(3): %s | len: %s" % ( rootRotate, len(rootRotate)) if extendMode in ['loliwrap', 'cylinder', 'disc'] and insetMult is None: insetMult = 1 for axis in ['x', 'y', 'z']: if axis in latheAxis.lower(): latheAxis = axis log.debug("targetObjects: %s" % targetObjects) if len(aimAxis) == 2: single_aimAxis = aimAxis[0] else: single_aimAxis = aimAxis mAxis_aim = VALID.simpleAxis(aimAxis) log.debug("Single aim: %s" % single_aimAxis) log.debug("createWrapControlShape>> midMeshCast: %s" % midMeshCast) log.debug("|{0}| >> extendMode: {1}".format(_str_func, extendMode)) #>> Info l_groupsBuffer = [] il_curvesToCombine = [] l_sliceReturns = [] #Need to do more to get a better size #>> Build curves #================================================================= #> Root curve # log.debug("RootRotate: %s" % rootRotate) mi_rootLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc() if rootOffset: log.debug("rootOffset: %s" % rootOffset) mc.move(rootOffset[0], rootOffset[1], rootOffset[2], [mi_rootLoc.mNode], r=True, rpr=True, os=True, wd=True) if rootRotate is not None and len(rootRotate): log.debug("rootRotate: %s" % rootRotate) mc.rotate(rootRotate[0], rootRotate[1], rootRotate[2], [mi_rootLoc.mNode], os=True, r=True) #>> Root mi_rootLoc.doGroup() #Group to zero if extendMode == 'segment': log.debug("segment mode. Target len: %s" % len(targetObjects[1:])) if len(targetObjects) < 2: log.warning( "Segment build mode only works with two objects or more") else: if insetMult is not None: rootDistanceToMove = distance.returnDistanceBetweenObjects( targetObjects[0], targetObjects[1]) log.debug("rootDistanceToMove: %s" % rootDistanceToMove) mi_rootLoc.__setattr__('t%s' % latheAxis, rootDistanceToMove * insetMult) #mi_rootLoc.tz = (rootDistanceToMove*insetMult)#Offset it #Notes -- may need to play with up object for aim snapping #mi_upLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc() #mi_upLoc.doGroup()#To zero objectUpVector = dictionary.returnStringToVectors(objectUp) log.debug("objectUpVector: %s" % objectUpVector) #mi_uploc for i, obj in enumerate(targetObjects[1:]): log.debug("i: %s" % i) #> End Curve mi_endLoc = cgmMeta.cgmNode(obj).doLoc() aimVector = dictionary.returnStringToVectors(latheAxis + '-') log.debug("segment aimback: %s" % aimVector) #Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,aim=True,aimVector=aimVector,upVector=objectUpVector) #Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,orient=True) SNAP.go(mi_endLoc.mNode, mi_rootLoc.mNode, position=False, rotation=True) mi_endLoc.doGroup() if i == len(targetObjects[1:]) - 1: if insetMult is not None: log.debug("segment insetMult: %s" % insetMult) distanceToMove = distance.returnDistanceBetweenObjects( targetObjects[-1], targetObjects[0]) log.debug("distanceToMove: %s" % distanceToMove) #mi_endLoc.tz = -(distanceToMove*insetMult)#Offset it mi_endLoc.__setattr__('t%s' % latheAxis, -(distanceToMove * insetMult)) log.debug("segment lathe: %s" % latheAxis) log.debug("segment aim: %s" % aimAxis) log.debug("segment rotateBank: %s" % rotateBank) d_endCastInfo = createMeshSliceCurve( targetGeo, mi_endLoc, midMeshCast=midMeshCast, curveDegree=curveDegree, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) l_sliceReturns.append(d_endCastInfo) mi_end = cgmMeta.cgmObject(d_endCastInfo['curve']) il_curvesToCombine.append(mi_end) mc.delete(mi_endLoc.parent) #delete the loc elif extendMode == 'radial': log.debug("|{0}| >> radial...".format(_str_func)) d_handleInner = createMeshSliceCurve( targetGeo, mi_rootLoc, midMeshCast=midMeshCast, curveDegree=curveDegree, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=0, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject(d_handleInner['curve']) #instance curve l_sliceReturns.append(d_handleInner) il_curvesToCombine.append(mi_buffer) elif extendMode == 'disc': log.debug("|{0}| >> disc...".format(_str_func)) d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size #discOffset = d_size[ d_size.keys()[0]]*insetMult size = False l_absSize = [abs(i) for i in posOffset] if l_absSize: size = max(l_absSize) if not size: d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size log.debug("d_size: %s" % d_size) size = d_size[d_size.keys()[0]] * insetMult discOffset = size log.debug("d_size: %s" % d_size) log.debug("discOffset is: %s" % discOffset) mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset) if posOffset: tmp_posOffset = [ posOffset[0] * .5, posOffset[1] * .5, posOffset[2] * .5 ] d_handleInnerUp = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=tmp_posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerUp['curve']) #instance curve l_sliceReturns.append(d_handleInnerUp) il_curvesToCombine.append(mi_buffer) mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset) d_handleInnerDown = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=tmp_posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerDown['curve']) #instance curve l_sliceReturns.append(d_handleInnerDown) il_curvesToCombine.append(mi_buffer) mi_rootLoc.tz = 0 elif extendMode == 'cylinder': log.debug("|{0}| >> cylinder...".format(_str_func)) d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size discOffset = d_size[d_size.keys()[0]] * insetMult log.debug("d_size: %s" % d_size) log.debug("discOffset is: %s" % discOffset) mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset) d_handleInnerUp = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerUp['curve']) #instance curve l_sliceReturns.append(d_handleInnerUp) il_curvesToCombine.append(mi_buffer) mi_rootLoc.__setattr__('t%s' % latheAxis, 0) elif extendMode == 'loliwrap': log.debug("|{0}| >> lolipop...".format(_str_func)) #l_absSize = [abs(i) for i in posOffset] size = False #if l_absSize: #log.debug("l_absSize: %s"%l_absSize) #size = max(l_absSize)*1.25 if subSize is not None: size = subSize if not size: d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size log.info("d_size: %s" % d_size) l_size = d_size[single_aimAxis] size = l_size / 3 log.info("loli size: %s" % size) i_ball = cgmMeta.cgmObject( curves.createControlCurve('sphere', size=size)) elif extendMode == 'endCap': log.debug("|{0}| >> endCap...".format(_str_func)) returnBuffer1 = createMeshSliceCurve( targetGeo, mi_rootLoc.mNode, aimAxis='{0}+'.format(latheAxis), latheAxis=objectUp[0], curveDegree=curveDegree, maxDistance=maxDistance, closestInRange=closestInRange, closedCurve=False, l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90], posOffset=posOffset) mi_rootLoc.rotate = [0, 0, 0] mi_rootLoc.__setattr__('r%s' % latheAxis, 90) returnBuffer2 = createMeshSliceCurve( targetGeo, mi_rootLoc.mNode, aimAxis='{0}+'.format(latheAxis), latheAxis=objectUp[0], curveDegree=curveDegree, maxDistance=maxDistance, closedCurve=False, closestInRange=closestInRange, l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90], posOffset=posOffset) l_sliceReturns.extend([returnBuffer1, returnBuffer2]) il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer1)) il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer2)) mi_rootLoc.rotate = [0, 0, 0] #Now cast our root since we needed to move it with segment mode before casting if extendMode == 'cylinder': log.debug("|{0}| >> cylinder move...".format(_str_func)) mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset) log.debug("|{0}| >> Rootcast...".format(_str_func)) d_rootCastInfo = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, minRotate=minRotate, maxRotate=maxRotate, latheAxis=latheAxis, midMeshCast=midMeshCast, aimAxis=aimAxis, posOffset=posOffset, points=points, vectorOffset=vectorOffset, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) #d_rootCastInfo = createMeshSliceCurve(targetGeo,mi_rootLoc,**kws) log.debug("|{0}| >> Rootcast done".format(_str_func) + cgmGEN._str_subLine) if extendMode == 'disc': l_sliceReturns.insert(1, d_rootCastInfo) else: l_sliceReturns.insert(0, d_rootCastInfo) #Special loli stuff if extendMode == 'loliwrap': SNAP.go(i_ball.mNode, mi_rootLoc.mNode, True, True) #Snap to main object #log.debug("hitReturns: %s"%d_rootCastInfo['hitReturns']) #cgmGEN.walk_dat(d_rootCastInfo['hitReturns'],'hitReturns') mi_crv = cgmMeta.cgmObject(d_rootCastInfo['curve']) """ d_return = RayCast.findMeshIntersectionFromObjectAxis(targetGeo,mi_rootLoc.mNode,mAxis_aim.p_string) or {} if not d_return.get('hit'): log.info(d_return) raise ValueError,"No hit on loli check" pos = d_return.get('hit') dist = distance.returnDistanceBetweenPoints(i_ball.getPosition(),pos) * 2""" if vectorOffset is not None: dist = vectorOffset + subSize * 4 else: dist = max(posOffset) + subSize * 4 if '-' in aimAxis: distM = -dist else: distM = dist log.debug("distM: %s" % distM) #Move the ball pBuffer = i_ball.doGroup() i_ball.__setattr__('t%s' % single_aimAxis, distM) i_ball.parent = False mc.delete(pBuffer) uPos = distance.returnClosestUPosition(i_ball.mNode, mi_crv.mNode) SNAP.aim(i_ball.mNode, mi_rootLoc.mNode, aimAxis='z-') #if posOffset: #mc.move(posOffset[0]*3,posOffset[1]*3,posOffset[2]*3, [i_ball.mNode], r = True, rpr = True, os = True, wd = True) #Make the curve between the two mi_traceCrv = cgmMeta.cgmObject( mc.curve(degree=1, ep=[uPos, i_ball.getPosition()])) #Combine il_curvesToCombine.extend([i_ball, mi_traceCrv]) mi_root = cgmMeta.cgmObject(d_rootCastInfo['curve']) #instance curve il_curvesToCombine.append(mi_root) mc.delete(mi_rootLoc.parent) #delete the loc l_curvesToCombine = [mi_obj.mNode for mi_obj in il_curvesToCombine ] #Build our combine list before adding connectors log.debug("|{0}| >> processed: {1}".format( _str_func, d_rootCastInfo['processedHits'])) if joinMode and extendMode not in ['loliwrap', 'endCap' ] and len(l_sliceReturns) > 1: if joinHits: keys = d_rootCastInfo['processedHits'].keys() keys.sort() #goodDegrees = [] #for i,key in enumerate(keys): #if i in joinHits: #goodDegrees.append(key) goodDegrees = [key for i, key in enumerate(keys) if i in joinHits] log.debug("joinHits: %s" % joinHits) log.debug("goodDegrees: %s" % goodDegrees) else: goodDegrees = [ key for key in d_rootCastInfo['processedHits'].keys() ] #> Side Curves for degree in goodDegrees: l_pos = [] for d in l_sliceReturns: l_pos.append(d['processedHits'].get(degree) or False) while False in l_pos: l_pos.remove(False) log.debug("l_pos: %s" % l_pos) if len(l_pos) >= 2: try: l_curvesToCombine.append( mc.curve(d=curveDegree, ep=l_pos, os=True)) #Make the curve except: log.debug( "createWrapControlShape>>> skipping curve fail: %s" % (degree)) #>>Combine the curves newCurve = curves.combineCurves(l_curvesToCombine) mi_crv = cgmMeta.cgmObject(rigging.groupMeObject(targetObjects[0], False)) curves.parentShapeInPlace(mi_crv.mNode, newCurve) #Parent shape mc.delete(newCurve) #>>Copy tags and name mi_crv.doCopyNameTagsFromObject(targetObjects[0], ignore=['cgmType', 'cgmTypeModifier']) mi_crv.addAttr('cgmType', attrType='string', value='controlCurve', lock=True) mi_crv.doName() #Store for return return {'curve': mi_crv.mNode, 'instance': mi_crv}
def validateData(self): # Validate data in case it was manually changed #self.obj = cgmMeta.asMeta(self.obj) self.aimFwd = VALID.simpleAxis(self.aimFwd) self.aimUp = VALID.simpleAxis(self.aimUp)
def setAim(self, aimFwd=None, aimUp=None): if aimFwd: self.aimFwd = VALID.simpleAxis(aimFwd) if aimUp: self.aimUp = VALID.simpleAxis(aimUp)
def CreateChain(self, objs = None, fwd = 'z+', up='y+',name = None): _str_func = 'CreateChain' objs = cgmMeta.asMeta( mc.ls(sl=True) ) if not objs: return log.warning("No objects passed. Unable to createChain") if name is None: name = objs[-1].p_nameBase self.targets = self.targets + objs fwdAxis = simpleAxis(fwd) upAxis = simpleAxis(up) crvPositions = [] for obj in objs: crvPositions.append(obj.p_position) crvPositions.append( DIST.get_pos_by_axis_dist(objs[-1], fwdAxis.p_string, DIST.get_distance_between_points(crvPositions[-1],crvPositions[-2])) ) crvPositions.insert(0, DIST.get_pos_by_axis_dist(objs[0], fwdAxis.inverse.p_string, DIST.get_distance_between_points(crvPositions[0],crvPositions[1])*.5) ) crv = CORERIG.create_at(create='curve',l_pos= crvPositions, baseName = name) # make the dynamic setup b_existing = False if self.hairSystem != None: log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(self.hairSystem))) mc.select(self.hairSystem, add=True) b_existing = True mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }') # get relevant nodes follicle = mc.listRelatives(crv,parent=True)[0] mFollicle = cgmMeta.asMeta(follicle) mFollicle.rename("{0}_foll".format(name)) follicle = mFollicle.mNode self.ml_follicles.append(mFollicle) follicleShape = mc.listRelatives(mFollicle.mNode, shapes=True)[0] self.hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0], shapes=True)[0] if not b_existing: mHairSys = cgmMeta.asMeta(self.hairSystem) mHairSysDag = mHairSys.getTransform(asMeta=1) mHairSysDag.rename("{0}_hairSys".format(self.baseName)) self.hairSystem = mHairSys.mNode outCurve = mc.listConnections('%s.outCurve' % follicle)[0] outCurveShape = mc.listRelatives(outCurve, shapes=True)[0] self.nucleus = mc.listConnections( '%s.currentState' % self.hairSystem )[0] if not b_existing: pass mc.select( objs[0].getParent() ) self.follicles.append(follicle) self.outCurves.append(outCurve) # set default properties mc.setAttr( '%s.pointLock' % follicleShape, 1 ) mc.parentConstraint(objs[0].getParent(), follicle, mo=True) # create locators on objects locators = [] prs = [] for i, obj in enumerate(objs): loc = LOC.create(obj.getNameLong()) locators.append(loc) aimNull = mc.group(em=True) aimNull = mc.rename('%s_aim' % obj.getShortName()) poc = mc.createNode('pointOnCurveInfo', name='%s_pos' % loc) pocAim = mc.createNode('pointOnCurveInfo', name='%s_aim' % loc) pr = CURVES.getUParamOnCurve(loc, outCurve) 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(objs)-1: nextpr = CURVES.getUParamOnCurve(objs[i+1], outCurve) mc.setAttr('%s.parameter' % pocAim, (nextpr + pr) * .5) else: mc.setAttr( '%s.parameter' % pocAim, len(objs)+1 ) locParent = mc.group(em=True) locParent = mc.rename( '%s_pos' % obj.getShortName() ) mc.connectAttr( '%s.position' % poc, '%s.translate' % locParent) mc.connectAttr( '%s.position' % pocAim, '%s.translate' % aimNull) aimConstraint = mc.aimConstraint( aimNull, locParent, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = objs[0].getParent() ) mc.parent(loc, locParent)
def create_proxyGeo(proxyShape='cube', size=[1, 1, 1], direction='z+', ch=True): try: #cube:sphere:cylinder:cone:torus _str_func = 'create_proxyGeo' _proxyShape = _d_proxyCreate.get(proxyShape, proxyShape) _call = getattr(mc, _proxyShape, None) if not _call: raise ValueError, "Failed to find maya.cmds call {0}".format( _proxyShape) #if proxyShape not in _d_create.keys(): #raise ValueError,"Unknown shape: {0}".format(proxyShape) _kws = {'ch': ch} if proxyShape in ['cube']: _kws['width'] = size[0] _kws['ch'] = False if proxyShape in ['cylinder', 'sphere', 'cone', 'cylinder', 'torus']: _kws['radius'] = max(size) / 2.0 _kws['axis'] = VALID.simpleAxis(direction).p_vector _res = _call(**_kws) if size is not None: if VALID.isListArg(size): TRANS.scale_to_boundingBox(_res[0], size) else: if absoluteSize: _f_current = DIST.get_bb_size(_res[0], True, True) multiplier = size / _f_current mc.scale(multiplier, multiplier, multiplier, _res[0], relative=True) else: mc.scale(size, size, size, _res[0], os=True) #mc.makeIdentity(_res[0], apply=True,s=1) """ if proxyShape == 'cube': _d_directionXRotates = {'x+':[0,0,0],'x-':[0,180,0],'y+':[0,0,90],'y-':[0,0,-90],'z+':[0,-90,0],'z-':[0,90,0]} _r_factor = _d_directionXRotates.get(direction) mc.rotate (_r_factor[0], _r_factor[1], _r_factor[2], _res[0], ws=True)""" #mc.makeIdentity(_res[0], apply=True,r =1, n= 1) if proxyShape == 'cube': _children = TRANS.children_get(_res[0]) for i, c in enumerate(_children): _children[i] = TRANS.parent_set(c, False) combineShapes(_children + [_res[0]], keepSource=False, replaceShapes=False) return _res except Exception, err: cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def orientByPlane(joints = None, axisAim = 'z+', axisUp = 'y+', worldUpAxis = [0,1,0], planarMode = 'up', relativeOrient = True, progressBar=None, baseName = None, cleanUp = True, asMeta = True): """ Given a chain of joints, setup :parameters: planarMode - up/out - What plane to use :returns created(list) """ _str_func = 'orientPlane' ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False) ml_joints = LISTS.get_noDuplicates(ml_joints) mAxis_aim = VALID.simpleAxis(axisAim) mAxis_up = VALID.simpleAxis(axisUp) str_aim = mAxis_aim.p_string str_up = mAxis_up.p_string ml_delete = [] if str_aim == str_up: raise ValueError,"axisAim and axisUp cannot be the same" if len(ml_joints) < 3: raise ValueError,"{0} > Need more than 3 joints".format(_str_func) #First setup a dup chain of first and end, orient those ---------------------------------------------------------------- log.debug("|{0}| >> Setup tmp chain...".format(_str_func)) mStart = ml_joints[0].doDuplicate(parentOnly = True) mEnd = ml_joints[-1].doDuplicate(parentOnly = True) mEnd.parent = mStart orientChain([mStart,mEnd], axisAim, axisUp, worldUpAxis, relativeOrient) #Setup Loft curves and plane ---------------------------------------------------------------- log.debug("|{0}| >> Setup curves...".format(_str_func)) if planarMode == 'up': crvUp = mAxis_up.p_string crvDn = mAxis_up.inverse.p_string else: for a in 'xyz': if a not in str_aim and a not in str_up: mAxisCrv_tmp = VALID.simpleAxis(a+'+') crvUp = mAxisCrv_tmp.p_string crvDn = mAxisCrv_tmp.inverse.p_string d_distance = DIST.get_distance_between_targets([mStart.mNode,mEnd.mNode]) l_crvs = [] for mObj in [mStart,mEnd]: crv = mc.curve (d=1, ep = [DIST.get_pos_by_axis_dist(mObj.mNode, crvUp, d_distance), DIST.get_pos_by_axis_dist(mObj.mNode, crvDn, d_distance)], os=True) log.debug("|{0}| >> Created: {1}".format(_str_func,crv)) l_crvs.append(crv) _res_body = mc.loft(l_crvs, o = True, d = 1, po = 1 ) _inputs = mc.listHistory(_res_body[0],pruneDagObjects=True) _tessellate = _inputs[0] _d = {'format':2,#General 'polygonType':1,#'quads' } for a,v in _d.iteritems(): ATTR.set(_tessellate,a,v) #Snap our joints --------------------------------------------------------------------------------- for mJnt in ml_joints[1:-1]: ml_children = mJnt.getChildren(asMeta=True) for mChild in ml_children: mChild.parent = False SNAP.go(mJnt, _res_body[0], rotation=False, pivot='closestPoint') for mChild in ml_children: mChild.parent = mJnt #Cleanup -------------------------------------------------------------------------------------------- if cleanUp: mc.delete(_res_body + l_crvs) mStart.delete() orientChain(ml_joints, axisAim, axisUp, worldUpAxis, relativeOrient,progressBar) return l_start = [] l_end = [] mStartCrv = mc.curve() mc.curve (d=1, ep = posList, os=True)
def snap_action(objects=None, snapMode='point', selectionMode='eachToLast', **kws): """ """ try: _str_func = 'snap_action' subKWS = {} if objects is None: objects = mc.ls(sl=True) if snapMode == 'aim': aim_axis = SHARED._l_axis_by_string[var_objDefaultAimAxis.value] up_axis = SHARED._l_axis_by_string[var_objDefaultUpAxis.value] subKWS = { 'aimAxis': aim_axis, 'upAxis': up_axis, 'mode': var_aimMode.value } if selectionMode == 'firstToRest': MMCONTEXT.func_process(SNAP.aim_atMidPoint, objects, selectionMode, 'Snap aim', **subKWS) else: MMCONTEXT.func_process(SNAP.aim, objects, selectionMode, 'Snap aim', **subKWS) if selectionMode == 'eachToNext': SNAP.aim(objects[-1], objects[-2], VALID.simpleAxis(aim_axis).inverse.p_string, up_axis, var_aimMode.value) elif snapMode == 'ground': MMCONTEXT.func_process(SNAP.to_ground, objects, 'each', 'Snap') elif snapMode in [ 'axisBox', 'boundingBox', 'boundingBoxShapes', 'boundingBoxEach', 'castCenter', 'castFar', 'castNear', 'castAllCenter', 'castAllFar', 'castAllNear' ]: log.debug("|{0}| | special mode: {1}".format(_str_func, snapMode)) subKWS['mode'] = kws.get('mode', 'z+') subKWS['arg'] = snapMode if len(objects) == 1: specialSnap(objects[0], **subKWS) elif snapMode in ['boundingBox'] and selectionMode != 'each': log.debug("|{0}| | bb each mode".format(_str_func, snapMode)) specialSnap(objects[0], objects, **subKWS) else: MMCONTEXT.func_process(specialSnap, objects, selectionMode, 'Snap Special', **subKWS) else: subKWS = { 'position': False, 'rotation': False, 'rotateAxis': False, 'rotateOrder': False, 'scalePivot': False, 'pivot': 'rp', 'space': 'w', 'mode': 'xform' } if snapMode in ['point', 'closestPoint']: subKWS['position'] = True elif snapMode == 'orient': subKWS['rotation'] = True elif snapMode == 'parent': subKWS['position'] = True subKWS['rotation'] = True elif snapMode == 'aim': subKWS['rotation'] = True else: raise ValueError, "Unknown mode!" _pivotMode = var_snapPivotMode.value if snapMode == 'closestPoint': subKWS['pivot'] = 'closestPoint' else: if not _pivotMode: pass #0 handled by default elif _pivotMode == 1: subKWS['pivot'] = 'sp' elif _pivotMode == 2: subKWS['pivot'] = 'boundingBox' else: raise ValueError, "Uknown pivotMode: {0}".format( _pivotMode) MMCONTEXT.func_process(SNAP.go, objects, selectionMode, 'Snap', **subKWS) mc.select(objects) return except Exception, err: cgmGEN.cgmExceptCB(Exception, err, msg=vars())
def test_axisToStrings(self): for k, v in SHARED._d_axis_string_to_vector.iteritems(): self.assertEqual(validateArgs.simpleAxis(k).p_vector, v) for k, v in SHARED._d_axis_string_to_vector.iteritems(): self.assertEqual(validateArgs.simpleAxis(v).p_string, k)