def bake(connection_data, start, end): bake_range = range( int(math.floor(start)), int(math.floor(end+1))) if end < start: bake_range = range(int(math.floor(end)),int(math.floor(start+1))) bake_range.reverse() for i in bake_range: mc.currentTime(i) for conn in connection_data: source_pos = POS.get(conn['source']) if conn['setPosition']: positionOffset = euclid.Vector3(0,0,0) if 'positionOffset' in conn: pos = conn['positionOffset'] positionOffset = euclid.Vector3(pos[0], pos[1], pos[2]) wanted_position = source_pos + positionOffset POS.set(conn['target'], [wanted_position.x, wanted_position.y, wanted_position.z]) mc.setKeyframe('%s.translate' % conn['target']) target_pos = POS.get(conn['target']) if conn['setRotation']: offsetForward = euclid.Vector3(0,0,1) if 'offsetForward' in conn: fwd = conn['offsetForward'] offsetForward = euclid.Vector3(fwd[0], fwd[1], fwd[2]) offsetUp = euclid.Vector3(0,1,0) if 'offsetUp' in conn: up = conn['offsetUp'] offsetUp = euclid.Vector3(up[0], up[1], up[2]) fwd = TRANS.transformDirection(conn['source'], offsetForward) up = TRANS.transformDirection(conn['source'], offsetUp) SNAP.aim_atPoint(conn['target'], target_pos + fwd, vectorUp=up, mode='matrix') mc.setKeyframe('%s.rotate' % conn['target'])
def update(self, deltaTime=.04): #dir = self.obj.getTransformDirection(self.aimFwd.p_vector) self.dir = self._bakedLoc.getTransformDirection( self.aimFwd.p_vector) * self.objectScale if self.translate: self.obj.p_position = MATH.Vector3.Lerp( VALID.euclidVector3Arg(self.previousPosition), VALID.euclidVector3Arg(self._bakedLoc.p_position), deltaTime * self.damp) if self.rotate: wantedTargetPos = ( (VALID.euclidVector3Arg(self.obj.p_position) + self.dir) - self.obj.p_position ).normalized() * self.objectScale + self.obj.p_position self.lastUp = MATH.Vector3.Lerp( self.lastUp, self._bakedLoc.getTransformDirection(self.aimUp.p_vector), min(deltaTime * self.damp, 1.0)).normalized() self.aimTargetPos = ( MATH.Vector3.Lerp(self.aimTargetPos, wantedTargetPos, deltaTime * self.damp) - self.obj.p_position ).normalized() * self.objectScale + self.obj.p_position self.upTargetPos = ( MATH.Vector3.Lerp(self.aimTargetPos, wantedTargetPos, deltaTime * self.damp) - self.obj.p_position ).normalized() * self.objectScale + self.obj.p_position self.lastFwd = MATH.Vector3.Lerp( self.lastFwd, self._bakedLoc.getTransformDirection(self.aimFwd.p_vector), min(deltaTime * self.damp, 1.0)).normalized() SNAP.aim_atPoint(obj=self.obj.mNode, mode='matrix', position=self.aimTargetPos, aimAxis=self.aimFwd.p_string, upAxis=self.aimUp.p_string, vectorUp=self.lastUp) if self.debug: if not self._debugLoc: self._debugLoc = cgmMeta.asMeta(LOC.create(name='debug_loc')) self._debugLoc.p_position = self.aimTargetPos mc.setKeyframe(self._debugLoc.mNode, at='translate')
def update(self, deltaTime=.04): #log.info("Updating") self.dir = self._bakedLoc.getTransformDirection( self.aimFwd.p_vector) * self.objectScale wantedTargetPos = ( (VALID.euclidVector3Arg(self.obj.p_position) + self.dir) - self.obj .p_position).normalized() * self.objectScale + self.obj.p_position wantedUp = self._bakedLoc.getTransformDirection( self.aimUp.p_vector) * self.objectScale self.positionForce = self.positionForce + ( (wantedTargetPos - self.aimTargetPos) * self.springForce) self.positionForce = self.positionForce * (1.0 - self.damp) self.angularForce = self.angularForce + ( (wantedUp - self.upTargetPos) * self.angularSpringForce) self.angularForce = self.angularForce * (1.0 - self.angularDamp) self.aimTargetPos = self.aimTargetPos + (self.positionForce * deltaTime) self.upTargetPos = self.upTargetPos + (self.angularForce * deltaTime) SNAP.aim_atPoint(obj=self.obj.mNode, mode='matrix', position=self.aimTargetPos, aimAxis=self.aimFwd.p_string, upAxis=self.aimUp.p_string, vectorUp=self.upTargetPos.normalized()) if self.debug: if not self._debugLoc: self._debugLoc = cgmMeta.asMeta(LOC.create(name='debug_loc')) self._debugLoc.p_position = self.aimTargetPos mc.setKeyframe(self._debugLoc.mNode, at='translate') if not self._wantedUpLoc: self._wantedUpLoc = cgmMeta.asMeta( LOC.create(name='wanted_up_loc')) self._wantedUpLoc.p_position = self.obj.p_position + self.upTargetPos mc.setKeyframe(self._wantedUpLoc.mNode, at='translate') if not self._wantedPosLoc: self._wantedPosLoc = cgmMeta.asMeta( LOC.create(name='wanted_pos_loc')) self._wantedPosLoc.p_position = wantedTargetPos mc.setKeyframe(self._wantedPosLoc.mNode, at='translate')
def update(self, deltaTime=.04): self.lastUp = MATH.Vector3.Lerp( self.lastUp, self._bakedLoc.getTransformDirection(self.aimUp.p_vector), min(deltaTime * self.damp, 1.0)).normalized() self.lastFwd = MATH.Vector3.Lerp(self.lastFwd, self.velocity.normalized(), min(deltaTime * self.damp, 1.0)).normalized() SNAP.aim_atPoint(obj=self.obj.mNode, mode='vector', position=self.obj.p_position + self.lastFwd, aimAxis=self.aimFwd.p_string, upAxis=self.aimUp.p_string, vectorUp=self.lastUp)
def restoreBakedLocFromData(self, frame=None): if frame is None: frame = int(mc.currentTime(q=True)) if self._bakedLoc and frame in self._prevDataDict: self._bakedLoc.p_position = self._prevDataDict[frame]['p'] SNAP.aim_atPoint(obj=self._bakedLoc.mNode, mode='matrix', position=self._prevDataDict[frame]['p'] + self._prevDataDict[frame]['f'], aimAxis='z+', upAxis='y+', vectorUp=self._prevDataDict[frame]['u']) return True return False
def projectOntoPlane(self, vector): _str_func = 'LiveRecord.projectOntoPlane' camPos = VALID.euclidVector3Arg(self.cam.p_position) planeNormal = self.planeNormal if self.plane in ['custom', 'object']: planeNormal = VALID.euclidVector3Arg( self._currentPlaneObject.getTransformDirection( self.planeNormal)) log.info('Current plane object : {0}'.format(self._currentPlaneObject)) self.planePoint = VALID.euclidVector3Arg( self._currentPlaneObject.p_position) rayPoint = VALID.euclidVector3Arg(self.cam.p_position) rayDirection = VALID.euclidVector3Arg(vector) plane = EUCLID.Plane( EUCLID.Point3(self.planePoint.x, self.planePoint.y, self.planePoint.z), EUCLID.Point3(planeNormal.x, planeNormal.y, planeNormal.z)) pos = plane.intersect( EUCLID.Line3( EUCLID.Point3(rayPoint.x, rayPoint.y, rayPoint.z), EUCLID.Vector3(rayDirection.x, rayDirection.y, rayDirection.z))) if self._debugPlane: self._debugPlane.p_position = self.planePoint SNAP.aim_atPoint(obj=self._debugPlane.mNode, mode='matrix', position=self.planePoint + planeNormal, aimAxis='y+', upAxis='z+', vectorUp=planeNormal.cross( EUCLID.Vector3(0, 1, .01))) return pos
def aimObjToPlane(self, vector): _str_func = 'LiveRecord.aimObjToPlane' wantedPos = self.projectOntoPlane(vector) vectorUp = VALID.euclidVector3Arg( self._currentPlaneObject.getTransformDirection( self._offsetUpVector)) for recordable in self.recordableObjs: SNAP.aim_atPoint(obj=recordable.obj, mode='matrix', position=wantedPos, aimAxis=self.aimFwd.p_string, upAxis=self.aimUp.p_string, vectorUp=vectorUp) mc.setKeyframe([x.obj.mNode for x in self.recordableObjs], at=self.keyableAttrs) if self._debugLoc: self._debugLoc.p_position = wantedPos mc.setKeyframe(self._debugLoc.mNode, at='translate')
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())
def settings(self, settingsPlace=None, ml_targets=None): try: _str_func = 'rp' log_start(_str_func) log.debug("|{0}| >> settings: {1}...".format(_str_func, settingsPlace)) mBlock = self.mBlock mRigNull = self.mRigNull _offset = self.v_offset _jointOrientation = self.d_orientation['str'] if settingsPlace == None: settingsPlace = mBlock.getEnumValueString('settingsPlace') if settingsPlace == 'cog': mCog = mRigNull.getMessageAsMeta('rigRoot') if mCog: log.debug("|{0}| >> Settings is cog...".format(_str_func)) mRigNull.connectChildNode(mCog, 'settings', 'rigNull') #Connect return mCog else: log.warning( "|{0}| >> Settings. Cog option but no cog found...".format( _str_func)) settingsPlace = 'start' mSettingsHelper = mBlock.getMessageAsMeta('settingsHelper') if settingsPlace in ['start', 'end']: if settingsPlace == 'start': _mTar = ml_targets[0] else: _mTar = ml_targets[self.int_handleEndIdx] #_settingsSize = _offset * 2 if not mSettingsHelper: mMesh_tmp = mBlock.atUtils('get_castMesh') str_meshShape = mMesh_tmp.getShapes()[0] d_directions = { 'up': 'y+', 'down': 'y-', 'in': 'x+', 'out': 'x-' } str_settingsDirections = d_directions.get( mBlock.getEnumValueString('settingsDirection'), 'y+') pos = RAYS.get_cast_pos(_mTar.mNode, str_settingsDirections, shapes=str_meshShape) if not pos: log.debug( cgmGEN.logString_msg(_str_func, 'standard IK end')) pos = _mTar.getPositionByAxisDistance( str_settingsDirections, _offset * 5) vec = MATH.get_vector_of_two_points(_mTar.p_position, pos) newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4) _settingsSize = _offset * 2 mSettingsShape = cgmMeta.validateObjArg(CURVES.create_fromName( 'gear', _settingsSize, '{0}+'.format(_jointOrientation[2]), baseSize=1.0), 'cgmObject', setClass=True) mSettingsShape.doSnapTo(_mTar.mNode) #SNAPCALLS.get_special_pos([_mTar,str_meshShape],'castNear',str_settingsDirections,False) mSettingsShape.p_position = newPos mMesh_tmp.delete() SNAP.aim_atPoint( mSettingsShape.mNode, _mTar.p_position, aimAxis=_jointOrientation[0] + '+', mode='vector', vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-')) else: mSettingsShape = mSettingsHelper.doDuplicate(po=False) mSettingsShape.parent = _mTar mSettings = mSettingsShape CORERIG.match_orientation(mSettings.mNode, _mTar.mNode) ATTR.copy_to(self.mModule.mNode, 'cgmName', mSettings.mNode, driven='target') mSettings.doStore('cgmTypeModifier', 'settings') mSettings.doName() self.mHandleFactory.color(mSettings.mNode, controlType='sub') mRigNull.connectChildNode(mSettings, 'settings', 'rigNull') #Connect #cgmGEN.func_snapShot(vars()) #mSettings.select() else: raise ValueError, "Unknown settingsPlace: {1}".format( settingsPlace) return mSettings except Exception, err: cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def 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))